appiq-solution 1.0.9 → 1.2.0

package/tools/installer/node_modules/rxjs/src/internal/Subject.ts

@@ -1,185 +0,0 @@
-import { Operator } from './Operator';
-import { Observable } from './Observable';
-import { Subscriber } from './Subscriber';
-import { Subscription, EMPTY_SUBSCRIPTION } from './Subscription';
-import { Observer, SubscriptionLike, TeardownLogic } from './types';
-import { ObjectUnsubscribedError } from './util/ObjectUnsubscribedError';
-import { arrRemove } from './util/arrRemove';
-import { errorContext } from './util/errorContext';
-
-/**
- * A Subject is a special type of Observable that allows values to be
- * multicasted to many Observers. Subjects are like EventEmitters.
- *
- * Every Subject is an Observable and an Observer. You can subscribe to a
- * Subject, and you can call next to feed values as well as error and complete.
- */
-export class Subject<T> extends Observable<T> implements SubscriptionLike {
-  closed = false;
-
-  private currentObservers: Observer<T>[] | null = null;
-
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  observers: Observer<T>[] = [];
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  isStopped = false;
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  hasError = false;
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  thrownError: any = null;
-
-  /**
-   * Creates a "subject" by basically gluing an observer to an observable.
-   *
-   * @deprecated Recommended you do not use. Will be removed at some point in the future. Plans for replacement still under discussion.
-   */
-  static create: (...args: any[]) => any = <T>(destination: Observer<T>, source: Observable<T>): AnonymousSubject<T> => {
-    return new AnonymousSubject<T>(destination, source);
-  };
-
-  constructor() {
-    // NOTE: This must be here to obscure Observable's constructor.
-    super();
-  }
-
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  lift<R>(operator: Operator<T, R>): Observable<R> {
-    const subject = new AnonymousSubject(this, this);
-    subject.operator = operator as any;
-    return subject as any;
-  }
-
-  /** @internal */
-  protected _throwIfClosed() {
-    if (this.closed) {
-      throw new ObjectUnsubscribedError();
-    }
-  }
-
-  next(value: T) {
-    errorContext(() => {
-      this._throwIfClosed();
-      if (!this.isStopped) {
-        if (!this.currentObservers) {
-          this.currentObservers = Array.from(this.observers);
-        }
-        for (const observer of this.currentObservers) {
-          observer.next(value);
-        }
-      }
-    });
-  }
-
-  error(err: any) {
-    errorContext(() => {
-      this._throwIfClosed();
-      if (!this.isStopped) {
-        this.hasError = this.isStopped = true;
-        this.thrownError = err;
-        const { observers } = this;
-        while (observers.length) {
-          observers.shift()!.error(err);
-        }
-      }
-    });
-  }
-
-  complete() {
-    errorContext(() => {
-      this._throwIfClosed();
-      if (!this.isStopped) {
-        this.isStopped = true;
-        const { observers } = this;
-        while (observers.length) {
-          observers.shift()!.complete();
-        }
-      }
-    });
-  }
-
-  unsubscribe() {
-    this.isStopped = this.closed = true;
-    this.observers = this.currentObservers = null!;
-  }
-
-  get observed() {
-    return this.observers?.length > 0;
-  }
-
-  /** @internal */
-  protected _trySubscribe(subscriber: Subscriber<T>): TeardownLogic {
-    this._throwIfClosed();
-    return super._trySubscribe(subscriber);
-  }
-
-  /** @internal */
-  protected _subscribe(subscriber: Subscriber<T>): Subscription {
-    this._throwIfClosed();
-    this._checkFinalizedStatuses(subscriber);
-    return this._innerSubscribe(subscriber);
-  }
-
-  /** @internal */
-  protected _innerSubscribe(subscriber: Subscriber<any>) {
-    const { hasError, isStopped, observers } = this;
-    if (hasError || isStopped) {
-      return EMPTY_SUBSCRIPTION;
-    }
-    this.currentObservers = null;
-    observers.push(subscriber);
-    return new Subscription(() => {
-      this.currentObservers = null;
-      arrRemove(observers, subscriber);
-    });
-  }
-
-  /** @internal */
-  protected _checkFinalizedStatuses(subscriber: Subscriber<any>) {
-    const { hasError, thrownError, isStopped } = this;
-    if (hasError) {
-      subscriber.error(thrownError);
-    } else if (isStopped) {
-      subscriber.complete();
-    }
-  }
-
-  /**
-   * Creates a new Observable with this Subject as the source. You can do this
-   * to create custom Observer-side logic of the Subject and conceal it from
-   * code that uses the Observable.
-   * @return Observable that this Subject casts to.
-   */
-  asObservable(): Observable<T> {
-    const observable: any = new Observable<T>();
-    observable.source = this;
-    return observable;
-  }
-}
-
-export class AnonymousSubject<T> extends Subject<T> {
-  constructor(
-    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-    public destination?: Observer<T>,
-    source?: Observable<T>
-  ) {
-    super();
-    this.source = source;
-  }
-
-  next(value: T) {
-    this.destination?.next?.(value);
-  }
-
-  error(err: any) {
-    this.destination?.error?.(err);
-  }
-
-  complete() {
-    this.destination?.complete?.();
-  }
-
-  /** @internal */
-  protected _subscribe(subscriber: Subscriber<T>): Subscription {
-    return this.source?.subscribe(subscriber) ?? EMPTY_SUBSCRIPTION;
-  }
-}

package/tools/installer/node_modules/rxjs/src/internal/Subscriber.ts

@@ -1,270 +0,0 @@
-import { isFunction } from './util/isFunction';
-import { Observer, ObservableNotification } from './types';
-import { isSubscription, Subscription } from './Subscription';
-import { config } from './config';
-import { reportUnhandledError } from './util/reportUnhandledError';
-import { noop } from './util/noop';
-import { nextNotification, errorNotification, COMPLETE_NOTIFICATION } from './NotificationFactories';
-import { timeoutProvider } from './scheduler/timeoutProvider';
-import { captureError } from './util/errorContext';
-
-/**
- * Implements the {@link Observer} interface and extends the
- * {@link Subscription} class. While the {@link Observer} is the public API for
- * consuming the values of an {@link Observable}, all Observers get converted to
- * a Subscriber, in order to provide Subscription-like capabilities such as
- * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
- * implementing operators, but it is rarely used as a public API.
- */
-export class Subscriber<T> extends Subscription implements Observer<T> {
-  /**
-   * A static factory for a Subscriber, given a (potentially partial) definition
-   * of an Observer.
-   * @param next The `next` callback of an Observer.
-   * @param error The `error` callback of an
-   * Observer.
-   * @param complete The `complete` callback of an
-   * Observer.
-   * @return A Subscriber wrapping the (partially defined)
-   * Observer represented by the given arguments.
-   * @deprecated Do not use. Will be removed in v8. There is no replacement for this
-   * method, and there is no reason to be creating instances of `Subscriber` directly.
-   * If you have a specific use case, please file an issue.
-   */
-  static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T> {
-    return new SafeSubscriber(next, error, complete);
-  }
-
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  protected isStopped: boolean = false;
-  /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-  protected destination: Subscriber<any> | Observer<any>; // this `any` is the escape hatch to erase extra type param (e.g. R)
-
-  /**
-   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-   * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons.
-   */
-  constructor(destination?: Subscriber<any> | Observer<any>) {
-    super();
-    if (destination) {
-      this.destination = destination;
-      // Automatically chain subscriptions together here.
-      // if destination is a Subscription, then it is a Subscriber.
-      if (isSubscription(destination)) {
-        destination.add(this);
-      }
-    } else {
-      this.destination = EMPTY_OBSERVER;
-    }
-  }
-
-  /**
-   * The {@link Observer} callback to receive notifications of type `next` from
-   * the Observable, with a value. The Observable may call this method 0 or more
-   * times.
-   * @param value The `next` value.
-   */
-  next(value: T): void {
-    if (this.isStopped) {
-      handleStoppedNotification(nextNotification(value), this);
-    } else {
-      this._next(value!);
-    }
-  }
-
-  /**
-   * The {@link Observer} callback to receive notifications of type `error` from
-   * the Observable, with an attached `Error`. Notifies the Observer that
-   * the Observable has experienced an error condition.
-   * @param err The `error` exception.
-   */
-  error(err?: any): void {
-    if (this.isStopped) {
-      handleStoppedNotification(errorNotification(err), this);
-    } else {
-      this.isStopped = true;
-      this._error(err);
-    }
-  }
-
-  /**
-   * The {@link Observer} callback to receive a valueless notification of type
-   * `complete` from the Observable. Notifies the Observer that the Observable
-   * has finished sending push-based notifications.
-   */
-  complete(): void {
-    if (this.isStopped) {
-      handleStoppedNotification(COMPLETE_NOTIFICATION, this);
-    } else {
-      this.isStopped = true;
-      this._complete();
-    }
-  }
-
-  unsubscribe(): void {
-    if (!this.closed) {
-      this.isStopped = true;
-      super.unsubscribe();
-      this.destination = null!;
-    }
-  }
-
-  protected _next(value: T): void {
-    this.destination.next(value);
-  }
-
-  protected _error(err: any): void {
-    try {
-      this.destination.error(err);
-    } finally {
-      this.unsubscribe();
-    }
-  }
-
-  protected _complete(): void {
-    try {
-      this.destination.complete();
-    } finally {
-      this.unsubscribe();
-    }
-  }
-}
-
-/**
- * This bind is captured here because we want to be able to have
- * compatibility with monoid libraries that tend to use a method named
- * `bind`. In particular, a library called Monio requires this.
- */
-const _bind = Function.prototype.bind;
-
-function bind<Fn extends (...args: any[]) => any>(fn: Fn, thisArg: any): Fn {
-  return _bind.call(fn, thisArg);
-}
-
-/**
- * Internal optimization only, DO NOT EXPOSE.
- * @internal
- */
-class ConsumerObserver<T> implements Observer<T> {
-  constructor(private partialObserver: Partial<Observer<T>>) {}
-
-  next(value: T): void {
-    const { partialObserver } = this;
-    if (partialObserver.next) {
-      try {
-        partialObserver.next(value);
-      } catch (error) {
-        handleUnhandledError(error);
-      }
-    }
-  }
-
-  error(err: any): void {
-    const { partialObserver } = this;
-    if (partialObserver.error) {
-      try {
-        partialObserver.error(err);
-      } catch (error) {
-        handleUnhandledError(error);
-      }
-    } else {
-      handleUnhandledError(err);
-    }
-  }
-
-  complete(): void {
-    const { partialObserver } = this;
-    if (partialObserver.complete) {
-      try {
-        partialObserver.complete();
-      } catch (error) {
-        handleUnhandledError(error);
-      }
-    }
-  }
-}
-
-export class SafeSubscriber<T> extends Subscriber<T> {
-  constructor(
-    observerOrNext?: Partial<Observer<T>> | ((value: T) => void) | null,
-    error?: ((e?: any) => void) | null,
-    complete?: (() => void) | null
-  ) {
-    super();
-
-    let partialObserver: Partial<Observer<T>>;
-    if (isFunction(observerOrNext) || !observerOrNext) {
-      // The first argument is a function, not an observer. The next
-      // two arguments *could* be observers, or they could be empty.
-      partialObserver = {
-        next: (observerOrNext ?? undefined) as ((value: T) => void) | undefined,
-        error: error ?? undefined,
-        complete: complete ?? undefined,
-      };
-    } else {
-      // The first argument is a partial observer.
-      let context: any;
-      if (this && config.useDeprecatedNextContext) {
-        // This is a deprecated path that made `this.unsubscribe()` available in
-        // next handler functions passed to subscribe. This only exists behind a flag
-        // now, as it is *very* slow.
-        context = Object.create(observerOrNext);
-        context.unsubscribe = () => this.unsubscribe();
-        partialObserver = {
-          next: observerOrNext.next && bind(observerOrNext.next, context),
-          error: observerOrNext.error && bind(observerOrNext.error, context),
-          complete: observerOrNext.complete && bind(observerOrNext.complete, context),
-        };
-      } else {
-        // The "normal" path. Just use the partial observer directly.
-        partialObserver = observerOrNext;
-      }
-    }
-
-    // Wrap the partial observer to ensure it's a full observer, and
-    // make sure proper error handling is accounted for.
-    this.destination = new ConsumerObserver(partialObserver);
-  }
-}
-
-function handleUnhandledError(error: any) {
-  if (config.useDeprecatedSynchronousErrorHandling) {
-    captureError(error);
-  } else {
-    // Ideal path, we report this as an unhandled error,
-    // which is thrown on a new call stack.
-    reportUnhandledError(error);
-  }
-}
-
-/**
- * An error handler used when no error handler was supplied
- * to the SafeSubscriber -- meaning no error handler was supplied
- * do the `subscribe` call on our observable.
- * @param err The error to handle
- */
-function defaultErrorHandler(err: any) {
-  throw err;
-}
-
-/**
- * A handler for notifications that cannot be sent to a stopped subscriber.
- * @param notification The notification being sent.
- * @param subscriber The stopped subscriber.
- */
-function handleStoppedNotification(notification: ObservableNotification<any>, subscriber: Subscriber<any>) {
-  const { onStoppedNotification } = config;
-  onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));
-}
-
-/**
- * The observer used as a stub for subscriptions where the user did not
- * pass any arguments to `subscribe`. Comes with the default error handling
- * behavior.
- */
-export const EMPTY_OBSERVER: Readonly<Observer<any>> & { closed: true } = {
-  closed: true,
-  next: noop,
-  error: defaultErrorHandler,
-  complete: noop,
-};

package/tools/installer/node_modules/rxjs/src/internal/Subscription.ts

@@ -1,212 +0,0 @@
-import { isFunction } from './util/isFunction';
-import { UnsubscriptionError } from './util/UnsubscriptionError';
-import { SubscriptionLike, TeardownLogic, Unsubscribable } from './types';
-import { arrRemove } from './util/arrRemove';
-
-/**
- * Represents a disposable resource, such as the execution of an Observable. A
- * Subscription has one important method, `unsubscribe`, that takes no argument
- * and just disposes the resource held by the subscription.
- *
- * Additionally, subscriptions may be grouped together through the `add()`
- * method, which will attach a child Subscription to the current Subscription.
- * When a Subscription is unsubscribed, all its children (and its grandchildren)
- * will be unsubscribed as well.
- */
-export class Subscription implements SubscriptionLike {
-  public static EMPTY = (() => {
-    const empty = new Subscription();
-    empty.closed = true;
-    return empty;
-  })();
-
-  /**
-   * A flag to indicate whether this Subscription has already been unsubscribed.
-   */
-  public closed = false;
-
-  private _parentage: Subscription[] | Subscription | null = null;
-
-  /**
-   * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
-   * list occurs in the {@link #add} and {@link #remove} methods.
-   */
-  private _finalizers: Exclude<TeardownLogic, void>[] | null = null;
-
-  /**
-   * @param initialTeardown A function executed first as part of the finalization
-   * process that is kicked off when {@link #unsubscribe} is called.
-   */
-  constructor(private initialTeardown?: () => void) {}
-
-  /**
-   * Disposes the resources held by the subscription. May, for instance, cancel
-   * an ongoing Observable execution or cancel any other type of work that
-   * started when the Subscription was created.
-   */
-  unsubscribe(): void {
-    let errors: any[] | undefined;
-
-    if (!this.closed) {
-      this.closed = true;
-
-      // Remove this from it's parents.
-      const { _parentage } = this;
-      if (_parentage) {
-        this._parentage = null;
-        if (Array.isArray(_parentage)) {
-          for (const parent of _parentage) {
-            parent.remove(this);
-          }
-        } else {
-          _parentage.remove(this);
-        }
-      }
-
-      const { initialTeardown: initialFinalizer } = this;
-      if (isFunction(initialFinalizer)) {
-        try {
-          initialFinalizer();
-        } catch (e) {
-          errors = e instanceof UnsubscriptionError ? e.errors : [e];
-        }
-      }
-
-      const { _finalizers } = this;
-      if (_finalizers) {
-        this._finalizers = null;
-        for (const finalizer of _finalizers) {
-          try {
-            execFinalizer(finalizer);
-          } catch (err) {
-            errors = errors ?? [];
-            if (err instanceof UnsubscriptionError) {
-              errors = [...errors, ...err.errors];
-            } else {
-              errors.push(err);
-            }
-          }
-        }
-      }
-
-      if (errors) {
-        throw new UnsubscriptionError(errors);
-      }
-    }
-  }
-
-  /**
-   * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
-   * when this subscription is unsubscribed. If this subscription is already {@link #closed},
-   * because it has already been unsubscribed, then whatever finalizer is passed to it
-   * will automatically be executed (unless the finalizer itself is also a closed subscription).
-   *
-   * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
-   * subscription to a any subscription will result in no operation. (A noop).
-   *
-   * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
-   * operation at all. (A noop).
-   *
-   * `Subscription` instances that are added to this instance will automatically remove themselves
-   * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
-   * will need to be removed manually with {@link #remove}
-   *
-   * @param teardown The finalization logic to add to this subscription.
-   */
-  add(teardown: TeardownLogic): void {
-    // Only add the finalizer if it's not undefined
-    // and don't add a subscription to itself.
-    if (teardown && teardown !== this) {
-      if (this.closed) {
-        // If this subscription is already closed,
-        // execute whatever finalizer is handed to it automatically.
-        execFinalizer(teardown);
-      } else {
-        if (teardown instanceof Subscription) {
-          // We don't add closed subscriptions, and we don't add the same subscription
-          // twice. Subscription unsubscribe is idempotent.
-          if (teardown.closed || teardown._hasParent(this)) {
-            return;
-          }
-          teardown._addParent(this);
-        }
-        (this._finalizers = this._finalizers ?? []).push(teardown);
-      }
-    }
-  }
-
-  /**
-   * Checks to see if a this subscription already has a particular parent.
-   * This will signal that this subscription has already been added to the parent in question.
-   * @param parent the parent to check for
-   */
-  private _hasParent(parent: Subscription) {
-    const { _parentage } = this;
-    return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
-  }
-
-  /**
-   * Adds a parent to this subscription so it can be removed from the parent if it
-   * unsubscribes on it's own.
-   *
-   * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED.
-   * @param parent The parent subscription to add
-   */
-  private _addParent(parent: Subscription) {
-    const { _parentage } = this;
-    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
-  }
-
-  /**
-   * Called on a child when it is removed via {@link #remove}.
-   * @param parent The parent to remove
-   */
-  private _removeParent(parent: Subscription) {
-    const { _parentage } = this;
-    if (_parentage === parent) {
-      this._parentage = null;
-    } else if (Array.isArray(_parentage)) {
-      arrRemove(_parentage, parent);
-    }
-  }
-
-  /**
-   * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
-   *
-   * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
-   * from every other `Subscription` they have been added to. This means that using the `remove` method
-   * is not a common thing and should be used thoughtfully.
-   *
-   * If you add the same finalizer instance of a function or an unsubscribable object to a `Subscription` instance
-   * more than once, you will need to call `remove` the same number of times to remove all instances.
-   *
-   * All finalizer instances are removed to free up memory upon unsubscription.
-   *
-   * @param teardown The finalizer to remove from this subscription
-   */
-  remove(teardown: Exclude<TeardownLogic, void>): void {
-    const { _finalizers } = this;
-    _finalizers && arrRemove(_finalizers, teardown);
-
-    if (teardown instanceof Subscription) {
-      teardown._removeParent(this);
-    }
-  }
-}
-
-export const EMPTY_SUBSCRIPTION = Subscription.EMPTY;
-
-export function isSubscription(value: any): value is Subscription {
-  return (
-    value instanceof Subscription ||
-    (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe))
-  );
-}
-
-function execFinalizer(finalizer: Unsubscribable | (() => void)) {
-  if (isFunction(finalizer)) {
-    finalizer();
-  } else {
-    finalizer.unsubscribe();
-  }
-}