@alexlit/lint-kit 186.2.2 → 186.3.1

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/partition.ts

@@ -1,60 +0,0 @@
-import { not } from '../util/not';
-import { filter } from './filter';
-import { Observable } from '../Observable';
-import { UnaryFunction } from '../types';
-
-/**
- * Splits the source Observable into two, one with values that satisfy a
- * predicate, and another with values that don't satisfy the predicate.
- *
- * <span class="informal">It's like {@link filter}, but returns two Observables:
- * one like the output of {@link filter}, and the other with values that did not
- * pass the condition.</span>
- *
- * ![](partition.png)
- *
- * `partition` outputs an array with two Observables that partition the values
- * from the source Observable through the given `predicate` function. The first
- * Observable in that array emits source values for which the predicate argument
- * returns true. The second Observable emits source values for which the
- * predicate returns false. The first behaves like {@link filter} and the second
- * behaves like {@link filter} with the predicate negated.
- *
- * ## Example
- * Partition click events into those on DIV elements and those elsewhere
- * ```ts
- * import { fromEvent } from 'rxjs';
- * import { partition } from 'rxjs/operators';
- *
- * const clicks = fromEvent(document, 'click');
- * const parts = clicks.pipe(partition(ev => ev.target.tagName === 'DIV'));
- * const clicksOnDivs = parts[0];
- * const clicksElsewhere = parts[1];
- * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));
- * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));
- * ```
- *
- * @see {@link filter}
- *
- * @param {function(value: T, index: number): boolean} predicate A function that
- * evaluates each value emitted by the source Observable. If it returns `true`,
- * the value is emitted on the first Observable in the returned array, if
- * `false` the value is emitted on the second Observable in the array. The
- * `index` parameter is the number `i` for the i-th source emission that has
- * happened since the subscription, starting from the number `0`.
- * @param {any} [thisArg] An optional argument to determine the value of `this`
- * in the `predicate` function.
- * @return {[Observable<T>, Observable<T>]} An array with two Observables: one
- * with values that passed the predicate, and another with values that did not
- * pass the predicate.
- * @method partition
- * @owner Observable
- * @deprecated use `partition` static creation function instead
- */
-export function partition<T>(predicate: (value: T, index: number) => boolean,
-                             thisArg?: any): UnaryFunction<Observable<T>, [Observable<T>, Observable<T>]> {
-  return (source: Observable<T>) => [
-    filter(predicate, thisArg)(source),
-    filter(not(predicate, thisArg) as any)(source)
-  ] as [Observable<T>, Observable<T>];
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/pluck.ts

@@ -1,70 +0,0 @@
-import { Observable } from '../Observable';
-import { map } from './map';
-import { OperatorFunction } from '../types';
-
-/* tslint:disable:max-line-length */
-export function pluck<T, K1 extends keyof T>(k1: K1): OperatorFunction<T, T[K1]>;
-export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1]>(k1: K1, k2: K2): OperatorFunction<T, T[K1][K2]>;
-export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(k1: K1, k2: K2, k3: K3): OperatorFunction<T, T[K1][K2][K3]>;
-export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(k1: K1, k2: K2, k3: K3, k4: K4): OperatorFunction<T, T[K1][K2][K3][K4]>;
-export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): OperatorFunction<T, T[K1][K2][K3][K4][K5]>;
-export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4], K6 extends keyof T[K1][K2][K3][K4][K5]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): OperatorFunction<T, T[K1][K2][K3][K4][K5][K6]>;
-export function pluck<T, R>(...properties: string[]): OperatorFunction<T, R>;
-/* tslint:enable:max-line-length */
-
-/**
- * Maps each source value (an object) to its specified nested property.
- *
- * <span class="informal">Like {@link map}, but meant only for picking one of
- * the nested properties of every emitted object.</span>
- *
- * ![](pluck.png)
- *
- * Given a list of strings describing a path to an object property, retrieves
- * the value of a specified nested property from all values in the source
- * Observable. If a property can't be resolved, it will return `undefined` for
- * that value.
- *
- * ## Example
- * Map every click to the tagName of the clicked target element
- * ```ts
- * import { fromEvent } from 'rxjs';
- * import { pluck } from 'rxjs/operators';
- *
- * const clicks = fromEvent(document, 'click');
- * const tagNames = clicks.pipe(pluck('target', 'tagName'));
- * tagNames.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link map}
- *
- * @param {...string} properties The nested properties to pluck from each source
- * value (an object).
- * @return {Observable} A new Observable of property values from the source values.
- * @method pluck
- * @owner Observable
- */
-export function pluck<T, R>(...properties: string[]): OperatorFunction<T, R> {
-  const length = properties.length;
-  if (length === 0) {
-    throw new Error('list of properties cannot be empty.');
-  }
-  return (source: Observable<T>) => map(plucker(properties, length))(source as any);
-}
-
-function plucker(props: string[], length: number): (x: string) => any {
-  const mapper = (x: string) => {
-    let currentProp = x;
-    for (let i = 0; i < length; i++) {
-      const p = currentProp != null ? currentProp[props[i]] : undefined;
-      if (p !== void 0) {
-        currentProp = p;
-      } else {
-        return undefined;
-      }
-    }
-    return currentProp;
-  };
-
-  return mapper;
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/publish.ts

@@ -1,67 +0,0 @@
-import { Observable } from '../Observable';
-import { Subject } from '../Subject';
-import { multicast } from './multicast';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { MonoTypeOperatorFunction, OperatorFunction, UnaryFunction, ObservableInput, ObservedValueOf } from '../types';
-
-/* tslint:disable:max-line-length */
-export function publish<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
-export function publish<T, O extends ObservableInput<any>>(selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;
-export function publish<T>(selector: MonoTypeOperatorFunction<T>): MonoTypeOperatorFunction<T>;
-/* tslint:enable:max-line-length */
-
-/**
- * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called
- * before it begins emitting items to those Observers that have subscribed to it.
- *
- * <span class="informal">Makes a cold Observable hot</span>
- *
- * ![](publish.png)
- *
- * ## Examples
- * Make source$ hot by applying publish operator, then merge each inner observable into a single one
- * and subscribe.
- * ```ts
- * import { of, zip, interval, merge } from "rxjs";
- * import { map, publish, tap } from "rxjs/operators";
- *
- * const source$ = zip(interval(2000), of(1, 2, 3, 4, 5, 6, 7, 8, 9)).pipe(
- *   map(values => values[1])
- * );
- *
- * source$
- *   .pipe(
- *     publish(multicasted$ =>
- *       merge(
- *         multicasted$.pipe(tap(x => console.log('Stream 1:', x))),
- *         multicasted$.pipe(tap(x => console.log('Stream 2:', x))),
- *         multicasted$.pipe(tap(x => console.log('Stream 3:', x))),
- *       )
- *     )
- *   )
- *   .subscribe();
- *
- * // Results every two seconds
- * // Stream 1: 1
- * // Stream 2: 1
- * // Stream 3: 1
- * // ...
- * // Stream 1: 9
- * // Stream 2: 9
- * // Stream 3: 9
- * ```
- *
- * @param {Function} [selector] - Optional selector function which can use the multicasted source sequence as many times
- * as needed, without causing multiple subscriptions to the source sequence.
- * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
- * @return A ConnectableObservable that upon connection causes the source Observable to emit items to its Observers.
- * @method publish
- * @owner Observable
- *
- *
- */
-export function publish<T, R>(selector?: OperatorFunction<T, R>): MonoTypeOperatorFunction<T> | OperatorFunction<T, R> {
-  return selector ?
-    multicast(() => new Subject<T>(), selector) :
-    multicast(new Subject<T>());
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/publishBehavior.ts

@@ -1,15 +0,0 @@
-import { Observable } from '../Observable';
-import { BehaviorSubject } from '../BehaviorSubject';
-import { multicast } from './multicast';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { UnaryFunction } from '../types';
-
-/**
- * @param value
- * @return {ConnectableObservable<T>}
- * @method publishBehavior
- * @owner Observable
- */
-export function publishBehavior<T>(value: T):  UnaryFunction<Observable<T>, ConnectableObservable<T>> {
-  return (source: Observable<T>) => multicast(new BehaviorSubject<T>(value))(source) as ConnectableObservable<T>;
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/publishLast.ts

@@ -1,67 +0,0 @@
-import { Observable } from '../Observable';
-import { AsyncSubject } from '../AsyncSubject';
-import { multicast } from './multicast';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { UnaryFunction } from '../types';
-
-/**
- * Returns a connectable observable sequence that shares a single subscription to the
- * underlying sequence containing only the last notification.
- *
- * ![](publishLast.png)
- *
- * Similar to {@link publish}, but it waits until the source observable completes and stores
- * the last emitted value.
- * Similarly to {@link publishReplay} and {@link publishBehavior}, this keeps storing the last
- * value even if it has no more subscribers. If subsequent subscriptions happen, they will
- * immediately get that last stored value and complete.
- *
- * ## Example
- *
- * ```ts
- * import { interval } from 'rxjs';
- * import { publishLast, tap, take } from 'rxjs/operators';
- *
- * const connectable =
- *   interval(1000)
- *     .pipe(
- *       tap(x => console.log("side effect", x)),
- *       take(3),
- *       publishLast());
- *
- * connectable.subscribe(
- *   x => console.log(  "Sub. A", x),
- *   err => console.log("Sub. A Error", err),
- *   () => console.log( "Sub. A Complete"));
- *
- * connectable.subscribe(
- *   x => console.log(  "Sub. B", x),
- *   err => console.log("Sub. B Error", err),
- *   () => console.log( "Sub. B Complete"));
- *
- * connectable.connect();
- *
- * // Results:
- * //    "side effect 0"
- * //    "side effect 1"
- * //    "side effect 2"
- * //    "Sub. A 2"
- * //    "Sub. B 2"
- * //    "Sub. A Complete"
- * //    "Sub. B Complete"
- * ```
- *
- * @see {@link ConnectableObservable}
- * @see {@link publish}
- * @see {@link publishReplay}
- * @see {@link publishBehavior}
- *
- * @return {ConnectableObservable} An observable sequence that contains the elements of a
- * sequence produced by multicasting the source sequence.
- * @method publishLast
- * @owner Observable
- */
-
-export function publishLast<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>> {
-  return (source: Observable<T>) => multicast(new AsyncSubject<T>())(source);
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/publishReplay.ts

@@ -1,25 +0,0 @@
-import { Observable } from '../Observable';
-import { ReplaySubject } from '../ReplaySubject';
-import { multicast } from './multicast';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { UnaryFunction, MonoTypeOperatorFunction, OperatorFunction, SchedulerLike, ObservableInput, ObservedValueOf } from '../types';
-
-/* tslint:disable:max-line-length */
-export function publishReplay<T>(bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-export function publishReplay<T, O extends ObservableInput<any>>(bufferSize?: number, windowTime?: number, selector?: (shared: Observable<T>) => O, scheduler?: SchedulerLike): OperatorFunction<T, ObservedValueOf<O>>;
-/* tslint:enable:max-line-length */
-
-export function publishReplay<T, R>(bufferSize?: number,
-                                    windowTime?: number,
-                                    selectorOrScheduler?: SchedulerLike | OperatorFunction<T, R>,
-                                    scheduler?: SchedulerLike): UnaryFunction<Observable<T>, ConnectableObservable<R>> {
-
-  if (selectorOrScheduler && typeof selectorOrScheduler !== 'function') {
-    scheduler = selectorOrScheduler;
-  }
-
-  const selector = typeof selectorOrScheduler === 'function' ? selectorOrScheduler : undefined;
-  const subject = new ReplaySubject<T>(bufferSize, windowTime, scheduler);
-
-  return (source: Observable<T>) => multicast(() => subject, selector)(source) as ConnectableObservable<R>;
-}

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

@@ -1,36 +0,0 @@
-import { Observable } from '../Observable';
-import { isArray } from '../util/isArray';
-import { MonoTypeOperatorFunction, OperatorFunction } from '../types';
-import { race as raceStatic } from '../observable/race';
-
-/* tslint:disable:max-line-length */
-/** @deprecated Deprecated in favor of static race. */
-export function race<T>(observables: Array<Observable<T>>): MonoTypeOperatorFunction<T>;
-/** @deprecated Deprecated in favor of static race. */
-export function race<T, R>(observables: Array<Observable<T>>): OperatorFunction<T, R>;
-/** @deprecated Deprecated in favor of static race. */
-export function race<T>(...observables: Array<Observable<T> | Array<Observable<T>>>): MonoTypeOperatorFunction<T>;
-/** @deprecated Deprecated in favor of static race. */
-export function race<T, R>(...observables: Array<Observable<any> | Array<Observable<any>>>): OperatorFunction<T, R>;
-/* tslint:enable:max-line-length */
-
-/**
- * Returns an Observable that mirrors the first source Observable to emit a next,
- * error or complete notification from the combination of this Observable and supplied Observables.
- * @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.
- * @method race
- * @owner Observable
- * @deprecated Deprecated in favor of static {@link race}.
- */
-export function race<T>(...observables: (Observable<T> | Observable<T>[])[]): MonoTypeOperatorFunction<T> {
-  return function raceOperatorFunction(source: Observable<T>) {
-    // if the only argument is an array, it was most likely called with
-    // `pair([obs1, obs2, ...])`
-    if (observables.length === 1 && isArray(observables[0])) {
-      observables = observables[0] as Observable<T>[];
-    }
-
-    return source.lift.call(raceStatic(source, ...(observables as Observable<T>[])));
-  };
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/reduce.ts

@@ -1,82 +0,0 @@
-import { Observable } from '../Observable';
-import { scan } from './scan';
-import { takeLast } from './takeLast';
-import { defaultIfEmpty } from './defaultIfEmpty';
-import { OperatorFunction, MonoTypeOperatorFunction } from '../types';
-import { pipe } from '../util/pipe';
-
-/* tslint:disable:max-line-length */
-export function reduce<T, R>(accumulator: (acc: R, value: T, index: number) => R, seed: R): OperatorFunction<T, R>;
-export function reduce<T>(accumulator: (acc: T, value: T, index: number) => T, seed?: T): MonoTypeOperatorFunction<T>;
-export function reduce<T, R>(accumulator: (acc: R, value: T, index: number) => R): OperatorFunction<T, R>;
-/* tslint:enable:max-line-length */
-
-/**
- * Applies an accumulator function over the source Observable, and returns the
- * accumulated result when the source completes, given an optional seed value.
- *
- * <span class="informal">Combines together all values emitted on the source,
- * using an accumulator function that knows how to join a new source value into
- * the accumulation from the past.</span>
- *
- * ![](reduce.png)
- *
- * Like
- * [Array.prototype.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce),
- * `reduce` applies an `accumulator` function against an accumulation and each
- * value of the source Observable (from the past) to reduce it to a single
- * value, emitted on the output Observable. Note that `reduce` will only emit
- * one value, only when the source Observable completes. It is equivalent to
- * applying operator {@link scan} followed by operator {@link last}.
- *
- * Returns an Observable that applies a specified `accumulator` function to each
- * item emitted by the source Observable. If a `seed` value is specified, then
- * that value will be used as the initial value for the accumulator. If no seed
- * value is specified, the first item of the source is used as the seed.
- *
- * ## Example
- * Count the number of click events that happened in 5 seconds
- * ```ts
- * import { fromEvent, interval } from 'rxjs';
- * import { reduce, takeUntil, mapTo } from 'rxjs/operators';
- *
- * const clicksInFiveSeconds = fromEvent(document, 'click').pipe(
- *   takeUntil(interval(5000)),
- * );
- * const ones = clicksInFiveSeconds.pipe(mapTo(1));
- * const seed = 0;
- * const count = ones.pipe(reduce((acc, one) => acc + one, seed));
- * count.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link count}
- * @see {@link expand}
- * @see {@link mergeScan}
- * @see {@link scan}
- *
- * @param {function(acc: R, value: T, index: number): R} accumulator The accumulator function
- * called on each source value.
- * @param {R} [seed] The initial accumulation value.
- * @return {Observable<R>} An Observable that emits a single value that is the
- * result of accumulating the values emitted by the source Observable.
- * @method reduce
- * @owner Observable
- */
-export function reduce<T, R>(accumulator: (acc: T | R, value: T, index?: number) => T | R, seed?: T | R): OperatorFunction<T, T | R> {
-  // providing a seed of `undefined` *should* be valid and trigger
-  // hasSeed! so don't use `seed !== undefined` checks!
-  // For this reason, we have to check it here at the original call site
-  // otherwise inside Operator/Subscriber we won't know if `undefined`
-  // means they didn't provide anything or if they literally provided `undefined`
-  if (arguments.length >= 2) {
-    return function reduceOperatorFunctionWithSeed(source: Observable<T>): Observable<T | R> {
-      return pipe(scan(accumulator, seed), takeLast(1), defaultIfEmpty(seed))(source);
-    };
-  }
-  return function reduceOperatorFunction(source: Observable<T>): Observable<T | R> {
-    return pipe(
-      scan<T, T | R>((acc, value, index) => accumulator(acc, value, index + 1)),
-      takeLast(1),
-    )(source);
-  };
-}

package/packages/config-stylelint/node_modules/rxjs/src/internal/operators/refCount.ts

@@ -1,148 +0,0 @@
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { Subscription } from '../Subscription';
-import { MonoTypeOperatorFunction, TeardownLogic } from '../types';
-import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { Observable } from '../Observable';
-
-/**
- * Make a {@link ConnectableObservable} behave like a ordinary observable and automates the way
- * you can connect to it.
- *
- * Internally it counts the subscriptions to the observable and subscribes (only once) to the source if
- * the number of subscriptions is larger than 0. If the number of subscriptions is smaller than 1, it
- * unsubscribes from the source. This way you can make sure that everything before the *published*
- * refCount has only a single subscription independently of the number of subscribers to the target
- * observable.
- *
- * Note that using the {@link share} operator is exactly the same as using the *publish* operator
- * (making the observable hot) and the *refCount* operator in a sequence.
- *
- * ![](refCount.png)
- *
- * ## Example
- *
- * In the following example there are two intervals turned into connectable observables
- * by using the *publish* operator. The first one uses the *refCount* operator, the
- * second one does not use it. You will notice that a connectable observable does nothing
- * until you call its connect function.
- *
- * ```ts
- * import { interval } from 'rxjs';
- * import { tap, publish, refCount } from 'rxjs/operators';
- *
- * // Turn the interval observable into a ConnectableObservable (hot)
- * const refCountInterval = interval(400).pipe(
- *   tap((num) => console.log(`refCount ${num}`)),
- *   publish(),
- *   refCount()
- * );
- *
- * const publishedInterval = interval(400).pipe(
- *   tap((num) => console.log(`publish ${num}`)),
- *   publish()
- * );
- *
- * refCountInterval.subscribe();
- * refCountInterval.subscribe();
- * // 'refCount 0' -----> 'refCount 1' -----> etc
- * // All subscriptions will receive the same value and the tap (and
- * // every other operator) before the publish operator will be executed
- * // only once per event independently of the number of subscriptions.
- *
- * publishedInterval.subscribe();
- * // Nothing happens until you call .connect() on the observable.
- * ```
- *
- * @see {@link ConnectableObservable}
- * @see {@link share}
- * @see {@link publish}
- */
-export function refCount<T>(): MonoTypeOperatorFunction<T> {
-  return function refCountOperatorFunction(source: ConnectableObservable<T>): Observable<T> {
-    return source.lift(new RefCountOperator(source));
-  } as MonoTypeOperatorFunction<T>;
-}
-
-class RefCountOperator<T> implements Operator<T, T> {
-  constructor(private connectable: ConnectableObservable<T>) {
-  }
-  call(subscriber: Subscriber<T>, source: any): TeardownLogic {
-
-    const { connectable } = this;
-    (<any> connectable)._refCount++;
-
-    const refCounter = new RefCountSubscriber(subscriber, connectable);
-    const subscription = source.subscribe(refCounter);
-
-    if (!refCounter.closed) {
-      (<any> refCounter).connection = connectable.connect();
-    }
-
-    return subscription;
-  }
-}
-
-class RefCountSubscriber<T> extends Subscriber<T> {
-
-  private connection: Subscription;
-
-  constructor(destination: Subscriber<T>,
-              private connectable: ConnectableObservable<T>) {
-    super(destination);
-  }
-
-  protected _unsubscribe() {
-
-    const { connectable } = this;
-    if (!connectable) {
-      this.connection = null;
-      return;
-    }
-
-    this.connectable = null;
-    const refCount = (<any> connectable)._refCount;
-    if (refCount <= 0) {
-      this.connection = null;
-      return;
-    }
-
-    (<any> connectable)._refCount = refCount - 1;
-    if (refCount > 1) {
-      this.connection = null;
-      return;
-    }
-
-    ///
-    // Compare the local RefCountSubscriber's connection Subscription to the
-    // connection Subscription on the shared ConnectableObservable. In cases
-    // where the ConnectableObservable source synchronously emits values, and
-    // the RefCountSubscriber's downstream Observers synchronously unsubscribe,
-    // execution continues to here before the RefCountOperator has a chance to
-    // supply the RefCountSubscriber with the shared connection Subscription.
-    // For example:
-    // ```
-    // range(0, 10).pipe(
-    //   publish(),
-    //   refCount(),
-    //   take(5),
-    // )
-    // .subscribe();
-    // ```
-    // In order to account for this case, RefCountSubscriber should only dispose
-    // the ConnectableObservable's shared connection Subscription if the
-    // connection Subscription exists, *and* either:
-    //   a. RefCountSubscriber doesn't have a reference to the shared connection
-    //      Subscription yet, or,
-    //   b. RefCountSubscriber's connection Subscription reference is identical
-    //      to the shared connection Subscription
-    ///
-    const { connection } = this;
-    const sharedConnection = (<any> connectable)._connection;
-    this.connection = null;
-
-    if (sharedConnection && (!connection || sharedConnection === connection)) {
-      sharedConnection.unsubscribe();
-    }
-  }
-}