lambda-live-debugger 1.12.3 → 1.12.4

package/node_modules/rxjs/src/internal/observable/ConnectableObservable.ts

@@ -1,104 +0,0 @@
-import { Subject } from '../Subject';
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { Subscription } from '../Subscription';
-import { refCount as higherOrderRefCount } from '../operators/refCount';
-import { createOperatorSubscriber } from '../operators/OperatorSubscriber';
-import { hasLift } from '../util/lift';
-
-/**
- * @class ConnectableObservable<T>
- * @deprecated Will be removed in v8. Use {@link connectable} to create a connectable observable.
- * If you are using the `refCount` method of `ConnectableObservable`, use the {@link share} operator
- * instead.
- * Details: https://rxjs.dev/deprecations/multicasting
- */
-export class ConnectableObservable<T> extends Observable<T> {
-  protected _subject: Subject<T> | null = null;
-  protected _refCount: number = 0;
-  protected _connection: Subscription | null = null;
-
-  /**
-   * @param source The source observable
-   * @param subjectFactory The factory that creates the subject used internally.
-   * @deprecated Will be removed in v8. Use {@link connectable} to create a connectable observable.
-   * `new ConnectableObservable(source, factory)` is equivalent to
-   * `connectable(source, { connector: factory })`.
-   * When the `refCount()` method is needed, the {@link share} operator should be used instead:
-   * `new ConnectableObservable(source, factory).refCount()` is equivalent to
-   * `source.pipe(share({ connector: factory }))`.
-   * Details: https://rxjs.dev/deprecations/multicasting
-   */
-  constructor(public source: Observable<T>, protected subjectFactory: () => Subject<T>) {
-    super();
-    // If we have lift, monkey patch that here. This is done so custom observable
-    // types will compose through multicast. Otherwise the resulting observable would
-    // simply be an instance of `ConnectableObservable`.
-    if (hasLift(source)) {
-      this.lift = source.lift;
-    }
-  }
-
-  /** @internal */
-  protected _subscribe(subscriber: Subscriber<T>) {
-    return this.getSubject().subscribe(subscriber);
-  }
-
-  protected getSubject(): Subject<T> {
-    const subject = this._subject;
-    if (!subject || subject.isStopped) {
-      this._subject = this.subjectFactory();
-    }
-    return this._subject!;
-  }
-
-  protected _teardown() {
-    this._refCount = 0;
-    const { _connection } = this;
-    this._subject = this._connection = null;
-    _connection?.unsubscribe();
-  }
-
-  /**
-   * @deprecated {@link ConnectableObservable} will be removed in v8. Use {@link connectable} instead.
-   * Details: https://rxjs.dev/deprecations/multicasting
-   */
-  connect(): Subscription {
-    let connection = this._connection;
-    if (!connection) {
-      connection = this._connection = new Subscription();
-      const subject = this.getSubject();
-      connection.add(
-        this.source.subscribe(
-          createOperatorSubscriber(
-            subject as any,
-            undefined,
-            () => {
-              this._teardown();
-              subject.complete();
-            },
-            (err) => {
-              this._teardown();
-              subject.error(err);
-            },
-            () => this._teardown()
-          )
-        )
-      );
-
-      if (connection.closed) {
-        this._connection = null;
-        connection = Subscription.EMPTY;
-      }
-    }
-    return connection;
-  }
-
-  /**
-   * @deprecated {@link ConnectableObservable} will be removed in v8. Use the {@link share} operator instead.
-   * Details: https://rxjs.dev/deprecations/multicasting
-   */
-  refCount(): Observable<T> {
-    return higherOrderRefCount()(this) as Observable<T>;
-  }
-}

package/node_modules/rxjs/src/internal/observable/bindCallback.ts

@@ -1,149 +0,0 @@
-/* @prettier */
-import { SchedulerLike } from '../types';
-import { Observable } from '../Observable';
-import { bindCallbackInternals } from './bindCallbackInternals';
-
-export function bindCallback(
-  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 bindCallback<A extends readonly unknown[], R extends readonly unknown[]>(
-  callbackFunc: (...args: [...A, (...res: R) => void]) => void,
-  schedulerLike?: SchedulerLike
-): (...arg: A) => Observable<R extends [] ? void : R extends [any] ? R[0] : R>;
-
-/**
- * Converts a callback API to a function that returns an Observable.
- *
- * <span class="informal">Give it a function `f` of type `f(x, callback)` and
- * it will return a function `g` that when called as `g(x)` will output an
- * Observable.</span>
- *
- * `bindCallback` is not an operator because its input and output are not
- * Observables. The input is a function `func` with some parameters. The
- * last parameter must be a callback function that `func` calls when it is
- * done.
- *
- * The output of `bindCallback` 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 function `func`
- * calls its callback with one argument, the Observable will emit that value.
- * If on the other hand the callback is called with multiple values the resulting
- * Observable will emit an array with said values as arguments.
- *
- * It is **very important** to remember that input function `func` is not called
- * when the output function is, but rather when the Observable returned by the output
- * function is subscribed. This means if `func` makes an AJAX request, that request
- * will be made every time someone subscribes to the resulting Observable, but not before.
- *
- * The last optional parameter - `scheduler` - can be used to control when the call
- * to `func` happens after someone subscribes to Observable, as well as when results
- * passed to callback will be emitted. By default, the subscription to an Observable calls `func`
- * synchronously, but using {@link asyncScheduler} as the last parameter will defer the call to `func`,
- * just like wrapping the call in `setTimeout` with a timeout of `0` would. If you were to use the async Scheduler
- * and call `subscribe` on the output Observable, all function calls that are currently executing
- * will end before `func` is invoked.
- *
- * By default, results passed to the callback are emitted immediately after `func` invokes the callback.
- * In particular, if the callback is called synchronously, then the subscription of the resulting Observable
- * will call the `next` function synchronously as well.  If you want to defer that call,
- * you may use {@link asyncScheduler} just as before.  This means that by using `Scheduler.async` you can
- * ensure that `func` always calls its callback asynchronously, thus avoiding terrifying Zalgo.
- *
- * Note that the Observable created by the output function will always emit a single value
- * and then complete immediately. If `func` calls the callback multiple times, values from subsequent
- * calls will not appear in the stream. If you need to listen for multiple calls,
- *  you probably want to use {@link fromEvent} or {@link fromEventPattern} instead.
- *
- * If `func` depends on some context (`this` property) and is not already bound, the context of `func`
- * will be the context that the output function has at call time. In particular, if `func`
- * is called as a method of some object and if `func` is not already bound, in order to preserve the context
- * it is recommended that the context of the output function is set to that object as well.
- *
- * If the input function calls its callback in the "node style" (i.e. first argument to callback is
- * optional error parameter signaling whether the call failed or not), {@link bindNodeCallback}
- * provides convenient error handling and probably is a better choice.
- * `bindCallback` will treat such functions the same as any other and error parameters
- * (whether passed or not) will always be interpreted as regular callback argument.
- *
- * ## Examples
- *
- * Convert jQuery's getJSON to an Observable API
- *
- * ```ts
- * import { bindCallback } from 'rxjs';
- * import * as jQuery from 'jquery';
- *
- * // Suppose we have jQuery.getJSON('/my/url', callback)
- * const getJSONAsObservable = bindCallback(jQuery.getJSON);
- * const result = getJSONAsObservable('/my/url');
- * result.subscribe(x => console.log(x), e => console.error(e));
- * ```
- *
- * Receive an array of arguments passed to a callback
- *
- * ```ts
- * import { bindCallback } from 'rxjs';
- *
- * const someFunction = (n, s, cb) => {
- *   cb(n, s, { someProperty: 'someValue' });
- * };
- *
- * const boundSomeFunction = bindCallback(someFunction);
- * boundSomeFunction(5, 'some string').subscribe((values) => {
- *   console.log(values); // [5, 'some string', {someProperty: 'someValue'}]
- * });
- * ```
- *
- * Compare behaviour with and without `asyncScheduler`
- *
- * ```ts
- * import { bindCallback, asyncScheduler } from 'rxjs';
- *
- * function iCallMyCallbackSynchronously(cb) {
- *   cb();
- * }
- *
- * const boundSyncFn = bindCallback(iCallMyCallbackSynchronously);
- * const boundAsyncFn = bindCallback(iCallMyCallbackSynchronously, null, asyncScheduler);
- *
- * boundSyncFn().subscribe(() => console.log('I was sync!'));
- * boundAsyncFn().subscribe(() => console.log('I was async!'));
- * console.log('This happened...');
- *
- * // Logs:
- * // I was sync!
- * // This happened...
- * // I was async!
- * ```
- *
- * Use `bindCallback` on an object method
- *
- * ```ts
- * import { bindCallback } from 'rxjs';
- *
- * const boundMethod = bindCallback(someObject.methodWithCallback);
- * boundMethod
- *   .call(someObject) // make sure methodWithCallback has access to someObject
- *   .subscribe(subscriber);
- * ```
- *
- * @see {@link bindNodeCallback}
- * @see {@link from}
- *
- * @param callbackFunc A function with a 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 callback would deliver.
- */
-export function bindCallback(
-  callbackFunc: (...args: [...any[], (...res: any) => void]) => void,
-  resultSelector?: ((...args: any[]) => any) | SchedulerLike,
-  scheduler?: SchedulerLike
-): (...args: any[]) => Observable<unknown> {
-  return bindCallbackInternals(false, callbackFunc, resultSelector, scheduler);
-}

package/node_modules/rxjs/src/internal/observable/bindCallbackInternals.ts

@@ -1,119 +0,0 @@
-import { SchedulerLike } from '../types';
-import { isScheduler } from '../util/isScheduler';
-import { Observable } from '../Observable';
-import { subscribeOn } from '../operators/subscribeOn';
-import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs';
-import { observeOn } from '../operators/observeOn';
-import { AsyncSubject } from '../AsyncSubject';
-
-export function bindCallbackInternals(
-  isNodeStyle: boolean,
-  callbackFunc: any,
-  resultSelector?: any,
-  scheduler?: SchedulerLike
-): (...args: any[]) => Observable<unknown> {
-  if (resultSelector) {
-    if (isScheduler(resultSelector)) {
-      scheduler = resultSelector;
-    } else {
-      // The user provided a result selector.
-      return function (this: any, ...args: any[]) {
-        return (bindCallbackInternals(isNodeStyle, callbackFunc, scheduler) as any)
-          .apply(this, args)
-          .pipe(mapOneOrManyArgs(resultSelector as any));
-      };
-    }
-  }
-
-  // If a scheduler was passed, use our `subscribeOn` and `observeOn` operators
-  // to compose that behavior for the user.
-  if (scheduler) {
-    return function (this: any, ...args: any[]) {
-      return (bindCallbackInternals(isNodeStyle, callbackFunc) as any)
-        .apply(this, args)
-        .pipe(subscribeOn(scheduler!), observeOn(scheduler!));
-    };
-  }
-
-  return function (this: any, ...args: any[]): Observable<any> {
-    // We're using AsyncSubject, because it emits when it completes,
-    // and it will play the value to all late-arriving subscribers.
-    const subject = new AsyncSubject<any>();
-
-    // If this is true, then we haven't called our function yet.
-    let uninitialized = true;
-    return new Observable((subscriber) => {
-      // Add our subscriber to the subject.
-      const subs = subject.subscribe(subscriber);
-
-      if (uninitialized) {
-        uninitialized = false;
-        // We're going to execute the bound function
-        // This bit is to signal that we are hitting the callback asynchronously.
-        // Because we don't have any anti-"Zalgo" guarantees with whatever
-        // function we are handed, we use this bit to figure out whether or not
-        // we are getting hit in a callback synchronously during our call.
-        let isAsync = false;
-
-        // This is used to signal that the callback completed synchronously.
-        let isComplete = false;
-
-        // Call our function that has a callback. If at any time during this
-        // call, an error is thrown, it will be caught by the Observable
-        // subscription process and sent to the consumer.
-        callbackFunc.apply(
-          // Pass the appropriate `this` context.
-          this,
-          [
-            // Pass the arguments.
-            ...args,
-            // And our callback handler.
-            (...results: any[]) => {
-              if (isNodeStyle) {
-                // If this is a node callback, shift the first value off of the
-                // results and check it, as it is the error argument. By shifting,
-                // we leave only the argument(s) we want to pass to the consumer.
-                const err = results.shift();
-                if (err != null) {
-                  subject.error(err);
-                  // If we've errored, we can stop processing this function
-                  // as there's nothing else to do. Just return to escape.
-                  return;
-                }
-              }
-              // If we have one argument, notify the consumer
-              // of it as a single value, otherwise, if there's more than one, pass
-              // them as an array. Note that if there are no arguments, `undefined`
-              // will be emitted.
-              subject.next(1 < results.length ? results : results[0]);
-              // Flip this flag, so we know we can complete it in the synchronous
-              // case below.
-              isComplete = true;
-              // If we're not asynchronous, we need to defer the `complete` call
-              // until after the call to the function is over. This is because an
-              // error could be thrown in the function after it calls our callback,
-              // and if that is the case, if we complete here, we are unable to notify
-              // the consumer than an error occurred.
-              if (isAsync) {
-                subject.complete();
-              }
-            },
-          ]
-        );
-        // If we flipped `isComplete` during the call, we resolved synchronously,
-        // notify complete, because we skipped it in the callback to wait
-        // to make sure there were no errors during the call.
-        if (isComplete) {
-          subject.complete();
-        }
-
-        // We're no longer synchronous. If the callback is called at this point
-        // we can notify complete on the spot.
-        isAsync = true;
-      }
-
-      // Return the subscription from adding our subscriber to the subject.
-      return subs;
-    });
-  };
-}

package/node_modules/rxjs/src/internal/observable/bindNodeCallback.ts

@@ -1,131 +0,0 @@
-/* @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);
-}