@alexlit/lint-kit 186.2.2 → 186.3.0

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

@@ -1,379 +0,0 @@
-import { Observable } from '../Observable';
-import { Subscriber } from '../Subscriber';
-import { identity } from '../util/identity';
-import { SchedulerAction, SchedulerLike } from '../types';
-import { isScheduler } from '../util/isScheduler';
-
-export type ConditionFunc<S> = (state: S) => boolean;
-export type IterateFunc<S> = (state: S) => S;
-export type ResultFunc<S, T> = (state: S) => T;
-
-interface SchedulerState<T, S> {
-  needIterate?: boolean;
-  state: S;
-  subscriber: Subscriber<T>;
-  condition?: ConditionFunc<S>;
-  iterate: IterateFunc<S>;
-  resultSelector: ResultFunc<S, T>;
-}
-
-export interface GenerateBaseOptions<S> {
-  /**
-   * Initial state.
-   */
-  initialState: S;
-  /**
-   * Condition function that accepts state and returns boolean.
-   * When it returns false, the generator stops.
-   * If not specified, a generator never stops.
-   */
-  condition?: ConditionFunc<S>;
-  /**
-   * Iterate function that accepts state and returns new state.
-   */
-  iterate: IterateFunc<S>;
-  /**
-   * SchedulerLike to use for generation process.
-   * By default, a generator starts immediately.
-   */
-  scheduler?: SchedulerLike;
-}
-
-export interface GenerateOptions<T, S> extends GenerateBaseOptions<S> {
-  /**
-   * Result selection function that accepts state and returns a value to emit.
-   */
-  resultSelector: ResultFunc<S, T>;
-}
-
-/**
- * Generates an observable sequence by running a state-driven loop
- * producing the sequence's elements, using the specified scheduler
- * to send out observer messages.
- *
- * ![](generate.png)
- *
- * @example <caption>Produces sequence of 0, 1, 2, ... 9, then completes.</caption>
- * const res = generate(0, x => x < 10, x => x + 1, x => x);
- *
- * @example <caption>Using asap scheduler, produces sequence of 2, 3, 5, then completes.</caption>
- * const res = generate(1, x => x < 5, x => x * 2, x => x + 1, asap);
- *
- * @see {@link from}
- * @see {@link Observable}
- *
- * @param {S} initialState Initial state.
- * @param {function (state: S): boolean} condition Condition to terminate generation (upon returning false).
- * @param {function (state: S): S} iterate Iteration step function.
- * @param {function (state: S): T} resultSelector Selector function for results produced in the sequence. (deprecated)
- * @param {SchedulerLike} [scheduler] A {@link SchedulerLike} on which to run the generator loop. If not provided, defaults to emit immediately.
- * @returns {Observable<T>} The generated sequence.
- */
-  export function generate<T, S>(initialState: S,
-                                 condition: ConditionFunc<S>,
-                                 iterate: IterateFunc<S>,
-                                 resultSelector: ResultFunc<S, T>,
-                                 scheduler?: SchedulerLike): Observable<T>;
-
-/**
- * Generates an Observable by running a state-driven loop
- * that emits an element on each iteration.
- *
- * <span class="informal">Use it instead of nexting values in a for loop.</span>
- *
- * <img src="./img/generate.png" width="100%">
- *
- * `generate` allows you to create stream of values generated with a loop very similar to
- * traditional for loop. First argument of `generate` is a beginning value. Second argument
- * is a function that accepts this value and tests if some condition still holds. If it does,
- * loop continues, if not, it stops. Third value is a function which takes previously defined
- * value and modifies it in some way on each iteration. Note how these three parameters
- * are direct equivalents of three expressions in regular for loop: first expression
- * initializes some state (for example numeric index), second tests if loop can make next
- * iteration (for example if index is lower than 10) and third states how defined value
- * will be modified on every step (index will be incremented by one).
- *
- * Return value of a `generate` operator is an Observable that on each loop iteration
- * emits a value. First, condition function is ran. If it returned true, Observable
- * emits currently stored value (initial value at the first iteration) and then updates
- * that value with iterate function. If at some point condition returned false, Observable
- * completes at that moment.
- *
- * Optionally you can pass fourth parameter to `generate` - a result selector function which allows you
- * to immediately map value that would normally be emitted by an Observable.
- *
- * If you find three anonymous functions in `generate` call hard to read, you can provide
- * single object to the operator instead. That object has properties: `initialState`,
- * `condition`, `iterate` and `resultSelector`, which should have respective values that you
- * would normally pass to `generate`. `resultSelector` is still optional, but that form
- * of calling `generate` allows you to omit `condition` as well. If you omit it, that means
- * condition always holds, so output Observable will never complete.
- *
- * Both forms of `generate` can optionally accept a scheduler. In case of multi-parameter call,
- * scheduler simply comes as a last argument (no matter if there is resultSelector
- * function or not). In case of single-parameter call, you can provide it as a
- * `scheduler` property on object passed to the operator. In both cases scheduler decides when
- * next iteration of the loop will happen and therefore when next value will be emitted
- * by the Observable. For example to ensure that each value is pushed to the observer
- * on separate task in event loop, you could use `async` scheduler. Note that
- * by default (when no scheduler is passed) values are simply emitted synchronously.
- *
- *
- * @example <caption>Use with condition and iterate functions.</caption>
- * const generated = generate(0, x => x < 3, x => x + 1);
- *
- * generated.subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('Yo!')
- * );
- *
- * // Logs:
- * // 0
- * // 1
- * // 2
- * // "Yo!"
- *
- *
- * @example <caption>Use with condition, iterate and resultSelector functions.</caption>
- * const generated = generate(0, x => x < 3, x => x + 1, x => x * 1000);
- *
- * generated.subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('Yo!')
- * );
- *
- * // Logs:
- * // 0
- * // 1000
- * // 2000
- * // "Yo!"
- *
- *
- * @example <caption>Use with options object.</caption>
- * const generated = generate({
- *   initialState: 0,
- *   condition(value) { return value < 3; },
- *   iterate(value) { return value + 1; },
- *   resultSelector(value) { return value * 1000; }
- * });
- *
- * generated.subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('Yo!')
- * );
- *
- * // Logs:
- * // 0
- * // 1000
- * // 2000
- * // "Yo!"
- *
- * @example <caption>Use options object without condition function.</caption>
- * const generated = generate({
- *   initialState: 0,
- *   iterate(value) { return value + 1; },
- *   resultSelector(value) { return value * 1000; }
- * });
- *
- * generated.subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('Yo!') // This will never run.
- * );
- *
- * // Logs:
- * // 0
- * // 1000
- * // 2000
- * // 3000
- * // ...and never stops.
- *
- *
- * @see {@link from}
- * @see {@link index/Observable.create}
- *
- * @param {S} initialState Initial state.
- * @param {function (state: S): boolean} condition Condition to terminate generation (upon returning false).
- * @param {function (state: S): S} iterate Iteration step function.
- * @param {function (state: S): T} [resultSelector] Selector function for results produced in the sequence.
- * @param {Scheduler} [scheduler] A {@link Scheduler} on which to run the generator loop. If not provided, defaults to emitting immediately.
- * @return {Observable<T>} The generated sequence.
- */
-export function generate<S>(initialState: S,
-                            condition: ConditionFunc<S>,
-                            iterate: IterateFunc<S>,
-                            scheduler?: SchedulerLike): Observable<S>;
-
-/**
- * Generates an observable sequence by running a state-driven loop
- * producing the sequence's elements, using the specified scheduler
- * to send out observer messages.
- * The overload accepts options object that might contain initial state, iterate,
- * condition and scheduler.
- *
- * ![](generate.png)
- *
- * @example <caption>Produces sequence of 0, 1, 2, ... 9, then completes.</caption>
- * const res = generate({
- *   initialState: 0,
- *   condition: x => x < 10,
- *   iterate: x => x + 1,
- * });
- *
- * @see {@link from}
- * @see {@link Observable}
- *
- * @param {GenerateBaseOptions<S>} options Object that must contain initialState, iterate and might contain condition and scheduler.
- * @returns {Observable<S>} The generated sequence.
- */
-export function generate<S>(options: GenerateBaseOptions<S>): Observable<S>;
-
-/**
- * Generates an observable sequence by running a state-driven loop
- * producing the sequence's elements, using the specified scheduler
- * to send out observer messages.
- * The overload accepts options object that might contain initial state, iterate,
- * condition, result selector and scheduler.
- *
- * ![](generate.png)
- *
- * @example <caption>Produces sequence of 0, 1, 2, ... 9, then completes.</caption>
- * const res = generate({
- *   initialState: 0,
- *   condition: x => x < 10,
- *   iterate: x => x + 1,
- *   resultSelector: x => x,
- * });
- *
- * @see {@link from}
- * @see {@link Observable}
- *
- * @param {GenerateOptions<T, S>} options Object that must contain initialState, iterate, resultSelector and might contain condition and scheduler.
- * @returns {Observable<T>} The generated sequence.
- */
-export function generate<T, S>(options: GenerateOptions<T, S>): Observable<T>;
-
-export function generate<T, S>(initialStateOrOptions: S | GenerateOptions<T, S>,
-                               condition?: ConditionFunc<S>,
-                               iterate?: IterateFunc<S>,
-                               resultSelectorOrObservable?: (ResultFunc<S, T>) | SchedulerLike,
-                               scheduler?: SchedulerLike): Observable<T> {
-
-  let resultSelector: ResultFunc<S, T>;
-  let initialState: S;
-
-  if (arguments.length == 1) {
-    const options = initialStateOrOptions as GenerateOptions<T, S>;
-    initialState = options.initialState;
-    condition = options.condition;
-    iterate = options.iterate;
-    resultSelector = options.resultSelector || identity as ResultFunc<S, T>;
-    scheduler = options.scheduler;
-  } else if (resultSelectorOrObservable === undefined || isScheduler(resultSelectorOrObservable)) {
-    initialState = initialStateOrOptions as S;
-    resultSelector = identity as ResultFunc<S, T>;
-    scheduler = resultSelectorOrObservable as SchedulerLike;
-  } else {
-    initialState = initialStateOrOptions as S;
-    resultSelector = resultSelectorOrObservable as ResultFunc<S, T>;
-  }
-
-  return new Observable<T>(subscriber => {
-    let state = initialState;
-    if (scheduler) {
-      return scheduler.schedule<SchedulerState<T, S>>(dispatch, 0, {
-        subscriber,
-        iterate,
-        condition,
-        resultSelector,
-        state
-      });
-    }
-
-    do {
-      if (condition) {
-        let conditionResult: boolean;
-        try {
-          conditionResult = condition(state);
-        } catch (err) {
-          subscriber.error(err);
-          return undefined;
-        }
-        if (!conditionResult) {
-          subscriber.complete();
-          break;
-        }
-      }
-      let value: T;
-      try {
-        value = resultSelector(state);
-      } catch (err) {
-        subscriber.error(err);
-        return undefined;
-      }
-      subscriber.next(value);
-      if (subscriber.closed) {
-        break;
-      }
-      try {
-        state = iterate(state);
-      } catch (err) {
-        subscriber.error(err);
-        return undefined;
-      }
-    } while (true);
-
-    return undefined;
-  });
-}
-
-function dispatch<T, S>(this: SchedulerAction<SchedulerState<T, S>>, state: SchedulerState<T, S>) {
-  const { subscriber, condition } = state;
-  if (subscriber.closed) {
-    return undefined;
-  }
-  if (state.needIterate) {
-    try {
-      state.state = state.iterate(state.state);
-    } catch (err) {
-      subscriber.error(err);
-      return undefined;
-    }
-  } else {
-    state.needIterate = true;
-  }
-  if (condition) {
-    let conditionResult: boolean;
-    try {
-      conditionResult = condition(state.state);
-    } catch (err) {
-      subscriber.error(err);
-      return undefined;
-    }
-    if (!conditionResult) {
-      subscriber.complete();
-      return undefined;
-    }
-    if (subscriber.closed) {
-      return undefined;
-    }
-  }
-  let value: T;
-  try {
-    value = state.resultSelector(state.state);
-  } catch (err) {
-    subscriber.error(err);
-    return undefined;
-  }
-  if (subscriber.closed) {
-    return undefined;
-  }
-  subscriber.next(value);
-  if (subscriber.closed) {
-    return undefined;
-  }
-  return this.schedule(state);
-}

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

@@ -1,100 +0,0 @@
-import { Observable } from '../Observable';
-import { defer } from './defer';
-import { EMPTY } from './empty';
-import { SubscribableOrPromise } from '../types';
-
-/**
- * Decides at subscription time which Observable will actually be subscribed.
- *
- * <span class="informal">`If` statement for Observables.</span>
- *
- * `iif` accepts a condition function and two Observables. When
- * an Observable returned by the operator is subscribed, condition function will be called.
- * Based on what boolean it returns at that moment, consumer will subscribe either to
- * the first Observable (if condition was true) or to the second (if condition was false). Condition
- * function may also not return anything - in that case condition will be evaluated as false and
- * second Observable will be subscribed.
- *
- * Note that Observables for both cases (true and false) are optional. If condition points to an Observable that
- * was left undefined, resulting stream will simply complete immediately. That allows you to, rather
- * than controlling which Observable will be subscribed, decide at runtime if consumer should have access
- * to given Observable or not.
- *
- * If you have more complex logic that requires decision between more than two Observables, {@link defer}
- * will probably be a better choice. Actually `iif` can be easily implemented with {@link defer}
- * and exists only for convenience and readability reasons.
- *
- *
- * ## Examples
- * ### Change at runtime which Observable will be subscribed
- * ```ts
- * import { iif, of } from 'rxjs';
- *
- * let subscribeToFirst;
- * const firstOrSecond = iif(
- *   () => subscribeToFirst,
- *   of('first'),
- *   of('second'),
- * );
- *
- * subscribeToFirst = true;
- * firstOrSecond.subscribe(value => console.log(value));
- *
- * // Logs:
- * // "first"
- *
- * subscribeToFirst = false;
- * firstOrSecond.subscribe(value => console.log(value));
- *
- * // Logs:
- * // "second"
- *
- * ```
- *
- * ### Control an access to an Observable
- * ```ts
- * let accessGranted;
- * const observableIfYouHaveAccess = iif(
- *   () => accessGranted,
- *   of('It seems you have an access...'), // Note that only one Observable is passed to the operator.
- * );
- *
- * accessGranted = true;
- * observableIfYouHaveAccess.subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('The end'),
- * );
- *
- * // Logs:
- * // "It seems you have an access..."
- * // "The end"
- *
- * accessGranted = false;
- * observableIfYouHaveAccess.subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('The end'),
- * );
- *
- * // Logs:
- * // "The end"
- * ```
- *
- * @see {@link defer}
- *
- * @param {function(): boolean} condition Condition which Observable should be chosen.
- * @param {Observable} [trueObservable] An Observable that will be subscribed if condition is true.
- * @param {Observable} [falseObservable] An Observable that will be subscribed if condition is false.
- * @return {Observable} Either first or second Observable, depending on condition.
- * @static true
- * @name iif
- * @owner Observable
-*/
-export function iif<T = never, F = never>(
-  condition: () => boolean,
-  trueResult: SubscribableOrPromise<T> = EMPTY,
-  falseResult: SubscribableOrPromise<F> = EMPTY
-): Observable<T|F> {
-  return defer(() => condition() ? trueResult : falseResult);
-}

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

@@ -1,83 +0,0 @@
-import { Observable } from '../Observable';
-import { async } from '../scheduler/async';
-import { SchedulerAction, SchedulerLike } from '../types';
-import { isNumeric } from '../util/isNumeric';
-import { Subscriber } from '../Subscriber';
-
-/**
- * Creates an Observable that emits sequential numbers every specified
- * interval of time, on a specified {@link SchedulerLike}.
- *
- * <span class="informal">Emits incremental numbers periodically in time.
- * </span>
- *
- * ![](interval.png)
- *
- * `interval` returns an Observable that emits an infinite sequence of
- * ascending integers, with a constant interval of time of your choosing
- * between those emissions. The first emission is not sent immediately, but
- * only after the first period has passed. By default, this operator uses the
- * `async` {@link SchedulerLike} to provide a notion of time, but you may pass any
- * {@link SchedulerLike} to it.
- *
- * ## Example
- * Emits ascending numbers, one every second (1000ms) up to the number 3
- * ```ts
- * import { interval } from 'rxjs';
- * import { take } from 'rxjs/operators';
- *
- * const numbers = interval(1000);
- *
- * const takeFourNumbers = numbers.pipe(take(4));
- *
- * takeFourNumbers.subscribe(x => console.log('Next: ', x));
- *
- * // Logs:
- * // Next: 0
- * // Next: 1
- * // Next: 2
- * // Next: 3
- * ```
- *
- * @see {@link timer}
- * @see {@link delay}
- *
- * @param {number} [period=0] The interval size in milliseconds (by default)
- * or the time unit determined by the scheduler's clock.
- * @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 sequential number each time
- * interval.
- * @static true
- * @name interval
- * @owner Observable
- */
-export function interval(period = 0,
-                         scheduler: SchedulerLike = async): Observable<number> {
-  if (!isNumeric(period) || period < 0) {
-    period = 0;
-  }
-
-  if (!scheduler || typeof scheduler.schedule !== 'function') {
-    scheduler = async;
-  }
-
-  return new Observable<number>(subscriber => {
-    subscriber.add(
-      scheduler.schedule(dispatch, period, { subscriber, counter: 0, period })
-    );
-    return subscriber;
-  });
-}
-
-function dispatch(this: SchedulerAction<IntervalState>, state: IntervalState) {
-  const { subscriber, counter, period } = state;
-  subscriber.next(counter);
-  this.schedule({ subscriber, counter: counter + 1, period }, period);
-}
-
-interface IntervalState {
-  subscriber: Subscriber<number>;
-  counter: number;
-  period: number;
-}