update

node_modules/rxjs/_esm2015/observable/BoundNodeCallbackObservable.js

@@ -0,0 +1,241 @@
+import { Observable } from '../Observable';
+import { tryCatch } from '../util/tryCatch';
+import { errorObject } from '../util/errorObject';
+import { AsyncSubject } from '../AsyncSubject';
+/**
+ * We need this JSDoc comment for affecting ESDoc.
+ * @extends {Ignored}
+ * @hide true
+ */
+export class BoundNodeCallbackObservable extends Observable {
+    constructor(callbackFunc, selector, args, context, scheduler) {
+        super();
+        this.callbackFunc = callbackFunc;
+        this.selector = selector;
+        this.args = args;
+        this.context = context;
+        this.scheduler = scheduler;
+    }
+    /* tslint:enable:max-line-length */
+    /**
+     * Converts a Node.js-style callback API to a function that returns an
+     * Observable.
+     *
+     * <span class="informal">It's just like {@link bindCallback}, but the
+     * callback is expected to be of type `callback(error, result)`.</span>
+     *
+     * `bindNodeCallback` is not an operator because its input and output are not
+     * Observables. The input is a function `func` with some parameters, but the
+     * last parameter must be a callback function that `func` calls when it is
+     * done. The callback function is expected to follow Node.js conventions,
+     * where the first argument to the callback is an error object, signaling
+     * whether call was successful. If that object is passed to callback, it means
+     * something went wrong.
+     *
+     * The output of `bindNodeCallback` is a function that takes the same
+     * parameters as `func`, except the last one (the callback). When the output
+     * function is called with arguments, it will return an Observable.
+     * If `func` calls its callback with error parameter present, Observable will
+     * error with that value as well. If error parameter is not passed, Observable will emit
+     * second parameter. If there are more parameters (third and so on),
+     * Observable will emit an array with all arguments, except first error argument.
+     *
+     * Optionally `bindNodeCallback` accepts selector function, which allows you to
+     * make resulting Observable emit value computed by selector, instead of regular
+     * callback arguments. It works similarly to {@link bindCallback} selector, but
+     * Node.js-style error argument will never be passed to that function.
+     *
+     * Note that `func` will not be called at the same time output function is,
+     * but rather whenever resulting Observable is subscribed. By default call to
+     * `func` will happen synchronously after subscription, but that can be changed
+     * with proper {@link Scheduler} provided as optional third parameter. Scheduler
+     * can also control when values from callback will be emitted by Observable.
+     * To find out more, check out documentation for {@link bindCallback}, where
+     * Scheduler works exactly the same.
+     *
+     * As in {@link bindCallback}, context (`this` property) of input function will be set to context
+     * of returned function, when it is called.
+     *
+     * After Observable emits value, it will complete immediately. This means
+     * even if `func` calls callback again, values from second and consecutive
+     * calls will never appear on the stream. If you need to handle functions
+     * that call callbacks multiple times, check out {@link fromEvent} or
+     * {@link fromEventPattern} instead.
+     *
+     * Note that `bindNodeCallback` can be used in non-Node.js environments as well.
+     * "Node.js-style" callbacks are just a convention, so if you write for
+     * browsers or any other environment and API you use implements that callback style,
+     * `bindNodeCallback` can be safely used on that API functions as well.
+     *
+     * Remember that Error object passed to callback does not have to be an instance
+     * of JavaScript built-in `Error` object. In fact, it does not even have to an object.
+     * Error parameter of callback function is interpreted as "present", when value
+     * of that parameter is truthy. It could be, for example, non-zero number, non-empty
+     * string or boolean `true`. In all of these cases resulting Observable would error
+     * with that value. This means usually regular style callbacks will fail very often when
+     * `bindNodeCallback` is used. If your Observable errors much more often then you
+     * would expect, check if callback really is called in Node.js-style and, if not,
+     * switch to {@link bindCallback} instead.
+     *
+     * Note that even if error parameter is technically present in callback, but its value
+     * is falsy, it still won't appear in array emitted by Observable or in selector function.
+     *
+     *
+     * @example <caption>Read a file from the filesystem and get the data as an Observable</caption>
+     * import * as fs from 'fs';
+     * var readFileAsObservable = Rx.Observable.bindNodeCallback(fs.readFile);
+     * var result = readFileAsObservable('./roadNames.txt', 'utf8');
+     * result.subscribe(x => console.log(x), e => console.error(e));
+     *
+     *
+     * @example <caption>Use on function calling callback with multiple arguments</caption>
+     * someFunction((err, a, b) => {
+     *   console.log(err); // null
+     *   console.log(a); // 5
+     *   console.log(b); // "some string"
+     * });
+     * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction);
+     * boundSomeFunction()
+     * .subscribe(value => {
+     *   console.log(value); // [5, "some string"]
+     * });
+     *
+     *
+     * @example <caption>Use with selector function</caption>
+     * someFunction((err, a, b) => {
+     *   console.log(err); // undefined
+     *   console.log(a); // "abc"
+     *   console.log(b); // "DEF"
+     * });
+     * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction, (a, b) => a + b);
+     * boundSomeFunction()
+     * .subscribe(value => {
+     *   console.log(value); // "abcDEF"
+     * });
+     *
+     *
+     * @example <caption>Use on function calling callback in regular style</caption>
+     * someFunction(a => {
+     *   console.log(a); // 5
+     * });
+     * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction);
+     * boundSomeFunction()
+     * .subscribe(
+     *   value => {}             // never gets called
+     *   err => console.log(err) // 5
+     *);
+     *
+     *
+     * @see {@link bindCallback}
+     * @see {@link from}
+     * @see {@link fromPromise}
+     *
+     * @param {function} func Function with a Node.js-style callback as the last parameter.
+     * @param {function} [selector] A function which takes the arguments from the
+     * callback and maps those to a value to emit on the output Observable.
+     * @param {Scheduler} [scheduler] The scheduler on which to schedule the
+     * callbacks.
+     * @return {function(...params: *): Observable} A function which returns the
+     * Observable that delivers the same values the Node.js callback would
+     * deliver.
+     * @static true
+     * @name bindNodeCallback
+     * @owner Observable
+     */
+    static create(func, selector = undefined, scheduler) {
+        return function (...args) {
+            return new BoundNodeCallbackObservable(func, selector, args, this, scheduler);
+        };
+    }
+    /** @deprecated internal use only */ _subscribe(subscriber) {
+        const callbackFunc = this.callbackFunc;
+        const args = this.args;
+        const scheduler = this.scheduler;
+        let subject = this.subject;
+        if (!scheduler) {
+            if (!subject) {
+                subject = this.subject = new AsyncSubject();
+                const handler = function handlerFn(...innerArgs) {
+                    const source = handlerFn.source;
+                    const { selector, subject } = source;
+                    const err = innerArgs.shift();
+                    if (err) {
+                        subject.error(err);
+                    }
+                    else if (selector) {
+                        const result = tryCatch(selector).apply(this, innerArgs);
+                        if (result === errorObject) {
+                            subject.error(errorObject.e);
+                        }
+                        else {
+                            subject.next(result);
+                            subject.complete();
+                        }
+                    }
+                    else {
+                        subject.next(innerArgs.length <= 1 ? innerArgs[0] : innerArgs);
+                        subject.complete();
+                    }
+                };
+                // use named function instance to avoid closure.
+                handler.source = this;
+                const result = tryCatch(callbackFunc).apply(this.context, args.concat(handler));
+                if (result === errorObject) {
+                    subject.error(errorObject.e);
+                }
+            }
+            return subject.subscribe(subscriber);
+        }
+        else {
+            return scheduler.schedule(dispatch, 0, { source: this, subscriber, context: this.context });
+        }
+    }
+}
+function dispatch(state) {
+    const self = this;
+    const { source, subscriber, context } = state;
+    // XXX: cast to `any` to access to the private field in `source`.
+    const { callbackFunc, args, scheduler } = source;
+    let subject = source.subject;
+    if (!subject) {
+        subject = source.subject = new AsyncSubject();
+        const handler = function handlerFn(...innerArgs) {
+            const source = handlerFn.source;
+            const { selector, subject } = source;
+            const err = innerArgs.shift();
+            if (err) {
+                self.add(scheduler.schedule(dispatchError, 0, { err, subject }));
+            }
+            else if (selector) {
+                const result = tryCatch(selector).apply(this, innerArgs);
+                if (result === errorObject) {
+                    self.add(scheduler.schedule(dispatchError, 0, { err: errorObject.e, subject }));
+                }
+                else {
+                    self.add(scheduler.schedule(dispatchNext, 0, { value: result, subject }));
+                }
+            }
+            else {
+                const value = innerArgs.length <= 1 ? innerArgs[0] : innerArgs;
+                self.add(scheduler.schedule(dispatchNext, 0, { value, subject }));
+            }
+        };
+        // use named function to pass values in without closure
+        handler.source = source;
+        const result = tryCatch(callbackFunc).apply(context, args.concat(handler));
+        if (result === errorObject) {
+            self.add(scheduler.schedule(dispatchError, 0, { err: errorObject.e, subject }));
+        }
+    }
+    self.add(subject.subscribe(subscriber));
+}
+function dispatchNext(arg) {
+    const { value, subject } = arg;
+    subject.next(value);
+    subject.complete();
+}
+function dispatchError(arg) {
+    const { err, subject } = arg;
+    subject.error(err);
+}
+//# sourceMappingURL=BoundNodeCallbackObservable.js.map