前端代码

node_modules/rx/ts/core/disposables/booleandisposable.ts

@@ -0,0 +1,52 @@
+/// <reference path="./disposable.ts" />
+module Rx {
+    export interface SingleAssignmentDisposable {
+        /** Performs the task of cleaning up resources. */
+        dispose(): void;
+
+        /** Is this value disposed. */
+        isDisposed: boolean;
+
+        getDisposable(): IDisposable;
+
+        setDisposable(value: IDisposable): void;
+    }
+
+    interface SingleAssignmentDisposableStatic {
+        new() : SingleAssignmentDisposable;
+    }
+
+    export var SingleAssignmentDisposable : SingleAssignmentDisposableStatic;
+
+    export interface SerialDisposable {
+        /** Performs the task of cleaning up resources. */
+        dispose(): void;
+
+        /** Is this value disposed. */
+        isDisposed: boolean;
+
+        getDisposable(): IDisposable;
+
+        setDisposable(value: IDisposable): void;
+    }
+
+    interface SerialDisposableStatic {
+        new() : SerialDisposable;
+    }
+
+    export var SerialDisposable : SerialDisposableStatic;
+}
+
+(function() {
+    var sad: Rx.SingleAssignmentDisposable = new Rx.SingleAssignmentDisposable();
+    sad.dispose();
+    sad.isDisposed;
+    var d = sad.getDisposable();
+    sad.setDisposable(d);
+    
+    var sad: Rx.SerialDisposable = new Rx.SerialDisposable();
+    sad.dispose();
+    sad.isDisposed;
+    var d = sad.getDisposable();
+    sad.setDisposable(d);
+});

node_modules/rx/ts/core/disposables/compositedisposable.ts

@@ -0,0 +1,48 @@
+/// <reference path="./disposable.ts" />
+module Rx {
+    /**
+     * Represents a group of disposable resources that are disposed together.
+     * @constructor
+     */
+    export interface CompositeDisposable extends Disposable {
+        /**
+         * Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed.
+         * @param {Mixed} item Disposable to add.
+         */
+        add(item: IDisposable): void;
+
+        /**
+         * Removes and disposes the first occurrence of a disposable from the CompositeDisposable.
+         * @param {Mixed} item Disposable to remove.
+         * @returns {Boolean} true if found; false otherwise.
+         */
+        remove(item: IDisposable): void;
+    }
+
+    interface CompositeDisposableStatic {
+        /**
+         * Represents a group of disposable resources that are disposed together.
+         * @constructor
+         */
+        new (...disposables: Rx.IDisposable[]): CompositeDisposable;
+        /**
+         * Represents a group of disposable resources that are disposed together.
+         * @constructor
+         */
+        new(disposables: Rx.IDisposable[]): CompositeDisposable;
+    }
+
+    export var CompositeDisposable: CompositeDisposableStatic;
+}
+
+(function() {
+    var cd = new Rx.CompositeDisposable();
+    var cd = new Rx.CompositeDisposable(Rx.Disposable.create(() => { }));
+    var cd = new Rx.CompositeDisposable([Rx.Disposable.create(() => { })]);
+
+    cd.add(Rx.Disposable.create(() => { }));
+    cd.remove(Rx.Disposable.create(() => { }));
+
+    cd.dispose();
+    cd.isDisposed;
+})

node_modules/rx/ts/core/disposables/disposable.ts

@@ -0,0 +1,57 @@
+module Rx {
+    export interface IDisposable {
+        dispose(): void;
+    }
+
+    export interface Disposable extends IDisposable {
+        /** Is this value disposed. */
+        isDisposed?: boolean;
+    }
+
+    interface DisposableStatic {
+        /**
+         * Provides a set of static methods for creating Disposables.
+         * @param {Function} dispose Action to run during the first call to dispose. The action is guaranteed to be run at most once.
+         */
+        new (action: () => void): Disposable;
+
+        /**
+         * Creates a disposable object that invokes the specified action when disposed.
+         * @param {Function} dispose Action to run during the first call to dispose. The action is guaranteed to be run at most once.
+         * @return {Disposable} The disposable object that runs the given action upon disposal.
+         */
+        create(action: () => void): Disposable;
+
+        /**
+         * Gets the disposable that does nothing when disposed.
+         */
+        empty: IDisposable;
+
+        /**
+         * Validates whether the given object is a disposable
+         * @param {Object} Object to test whether it has a dispose method
+         * @returns {Boolean} true if a disposable object, else false.
+         */
+        isDisposable(d: any): boolean;
+    }
+
+    /**
+     * Provides a set of static methods for creating Disposables.
+     * @param {Function} dispose Action to run during the first call to dispose. The action is guaranteed to be run at most once.
+     */
+    export var Disposable: DisposableStatic;
+}
+
+(function() {
+    var id: Rx.IDisposable;
+    var d : Rx.Disposable;
+
+    id.dispose();
+    d.dispose();
+
+    d.isDisposed;
+
+    Rx.Disposable.create(() => {})
+    Rx.Disposable.empty;
+    Rx.Disposable.isDisposable(d);
+})

node_modules/rx/ts/core/disposables/refcountdisposable.ts

@@ -0,0 +1,39 @@
+/// <reference path="./disposable.ts" />
+module Rx {
+    /**
+     * Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed.
+     */
+    export interface RefCountDisposable extends Disposable {
+
+        /** Performs the task of cleaning up resources. */
+        dispose(): void;
+
+        /** Is this value disposed. */
+        isDisposed: boolean;
+
+        /**
+         * Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable.
+         * @returns {Disposable} A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime.
+         */
+        getDisposable(): IDisposable;
+    }
+
+    interface RefCountDisposableStatic {
+        /**
+         * Initializes a new instance of the RefCountDisposable with the specified disposable.
+         * @constructor
+         * @param {Disposable} disposable Underlying disposable.
+         */
+        new(disposable: IDisposable): RefCountDisposable;
+    }
+
+    export var RefCountDisposable : RefCountDisposableStatic;
+}
+
+(function() {
+    var d = Rx.Disposable.create(() => {});
+    var rcd = new Rx.RefCountDisposable(d);
+    d = rcd.getDisposable();
+    rcd.dispose();
+    rcd.isDisposed;
+})