appiq-solution 1.0.8 → 1.1.0

package/tools/installer/node_modules/rxjs/src/internal/operators/timeout.ts

@@ -1,403 +0,0 @@
-import { asyncScheduler } from '../scheduler/async';
-import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
-import { isValidDate } from '../util/isDate';
-import { Subscription } from '../Subscription';
-import { operate } from '../util/lift';
-import { Observable } from '../Observable';
-import { innerFrom } from '../observable/innerFrom';
-import { createErrorClass } from '../util/createErrorClass';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { executeSchedule } from '../util/executeSchedule';
-
-export interface TimeoutConfig<T, O extends ObservableInput<unknown> = ObservableInput<T>, M = unknown> {
-  /**
-   * The time allowed between values from the source before timeout is triggered.
-   */
-  each?: number;
-
-  /**
-   * The relative time as a `number` in milliseconds, or a specific time as a `Date` object,
-   * by which the first value must arrive from the source before timeout is triggered.
-   */
-  first?: number | Date;
-
-  /**
-   * The scheduler to use with time-related operations within this operator. Defaults to {@link asyncScheduler}
-   */
-  scheduler?: SchedulerLike;
-
-  /**
-   * A factory used to create observable to switch to when timeout occurs. Provides
-   * a {@link TimeoutInfo} about the source observable's emissions and what delay or
-   * exact time triggered the timeout.
-   */
-  with?: (info: TimeoutInfo<T, M>) => O;
-
-  /**
-   * Optional additional metadata you can provide to code that handles
-   * the timeout, will be provided through the {@link TimeoutError}.
-   * This can be used to help identify the source of a timeout or pass along
-   * other information related to the timeout.
-   */
-  meta?: M;
-}
-
-export interface TimeoutInfo<T, M = unknown> {
-  /** Optional metadata that was provided to the timeout configuration. */
-  readonly meta: M;
-  /** The number of messages seen before the timeout */
-  readonly seen: number;
-  /** The last message seen */
-  readonly lastValue: T | null;
-}
-
-/**
- * An error emitted when a timeout occurs.
- */
-export interface TimeoutError<T = unknown, M = unknown> extends Error {
-  /**
-   * The information provided to the error by the timeout
-   * operation that created the error. Will be `null` if
-   * used directly in non-RxJS code with an empty constructor.
-   * (Note that using this constructor directly is not recommended,
-   * you should create your own errors)
-   */
-  info: TimeoutInfo<T, M> | null;
-}
-
-export interface TimeoutErrorCtor {
-  /**
-   * @deprecated Internal implementation detail. Do not construct error instances.
-   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-   */
-  new <T = unknown, M = unknown>(info?: TimeoutInfo<T, M>): TimeoutError<T, M>;
-}
-
-/**
- * An error thrown by the {@link timeout} operator.
- *
- * Provided so users can use as a type and do quality comparisons.
- * We recommend you do not subclass this or create instances of this class directly.
- * If you have need of a error representing a timeout, you should
- * create your own error class and use that.
- *
- * @see {@link timeout}
- */
-export const TimeoutError: TimeoutErrorCtor = createErrorClass(
-  (_super) =>
-    function TimeoutErrorImpl(this: any, info: TimeoutInfo<any> | null = null) {
-      _super(this);
-      this.message = 'Timeout has occurred';
-      this.name = 'TimeoutError';
-      this.info = info;
-    }
-);
-
-/**
- * If `with` is provided, this will return an observable that will switch to a different observable if the source
- * does not push values within the specified time parameters.
- *
- * <span class="informal">The most flexible option for creating a timeout behavior.</span>
- *
- * The first thing to know about the configuration is if you do not provide a `with` property to the configuration,
- * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory
- * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by
- * the settings in `first` and `each`.
- *
- * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the
- * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of
- * the first value from the source _only_. The timings of all subsequent values  from the source will be checked
- * against the time period provided by `each`, if it was provided.
- *
- * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of
- * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if
- * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first
- * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first.
- *
- * ## Examples
- *
- * Emit a custom error if there is too much time between values
- *
- * ```ts
- * import { interval, timeout, throwError } from 'rxjs';
- *
- * class CustomTimeoutError extends Error {
- *   constructor() {
- *     super('It was too slow');
- *     this.name = 'CustomTimeoutError';
- *   }
- * }
- *
- * const slow$ = interval(900);
- *
- * slow$.pipe(
- *   timeout({
- *     each: 1000,
- *     with: () => throwError(() => new CustomTimeoutError())
- *   })
- * )
- * .subscribe({
- *   error: console.error
- * });
- * ```
- *
- * Switch to a faster observable if your source is slow.
- *
- * ```ts
- * import { interval, timeout } from 'rxjs';
- *
- * const slow$ = interval(900);
- * const fast$ = interval(500);
- *
- * slow$.pipe(
- *   timeout({
- *     each: 1000,
- *     with: () => fast$,
- *   })
- * )
- * .subscribe(console.log);
- * ```
- * @param config The configuration for the timeout.
- */
-export function timeout<T, O extends ObservableInput<unknown>, M = unknown>(
-  config: TimeoutConfig<T, O, M> & { with: (info: TimeoutInfo<T, M>) => O }
-): OperatorFunction<T, T | ObservedValueOf<O>>;
-
-/**
- * Returns an observable that will error or switch to a different observable if the source does not push values
- * within the specified time parameters.
- *
- * <span class="informal">The most flexible option for creating a timeout behavior.</span>
- *
- * The first thing to know about the configuration is if you do not provide a `with` property to the configuration,
- * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory
- * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by
- * the settings in `first` and `each`.
- *
- * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the
- * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of
- * the first value from the source _only_. The timings of all subsequent values  from the source will be checked
- * against the time period provided by `each`, if it was provided.
- *
- * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of
- * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if
- * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first
- * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first.
- *
- * ### Handling TimeoutErrors
- *
- * If no `with` property was provided, subscriptions to the resulting observable may emit an error of {@link TimeoutError}.
- * The timeout error provides useful information you can examine when you're handling the error. The most common way to handle
- * the error would be with {@link catchError}, although you could use {@link tap} or just the error handler in your `subscribe` call
- * directly, if your error handling is only a side effect (such as notifying the user, or logging).
- *
- * In this case, you would check the error for `instanceof TimeoutError` to validate that the error was indeed from `timeout`, and
- * not from some other source. If it's not from `timeout`, you should probably rethrow it if you're in a `catchError`.
- *
- * ## Examples
- *
- * Emit a {@link TimeoutError} if the first value, and _only_ the first value, does not arrive within 5 seconds
- *
- * ```ts
- * import { interval, timeout } from 'rxjs';
- *
- * // A random interval that lasts between 0 and 10 seconds per tick
- * const source$ = interval(Math.round(Math.random() * 10_000));
- *
- * source$.pipe(
- *   timeout({ first: 5_000 })
- * )
- * .subscribe({
- *   next: console.log,
- *   error: console.error
- * });
- * ```
- *
- * Emit a {@link TimeoutError} if the source waits longer than 5 seconds between any two values or the first value
- * and subscription.
- *
- * ```ts
- * import { timer, timeout, expand } from 'rxjs';
- *
- * const getRandomTime = () => Math.round(Math.random() * 10_000);
- *
- * // An observable that waits a random amount of time between each delivered value
- * const source$ = timer(getRandomTime())
- *   .pipe(expand(() => timer(getRandomTime())));
- *
- * source$
- *   .pipe(timeout({ each: 5_000 }))
- *   .subscribe({
- *     next: console.log,
- *     error: console.error
- *   });
- * ```
- *
- * Emit a {@link TimeoutError} if the source does not emit before 7 seconds, _or_ if the source waits longer than
- * 5 seconds between any two values after the first.
- *
- * ```ts
- * import { timer, timeout, expand } from 'rxjs';
- *
- * const getRandomTime = () => Math.round(Math.random() * 10_000);
- *
- * // An observable that waits a random amount of time between each delivered value
- * const source$ = timer(getRandomTime())
- *   .pipe(expand(() => timer(getRandomTime())));
- *
- * source$
- *   .pipe(timeout({ first: 7_000, each: 5_000 }))
- *   .subscribe({
- *     next: console.log,
- *     error: console.error
- *   });
- * ```
- */
-export function timeout<T, M = unknown>(config: Omit<TimeoutConfig<T, any, M>, 'with'>): OperatorFunction<T, T>;
-
-/**
- * Returns an observable that will error if the source does not push its first value before the specified time passed as a `Date`.
- * This is functionally the same as `timeout({ first: someDate })`.
- *
- * <span class="informal">Errors if the first value doesn't show up before the given date and time</span>
- *
- * ![](timeout.png)
- *
- * @param first The date to at which the resulting observable will timeout if the source observable
- * does not emit at least one value.
- * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}.
- */
-export function timeout<T>(first: Date, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-
-/**
- * Returns an observable that will error if the source does not push a value within the specified time in milliseconds.
- * This is functionally the same as `timeout({ each: milliseconds })`.
- *
- * <span class="informal">Errors if it waits too long between any value</span>
- *
- * ![](timeout.png)
- *
- * @param each The time allowed between each pushed value from the source before the resulting observable
- * will timeout.
- * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}.
- */
-export function timeout<T>(each: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-
-/**
- *
- * Errors if Observable does not emit a value in given time span.
- *
- * <span class="informal">Timeouts on Observable that doesn't emit values fast enough.</span>
- *
- * ![](timeout.png)
- *
- * @see {@link timeoutWith}
- *
- * @return A function that returns an Observable that mirrors behaviour of the
- * source Observable, unless timeout happens when it throws an error.
- */
-export function timeout<T, O extends ObservableInput<any>, M>(
-  config: number | Date | TimeoutConfig<T, O, M>,
-  schedulerArg?: SchedulerLike
-): OperatorFunction<T, T | ObservedValueOf<O>> {
-  // Intentionally terse code.
-  // If the first argument is a valid `Date`, then we use it as the `first` config.
-  // Otherwise, if the first argument is a `number`, then we use it as the `each` config.
-  // Otherwise, it can be assumed the first argument is the configuration object itself, and
-  // we destructure that into what we're going to use, setting important defaults as we do.
-  // NOTE: The default for `scheduler` will be the `scheduler` argument if it exists, or
-  // it will default to the `asyncScheduler`.
-  const {
-    first,
-    each,
-    with: _with = timeoutErrorFactory,
-    scheduler = schedulerArg ?? asyncScheduler,
-    meta = null!,
-  } = (isValidDate(config) ? { first: config } : typeof config === 'number' ? { each: config } : config) as TimeoutConfig<T, O, M>;
-
-  if (first == null && each == null) {
-    // Ensure timeout was provided at runtime.
-    throw new TypeError('No timeout provided.');
-  }
-
-  return operate((source, subscriber) => {
-    // This subscription encapsulates our subscription to the
-    // source for this operator. We're capturing it separately,
-    // because if there is a `with` observable to fail over to,
-    // we want to unsubscribe from our original subscription, and
-    // hand of the subscription to that one.
-    let originalSourceSubscription: Subscription;
-    // The subscription for our timeout timer. This changes
-    // every time we get a new value.
-    let timerSubscription: Subscription;
-    // A bit of state we pass to our with and error factories to
-    // tell what the last value we saw was.
-    let lastValue: T | null = null;
-    // A bit of state we pass to the with and error factories to
-    // tell how many values we have seen so far.
-    let seen = 0;
-    const startTimer = (delay: number) => {
-      timerSubscription = executeSchedule(
-        subscriber,
-        scheduler,
-        () => {
-          try {
-            originalSourceSubscription.unsubscribe();
-            innerFrom(
-              _with!({
-                meta,
-                lastValue,
-                seen,
-              })
-            ).subscribe(subscriber);
-          } catch (err) {
-            subscriber.error(err);
-          }
-        },
-        delay
-      );
-    };
-
-    originalSourceSubscription = source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value: T) => {
-          // clear the timer so we can emit and start another one.
-          timerSubscription?.unsubscribe();
-          seen++;
-          // Emit
-          subscriber.next((lastValue = value));
-          // null | undefined are both < 0. Thanks, JavaScript.
-          each! > 0 && startTimer(each!);
-        },
-        undefined,
-        undefined,
-        () => {
-          if (!timerSubscription?.closed) {
-            timerSubscription?.unsubscribe();
-          }
-          // Be sure not to hold the last value in memory after unsubscription
-          // it could be quite large.
-          lastValue = null;
-        }
-      )
-    );
-
-    // Intentionally terse code.
-    // If we've `seen` a value, that means the "first" clause was met already, if it existed.
-    //   it also means that a timer was already started for "each" (in the next handler above).
-    // If `first` was provided, and it's a number, then use it.
-    // If `first` was provided and it's not a number, it's a Date, and we get the difference between it and "now".
-    // If `first` was not provided at all, then our first timer will be the value from `each`.
-    !seen && startTimer(first != null ? (typeof first === 'number' ? first : +first - scheduler!.now()) : each!);
-  });
-}
-
-/**
- * The default function to use to emit an error when timeout occurs and a `with` function
- * is not specified.
- * @param info The information about the timeout to pass along to the error
- */
-function timeoutErrorFactory(info: TimeoutInfo<any>): Observable<never> {
-  throw new TimeoutError(info);
-}

package/tools/installer/node_modules/rxjs/src/internal/operators/timeoutWith.ts

@@ -1,116 +0,0 @@
-import { async } from '../scheduler/async';
-import { isValidDate } from '../util/isDate';
-import { ObservableInput, OperatorFunction, SchedulerLike } from '../types';
-import { timeout } from './timeout';
-
-/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(someDate, a$, scheduler)`, use the configuration object
- * `timeout({ first: someDate, with: () => a$, scheduler })`. Will be removed in v8. */
-export function timeoutWith<T, R>(dueBy: Date, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;
-/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(100, a$, scheduler)`, use the configuration object
- *  `timeout({ each: 100, with: () => a$, scheduler })`. Will be removed in v8. */
-export function timeoutWith<T, R>(waitFor: number, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;
-
-/**
- * When the passed timespan elapses before the source emits any given value, it will unsubscribe from the source,
- * and switch the subscription to another observable.
- *
- * <span class="informal">Used to switch to a different observable if your source is being slow.</span>
- *
- * Useful in cases where:
- *
- * - You want to switch to a different source that may be faster.
- * - You want to notify a user that the data stream is slow.
- * - You want to emit a custom error rather than the {@link TimeoutError} emitted
- *   by the default usage of {@link timeout}.
- *
- * If the first parameter is passed as Date and the time of the Date arrives before the first value arrives from the source,
- * it will unsubscribe from the source and switch the subscription to another observable.
- *
- * <span class="informal">Use Date object to switch to a different observable if the first value doesn't arrive by a specific time.</span>
- *
- * Can be used to set a timeout only for the first value, however it's recommended to use the {@link timeout} operator with
- * the `first` configuration to get the same effect.
- *
- * ## Examples
- *
- * Fallback to a faster observable
- *
- * ```ts
- * import { interval, timeoutWith } from 'rxjs';
- *
- * const slow$ = interval(1000);
- * const faster$ = interval(500);
- *
- * slow$
- *   .pipe(timeoutWith(900, faster$))
- *   .subscribe(console.log);
- * ```
- *
- * Emit your own custom timeout error
- *
- * ```ts
- * import { interval, timeoutWith, throwError } from 'rxjs';
- *
- * class CustomTimeoutError extends Error {
- *   constructor() {
- *     super('It was too slow');
- *     this.name = 'CustomTimeoutError';
- *   }
- * }
- *
- * const slow$ = interval(1000);
- *
- * slow$
- *   .pipe(timeoutWith(900, throwError(() => new CustomTimeoutError())))
- *   .subscribe({
- *     error: err => console.error(err.message)
- *   });
- * ```
- *
- * @see {@link timeout}
- *
- * @param due When passed a number, used as the time (in milliseconds) allowed between each value from the source before timeout
- * is triggered. When passed a Date, used as the exact time at which the timeout will be triggered if the first value does not arrive.
- * @param withObservable The observable to switch to when timeout occurs.
- * @param scheduler The scheduler to use with time-related operations within this operator. Defaults to {@link asyncScheduler}
- * @return A function that returns an Observable that mirrors behaviour of the
- * source Observable, unless timeout happens when it starts emitting values
- * from the `ObservableInput` passed as a second parameter.
- * @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(100, a$, scheduler)`, use {@link timeout} with the configuration
- * object: `timeout({ each: 100, with: () => a$, scheduler })`. Instead of `timeoutWith(someDate, a$, scheduler)`, use {@link timeout}
- * with the configuration object: `timeout({ first: someDate, with: () => a$, scheduler })`. Will be removed in v8.
- */
-export function timeoutWith<T, R>(
-  due: number | Date,
-  withObservable: ObservableInput<R>,
-  scheduler?: SchedulerLike
-): OperatorFunction<T, T | R> {
-  let first: number | Date | undefined;
-  let each: number | undefined;
-  let _with: () => ObservableInput<R>;
-  scheduler = scheduler ?? async;
-
-  if (isValidDate(due)) {
-    first = due;
-  } else if (typeof due === 'number') {
-    each = due;
-  }
-
-  if (withObservable) {
-    _with = () => withObservable;
-  } else {
-    throw new TypeError('No observable provided to switch to');
-  }
-
-  if (first == null && each == null) {
-    // Ensure timeout was provided at runtime.
-    throw new TypeError('No timeout provided.');
-  }
-
-  return timeout<T, ObservableInput<R>>({
-    first,
-    each,
-    scheduler,
-    with: _with,
-  });
-}

package/tools/installer/node_modules/rxjs/src/internal/operators/timestamp.ts

@@ -1,39 +0,0 @@
-import { OperatorFunction, TimestampProvider, Timestamp } from '../types';
-import { dateTimestampProvider } from '../scheduler/dateTimestampProvider';
-import { map } from './map';
-
-/**
- * Attaches a timestamp to each item emitted by an observable indicating when it was emitted
- *
- * The `timestamp` operator maps the *source* observable stream to an object of type
- * `{value: T, timestamp: R}`. The properties are generically typed. The `value` property contains the value
- * and type of the *source* observable. The `timestamp` is generated by the schedulers `now` function. By
- * default, it uses the `asyncScheduler` which simply returns `Date.now()` (milliseconds since 1970/01/01
- * 00:00:00:000) and therefore is of type `number`.
- *
- * ![](timestamp.png)
- *
- * ## Example
- *
- * In this example there is a timestamp attached to the document's click events
- *
- * ```ts
- * import { fromEvent, timestamp } from 'rxjs';
- *
- * const clickWithTimestamp = fromEvent(document, 'click').pipe(
- *   timestamp()
- * );
- *
- * // Emits data of type { value: PointerEvent, timestamp: number }
- * clickWithTimestamp.subscribe(data => {
- *   console.log(data);
- * });
- * ```
- *
- * @param timestampProvider An object with a `now()` method used to get the current timestamp.
- * @return A function that returns an Observable that attaches a timestamp to
- * each item emitted by the source Observable indicating when it was emitted.
- */
-export function timestamp<T>(timestampProvider: TimestampProvider = dateTimestampProvider): OperatorFunction<T, Timestamp<T>> {
-  return map((value: T) => ({ value, timestamp: timestampProvider.now() }));
-}

package/tools/installer/node_modules/rxjs/src/internal/operators/toArray.ts

@@ -1,44 +0,0 @@
-import { reduce } from './reduce';
-import { OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-
-const arrReducer = (arr: any[], value: any) => (arr.push(value), arr);
-
-/**
- * Collects all source emissions and emits them as an array when the source completes.
- *
- * <span class="informal">Get all values inside an array when the source completes</span>
- *
- * ![](toArray.png)
- *
- * `toArray` will wait until the source Observable completes before emitting
- * the array containing all emissions. When the source Observable errors no
- * array will be emitted.
- *
- * ## Example
- *
- * ```ts
- * import { interval, take, toArray } from 'rxjs';
- *
- * const source = interval(1000);
- * const example = source.pipe(
- *   take(10),
- *   toArray()
- * );
- *
- * example.subscribe(value => console.log(value));
- *
- * // output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- * ```
- *
- * @return A function that returns an Observable that emits an array of items
- * emitted by the source Observable when source completes.
- */
-export function toArray<T>(): OperatorFunction<T, T[]> {
-  // Because arrays are mutable, and we're mutating the array in this
-  // reducer process, we have to encapsulate the creation of the initial
-  // array within this `operate` function.
-  return operate((source, subscriber) => {
-    reduce(arrReducer, [] as T[])(source).subscribe(subscriber);
-  });
-}