@alexlit/lint-kit 186.2.2 → 186.3.0

package/packages/config-stylelint/node_modules/rxjs/src/internal/observable/race.ts

@@ -1,139 +0,0 @@
-import { Observable } from '../Observable';
-import { isArray } from '../util/isArray';
-import { fromArray } from './fromArray';
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { Subscription } from '../Subscription';
-import { TeardownLogic, ObservableInput } from '../types';
-import { OuterSubscriber } from '../OuterSubscriber';
-import { InnerSubscriber } from '../InnerSubscriber';
-import { subscribeToResult } from '../util/subscribeToResult';
-
-// tslint:disable:max-line-length
-export function race<A>(arg: [ObservableInput<A>]): Observable<A>;
-export function race<A, B>(arg: [ObservableInput<A>, ObservableInput<B>]): Observable<A | B>;
-export function race<A, B, C>(arg: [ObservableInput<A>, ObservableInput<B>, ObservableInput<C>]): Observable<A | B | C>;
-export function race<A, B, C, D>(arg: [ObservableInput<A>, ObservableInput<B>, ObservableInput<C>, ObservableInput<D>]): Observable<A | B | C | D>;
-export function race<A, B, C, D, E>(arg: [ObservableInput<A>, ObservableInput<B>, ObservableInput<C>, ObservableInput<D>, ObservableInput<E>]): Observable<A | B | C | D | E>;
-export function race<T>(arg: ObservableInput<T>[]): Observable<T>;
-export function race(arg: ObservableInput<any>[]): Observable<{}>;
-
-export function race<A>(a: ObservableInput<A>): Observable<A>;
-export function race<A, B>(a: ObservableInput<A>, b: ObservableInput<B>): Observable<A | B>;
-export function race<A, B, C>(a: ObservableInput<A>, b: ObservableInput<B>, c: ObservableInput<C>): Observable<A | B | C>;
-export function race<A, B, C, D>(a: ObservableInput<A>, b: ObservableInput<B>, c: ObservableInput<C>, d: ObservableInput<D>): Observable<A | B | C | D>;
-export function race<A, B, C, D, E>(a: ObservableInput<A>, b: ObservableInput<B>, c: ObservableInput<C>, d: ObservableInput<D>, e: ObservableInput<E>): Observable<A | B | C | D | E>;
-// tslint:enable:max-line-length
-
-export function race<T>(observables: ObservableInput<T>[]): Observable<T>;
-export function race(observables: ObservableInput<any>[]): Observable<{}>;
-export function race<T>(...observables: ObservableInput<T>[]): Observable<T>;
-export function race(...observables: ObservableInput<any>[]): Observable<{}>;
-
-/**
- * Returns an Observable that mirrors the first source Observable to emit an item.
- *
- * ## Example
- * ### Subscribes to the observable that was the first to start emitting.
- *
- * ```ts
- * import { race, interval } from 'rxjs';
- * import { mapTo } from 'rxjs/operators';
- *
- * const obs1 = interval(1000).pipe(mapTo('fast one'));
- * const obs2 = interval(3000).pipe(mapTo('medium one'));
- * const obs3 = interval(5000).pipe(mapTo('slow one'));
- *
- * race(obs3, obs1, obs2)
- * .subscribe(
- *   winner => console.log(winner)
- * );
- *
- * // result:
- * // a series of 'fast one'
- * ```
- *
- * @param {...Observables} ...observables sources used to race for which Observable emits first.
- * @return {Observable} an Observable that mirrors the output of the first Observable to emit an item.
- * @static true
- * @name race
- * @owner Observable
- */
-export function race<T>(...observables: ObservableInput<any>[]): Observable<T> {
-  // if the only argument is an array, it was most likely called with
-  // `race([obs1, obs2, ...])`
-  if (observables.length === 1) {
-    if (isArray(observables[0])) {
-      observables = observables[0] as Observable<any>[];
-    } else {
-      return observables[0] as Observable<T>;
-    }
-  }
-
-  return fromArray(observables, undefined).lift(new RaceOperator<T>());
-}
-
-export class RaceOperator<T> implements Operator<T, T> {
-  call(subscriber: Subscriber<T>, source: any): TeardownLogic {
-    return source.subscribe(new RaceSubscriber(subscriber));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-export class RaceSubscriber<T> extends OuterSubscriber<T, T> {
-  private hasFirst: boolean = false;
-  private observables: Observable<any>[] = [];
-  private subscriptions: Subscription[] = [];
-
-  constructor(destination: Subscriber<T>) {
-    super(destination);
-  }
-
-  protected _next(observable: any): void {
-    this.observables.push(observable);
-  }
-
-  protected _complete() {
-    const observables = this.observables;
-    const len = observables.length;
-
-    if (len === 0) {
-      this.destination.complete!();
-    } else {
-      for (let i = 0; i < len && !this.hasFirst; i++) {
-        const observable = observables[i];
-        const subscription = subscribeToResult(this, observable, undefined, i)!;
-
-        if (this.subscriptions) {
-          this.subscriptions.push(subscription);
-        }
-        this.add(subscription);
-      }
-      this.observables = null!;
-    }
-  }
-
-  notifyNext(_outerValue: T, innerValue: T,
-             outerIndex: number): void {
-    if (!this.hasFirst) {
-      this.hasFirst = true;
-
-      for (let i = 0; i < this.subscriptions.length; i++) {
-        if (i !== outerIndex) {
-          let subscription = this.subscriptions[i];
-
-          subscription.unsubscribe();
-          this.remove(subscription);
-        }
-      }
-
-      this.subscriptions = null!;
-    }
-
-    this.destination.next!(innerValue);
-  }
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/observable/range.ts

@@ -1,90 +0,0 @@
-import { SchedulerAction, SchedulerLike } from '../types';
-import { Observable } from '../Observable';
-
-/**
- * Creates an Observable that emits a sequence of numbers within a specified
- * range.
- *
- * <span class="informal">Emits a sequence of numbers in a range.</span>
- *
- * ![](range.png)
- *
- * `range` operator emits a range of sequential integers, in order, where you
- * select the `start` of the range and its `length`. By default, uses no
- * {@link SchedulerLike} and just delivers the notifications synchronously, but may use
- * an optional {@link SchedulerLike} to regulate those deliveries.
- *
- * ## Example
- * Emits the numbers 1 to 10</caption>
- * ```ts
- * import { range } from 'rxjs';
- *
- * const numbers = range(1, 10);
- * numbers.subscribe(x => console.log(x));
- * ```
- * @see {@link timer}
- * @see {@link index/interval}
- *
- * @param {number} [start=0] The value of the first integer in the sequence.
- * @param {number} count The number of sequential integers to generate.
- * @param {SchedulerLike} [scheduler] A {@link SchedulerLike} to use for scheduling
- * the emissions of the notifications.
- * @return {Observable} An Observable of numbers that emits a finite range of
- * sequential integers.
- * @static true
- * @name range
- * @owner Observable
- */
-export function range(start: number = 0,
-                      count?: number,
-                      scheduler?: SchedulerLike): Observable<number> {
-  return new Observable<number>(subscriber => {
-    if (count === undefined) {
-      count = start;
-      start = 0;
-    }
-
-    let index = 0;
-    let current = start;
-
-    if (scheduler) {
-      return scheduler.schedule(dispatch, 0, {
-        index, count, start, subscriber
-      });
-    } else {
-      do {
-        if (index++ >= count) {
-          subscriber.complete();
-          break;
-        }
-        subscriber.next(current++);
-        if (subscriber.closed) {
-          break;
-        }
-      } while (true);
-    }
-
-    return undefined;
-  });
-}
-
-/** @internal */
-export function dispatch(this: SchedulerAction<any>, state: any) {
-  const { start, index, count, subscriber } = state;
-
-  if (index >= count) {
-    subscriber.complete();
-    return;
-  }
-
-  subscriber.next(start);
-
-  if (subscriber.closed) {
-    return;
-  }
-
-  state.index = index + 1;
-  state.start = start + 1;
-
-  this.schedule(state);
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/observable/throwError.ts

@@ -1,84 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerLike } from '../types';
-import { Subscriber } from '../Subscriber';
-
-/**
- * Creates an Observable that emits no items to the Observer and immediately
- * emits an error notification.
- *
- * <span class="informal">Just emits 'error', and nothing else.
- * </span>
- *
- * ![](throw.png)
- *
- * This static operator is useful for creating a simple Observable that only
- * emits the error notification. It can be used for composing with other
- * Observables, such as in a {@link mergeMap}.
- *
- * ## Examples
- * ### Emit the number 7, then emit an error
- * ```ts
- * import { throwError, concat, of } from 'rxjs';
- *
- * const result = concat(of(7), throwError(new Error('oops!')));
- * result.subscribe(x => console.log(x), e => console.error(e));
- *
- * // Logs:
- * // 7
- * // Error: oops!
- * ```
- *
- * ---
- *
- * ### Map and flatten numbers to the sequence 'a', 'b', 'c', but throw an error for 2
- * ```ts
- * import { throwError, interval, of } from 'rxjs';
- * import { mergeMap } from 'rxjs/operators';
- *
- * interval(1000).pipe(
- *   mergeMap(x => x === 2
- *     ? throwError('Twos are bad')
- *     : of('a', 'b', 'c')
- *   ),
- * ).subscribe(x => console.log(x), e => console.error(e));
- *
- * // Logs:
- * // a
- * // b
- * // c
- * // a
- * // b
- * // c
- * // Twos are bad
- * ```
- *
- * @see {@link Observable}
- * @see {@link empty}
- * @see {@link never}
- * @see {@link of}
- *
- * @param {any} error The particular Error to pass to the error notification.
- * @param {SchedulerLike} [scheduler] A {@link SchedulerLike} to use for scheduling
- * the emission of the error notification.
- * @return {Observable} An error Observable: emits only the error notification
- * using the given error argument.
- * @static true
- * @name throwError
- * @owner Observable
- */
-export function throwError(error: any, scheduler?: SchedulerLike): Observable<never> {
-  if (!scheduler) {
-    return new Observable(subscriber => subscriber.error(error));
-  } else {
-    return new Observable(subscriber => scheduler.schedule(dispatch, 0, { error, subscriber }));
-  }
-}
-
-interface DispatchArg {
-  error: any;
-  subscriber: Subscriber<any>;
-}
-
-function dispatch({ error, subscriber }: DispatchArg) {
-  subscriber.error(error);
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/observable/timer.ts

@@ -1,101 +0,0 @@
-import { Observable } from '../Observable';
-import { SchedulerAction, SchedulerLike } from '../types';
-import { async } from '../scheduler/async';
-import { isNumeric } from '../util/isNumeric';
-import { isScheduler } from '../util/isScheduler';
-import { Subscriber } from '../Subscriber';
-
-/**
- * Creates an Observable that starts emitting after an `dueTime` and
- * emits ever increasing numbers after each `period` of time thereafter.
- *
- * <span class="informal">Its like {@link index/interval}, but you can specify when
- * should the emissions start.</span>
- *
- * ![](timer.png)
- *
- * `timer` returns an Observable that emits an infinite sequence of ascending
- * integers, with a constant interval of time, `period` of your choosing
- * between those emissions. The first emission happens after the specified
- * `dueTime`. The initial delay may be a `Date`. By default, this
- * operator uses the {@link asyncScheduler} {@link SchedulerLike} to provide a notion of time, but you
- * may pass any {@link SchedulerLike} to it. If `period` is not specified, the output
- * Observable emits only one value, `0`. Otherwise, it emits an infinite
- * sequence.
- *
- * ## Examples
- * ### Emits ascending numbers, one every second (1000ms), starting after 3 seconds
- * ```ts
- * import { timer } from 'rxjs';
- *
- * const numbers = timer(3000, 1000);
- * numbers.subscribe(x => console.log(x));
- * ```
- *
- * ### Emits one number after five seconds
- * ```ts
- * import { timer } from 'rxjs';
- *
- * const numbers = timer(5000);
- * numbers.subscribe(x => console.log(x));
- * ```
- * @see {@link index/interval}
- * @see {@link delay}
- *
- * @param {number|Date} [dueTime] The initial delay time specified as a Date object or as an integer denoting
- * milliseconds to wait before emitting the first value of 0`.
- * @param {number|SchedulerLike} [periodOrScheduler] The period of time between emissions of the
- * subsequent numbers.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for scheduling
- * the emission of values, and providing a notion of "time".
- * @return {Observable} An Observable that emits a `0` after the
- * `dueTime` and ever increasing numbers after each `period` of time
- * thereafter.
- * @static true
- * @name timer
- * @owner Observable
- */
-export function timer(dueTime: number | Date = 0,
-                      periodOrScheduler?: number | SchedulerLike,
-                      scheduler?: SchedulerLike): Observable<number> {
-  let period = -1;
-  if (isNumeric(periodOrScheduler)) {
-    period = Number(periodOrScheduler) < 1 && 1 || Number(periodOrScheduler);
-  } else if (isScheduler(periodOrScheduler)) {
-    scheduler = periodOrScheduler as any;
-  }
-
-  if (!isScheduler(scheduler)) {
-    scheduler = async;
-  }
-
-  return new Observable(subscriber => {
-    const due = isNumeric(dueTime)
-      ? (dueTime as number)
-      : (+dueTime - scheduler.now());
-
-    return scheduler.schedule(dispatch, due, {
-      index: 0, period, subscriber
-    });
-  });
-}
-
-interface TimerState {
-  index: number;
-  period: number;
-  subscriber: Subscriber<number>;
-}
-
-function dispatch(this: SchedulerAction<TimerState>, state: TimerState) {
-  const { index, period, subscriber } = state;
-  subscriber.next(index);
-
-  if (subscriber.closed) {
-    return;
-  } else if (period === -1) {
-    return subscriber.complete();
-  }
-
-  state.index = index + 1;
-  this.schedule(state, period);
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/observable/using.ts

@@ -1,63 +0,0 @@
-import { Observable } from '../Observable';
-import { Unsubscribable, ObservableInput } from '../types';
-import { from } from './from'; // from from from! LAWL
-import { EMPTY } from './empty';
-
-/**
- * Creates an Observable that uses a resource which will be disposed at the same time as the Observable.
- *
- * <span class="informal">Use it when you catch yourself cleaning up after an Observable.</span>
- *
- * `using` is a factory operator, which accepts two functions. First function returns a disposable resource.
- * It can be an arbitrary object that implements `unsubscribe` method. Second function will be injected with
- * that object and should return an Observable. That Observable can use resource object during its execution.
- * Both functions passed to `using` will be called every time someone subscribes - neither an Observable nor
- * resource object will be shared in any way between subscriptions.
- *
- * When Observable returned by `using` is subscribed, Observable returned from the second function will be subscribed
- * as well. All its notifications (nexted values, completion and error events) will be emitted unchanged by the output
- * Observable. If however someone unsubscribes from the Observable or source Observable completes or errors by itself,
- * the `unsubscribe` method on resource object will be called. This can be used to do any necessary clean up, which
- * otherwise would have to be handled by hand. Note that complete or error notifications are not emitted when someone
- * cancels subscription to an Observable via `unsubscribe`, so `using` can be used as a hook, allowing you to make
- * sure that all resources which need to exist during an Observable execution will be disposed at appropriate time.
- *
- * @see {@link defer}
- *
- * @param {function(): ISubscription} resourceFactory A function which creates any resource object
- * that implements `unsubscribe` method.
- * @param {function(resource: ISubscription): Observable<T>} observableFactory A function which
- * creates an Observable, that can use injected resource object.
- * @return {Observable<T>} An Observable that behaves the same as Observable returned by `observableFactory`, but
- * which - when completed, errored or unsubscribed - will also call `unsubscribe` on created resource object.
- */
-export function using<T>(resourceFactory: () => Unsubscribable | void,
-                         observableFactory: (resource: Unsubscribable | void) => ObservableInput<T> | void): Observable<T> {
-  return new Observable<T>(subscriber => {
-    let resource: Unsubscribable | void;
-
-    try {
-      resource = resourceFactory();
-    } catch (err) {
-      subscriber.error(err);
-      return undefined;
-    }
-
-    let result: ObservableInput<T> | void;
-    try {
-      result = observableFactory(resource);
-    } catch (err) {
-      subscriber.error(err);
-      return undefined;
-    }
-
-    const source = result ? from(result) : EMPTY;
-    const subscription = source.subscribe(subscriber);
-    return () => {
-      subscription.unsubscribe();
-      if (resource) {
-        resource.unsubscribe();
-      }
-    };
-  });
-}