前端代码

node_modules/rx/ts/core/internal/bindcallback.ts

@@ -0,0 +1,9 @@
+module Rx {
+    export module internals {
+        export var bindCallback: (func: Function, thisArg: any, argCount: number) => Function;
+    }
+}
+
+(function() {
+    Rx.internals.bindCallback(() => {}, null, 100);
+});

node_modules/rx/ts/core/internal/errors.ts

@@ -0,0 +1,23 @@
+module Rx {
+    export module internals {
+        export interface EmptyError extends Error { message: string; }
+        export interface EmptyErrorStatic { new (): EmptyError; }
+
+        export interface ObjectDisposedError extends Error { message: string; }
+        export interface ObjectDisposedErrorStatic { new (): ObjectDisposedError; }
+
+        export interface ArgumentOutOfRangeError extends Error { message: string; }
+        export interface ArgumentOutOfRangeErrorStatic { new (): ArgumentOutOfRangeError; }
+
+        export interface NotSupportedError extends Error { message: string; }
+        export interface NotSupportedErrorStatic { new (): NotSupportedError; }
+
+        export interface NotImplementedError extends Error { message: string; }
+        export interface NotImplementedErrorStatic { new (): NotImplementedError; }
+    }
+
+    export module helpers {
+        export var notImplemented: () => internals.NotImplementedError;
+        export var notSupported: () => internals.NotSupportedError;
+    }
+}

node_modules/rx/ts/core/internal/isequal.ts

@@ -0,0 +1,9 @@
+module Rx {
+    export module internals {
+        export var isEqual : (left: any, right: any) => boolean;
+    }
+}
+
+(function() {
+    var b : boolean = Rx.internals.isEqual(1, 1);
+});

node_modules/rx/ts/core/internal/priorityqueue.ts

@@ -0,0 +1,40 @@
+/// <reference path="../concurrency/scheduleditem.ts" />
+module Rx {
+    export module internals {
+        // Priority Queue for Scheduling
+        export interface PriorityQueue<TTime> {
+            length: number;
+
+            isHigherPriority(left: number, right: number): boolean;
+            percolate(index: number): void;
+            heapify(index: number): void;
+            peek(): ScheduledItem<TTime>;
+            removeAt(index: number): void;
+            dequeue(): ScheduledItem<TTime>;
+            enqueue(item: ScheduledItem<TTime>): void;
+            remove(item: ScheduledItem<TTime>): boolean;
+        }
+
+        interface PriorityQueueStatic {
+                new <T>(capacity: number) : PriorityQueue<T>;
+                count: number;
+        }
+
+        export var PriorityQueue : PriorityQueueStatic;
+    }
+}
+
+(function() {
+    var queue = new Rx.internals.PriorityQueue<number>(100);
+    var n : number = queue.length
+    var b : boolean = queue.isHigherPriority(1, 100);
+    queue.percolate(100);
+    queue.heapify(100);
+    var item: Rx.internals.ScheduledItem<number> = queue.peek();
+    queue.removeAt(100);
+    var item: Rx.internals.ScheduledItem<number> = queue.dequeue();
+    queue.enqueue(item);
+    b = queue.remove(item);
+
+    n = Rx.internals.PriorityQueue.count;
+});

node_modules/rx/ts/core/internal/util.ts

@@ -0,0 +1,15 @@
+/// <reference path="../disposables/disposable.ts" />
+/// <reference path="../observable.ts" />
+module Rx {
+    export module internals {
+        export var inherits: (child: any, parent: any) => void;
+        export var addProperties: (obj: any, ...sources: any[]) => void;
+        export var addRef: <T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }) => Observable<T>;
+    }
+}
+
+(function() {
+    Rx.internals.inherits(null, null);
+    Rx.internals.addProperties({}, 1, 2, 3);
+    var o: Rx.Observable<number> = Rx.internals.addRef(<Rx.Observable<number>>{}, new Rx.SingleAssignmentDisposable());
+});