1 files changed, 131 insertions, 0 deletions
diff --git a/node_modules/rxjs/src/internal/observable/bindNodeCallback.ts b/node_modules/rxjs/src/internal/observable/bindNodeCallback.ts
new file mode 100644
index 0000000..8d83722
--- /dev/null
+++ b/node_modules/rxjs/src/internal/observable/bindNodeCallback.ts
@@ -0,0 +1,131 @@
+/* @prettier */
+import { Observable } from '../Observable';
+import { SchedulerLike } from '../types';
+import { bindCallbackInternals } from './bindCallbackInternals';
+
+export function bindNodeCallback(
+  callbackFunc: (...args: any[]) => void,
+  resultSelector: (...args: any[]) => any,
+  scheduler?: SchedulerLike
+): (...args: any[]) => Observable<any>;
+
+// args is the arguments array and we push the callback on the rest tuple since the rest parameter must be last (only item) in a parameter list
+export function bindNodeCallback<A extends readonly unknown[], R extends readonly unknown[]>(
+  callbackFunc: (...args: [...A, (err: any, ...res: R) => void]) => void,
+  schedulerLike?: SchedulerLike
+): (...arg: A) => Observable<R extends [] ? void : R extends [any] ? R[0] : R>;
+
+/**
+ * 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.
+ *
+ * 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 `scheduler` provided as optional third parameter. {@link SchedulerLike}
+ * can also control when values from callback will be emitted by Observable.
+ * To find out more, check out documentation for {@link bindCallback}, where
+ * {@link SchedulerLike} 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.
+ *
+ * ## Examples
+ *
+ *  Read a file from the filesystem and get the data as an Observable
+ *
+ * ```ts
+ * import * as fs from 'fs';
+ * const readFileAsObservable = bindNodeCallback(fs.readFile);
+ * const result = readFileAsObservable('./roadNames.txt', 'utf8');
+ * result.subscribe(x => console.log(x), e => console.error(e));
+ * ```
+ *
+ * Use on function calling callback with multiple arguments
+ *
+ * ```ts
+ * someFunction((err, a, b) => {
+ *   console.log(err); // null
+ *   console.log(a); // 5
+ *   console.log(b); // "some string"
+ * });
+ * const boundSomeFunction = bindNodeCallback(someFunction);
+ * boundSomeFunction()
+ * .subscribe(value => {
+ *   console.log(value); // [5, "some string"]
+ * });
+ * ```
+ *
+ * Use on function calling callback in regular style
+ *
+ * ```ts
+ * someFunction(a => {
+ *   console.log(a); // 5
+ * });
+ * const boundSomeFunction = bindNodeCallback(someFunction);
+ * boundSomeFunction()
+ * .subscribe(
+ *   value => {}             // never gets called
+ *   err => console.log(err) // 5
+ * );
+ * ```
+ *
+ * @see {@link bindCallback}
+ * @see {@link from}
+ *
+ * @param callbackFunc Function with a Node.js-style callback as the last parameter.
+ * @param resultSelector A mapping function used to transform callback events.
+ * @param scheduler The scheduler on which to schedule the callbacks.
+ * @return A function which returns the Observable that delivers the same values the
+ * Node.js callback would deliver.
+ */
+export function bindNodeCallback(
+  callbackFunc: (...args: [...any[], (err: any, ...res: any) => void]) => void,
+  resultSelector?: ((...args: any[]) => any) | SchedulerLike,
+  scheduler?: SchedulerLike
+): (...args: any[]) => Observable<any> {
+  return bindCallbackInternals(true, callbackFunc, resultSelector, scheduler);
+}