@alexlit/lint-kit 186.2.2 → 186.3.1

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

@@ -1,302 +0,0 @@
-import { isFunction } from './util/isFunction';
-import { empty as emptyObserver } from './Observer';
-import { Observer, PartialObserver, TeardownLogic } from './types';
-import { Subscription } from './Subscription';
-import { rxSubscriber as rxSubscriberSymbol } from '../internal/symbol/rxSubscriber';
-import { config } from './config';
-import { hostReportError } from './util/hostReportError';
-
-/**
- * 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.
- *
- * @class Subscriber<T>
- */
-export class Subscriber<T> extends Subscription implements Observer<T> {
-
-  [rxSubscriberSymbol]() { return this; }
-
-  /**
-   * A static factory for a Subscriber, given a (potentially partial) definition
-   * of an Observer.
-   * @param {function(x: ?T): void} [next] The `next` callback of an Observer.
-   * @param {function(e: ?any): void} [error] The `error` callback of an
-   * Observer.
-   * @param {function(): void} [complete] The `complete` callback of an
-   * Observer.
-   * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)
-   * Observer represented by the given arguments.
-   * @nocollapse
-   */
-  static create<T>(next?: (x?: T) => void,
-                   error?: (e?: any) => void,
-                   complete?: () => void): Subscriber<T> {
-    const subscriber = new Subscriber(next, error, complete);
-    subscriber.syncErrorThrowable = false;
-    return subscriber;
-  }
-
-  /** @internal */ syncErrorValue: any = null;
-  /** @internal */ syncErrorThrown: boolean = false;
-  /** @internal */ syncErrorThrowable: boolean = false;
-
-  protected isStopped: boolean = false;
-  protected destination: PartialObserver<any> | Subscriber<any>; // this `any` is the escape hatch to erase extra type param (e.g. R)
-
-  /**
-   * @param {Observer|function(value: T): void} [destinationOrNext] A partially
-   * defined Observer or a `next` callback function.
-   * @param {function(e: ?any): void} [error] The `error` callback of an
-   * Observer.
-   * @param {function(): void} [complete] The `complete` callback of an
-   * Observer.
-   */
-  constructor(destinationOrNext?: PartialObserver<any> | ((value: T) => void),
-              error?: (e?: any) => void,
-              complete?: () => void) {
-    super();
-
-    switch (arguments.length) {
-      case 0:
-        this.destination = emptyObserver;
-        break;
-      case 1:
-        if (!destinationOrNext) {
-          this.destination = emptyObserver;
-          break;
-        }
-        if (typeof destinationOrNext === 'object') {
-          if (destinationOrNext instanceof Subscriber) {
-            this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;
-            this.destination = destinationOrNext;
-            destinationOrNext.add(this);
-          } else {
-            this.syncErrorThrowable = true;
-            this.destination = new SafeSubscriber<T>(this, <PartialObserver<any>> destinationOrNext);
-          }
-          break;
-        }
-      default:
-        this.syncErrorThrowable = true;
-        this.destination = new SafeSubscriber<T>(this, <((value: T) => void)> destinationOrNext, error, complete);
-        break;
-    }
-  }
-
-  /**
-   * 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 {T} [value] The `next` value.
-   * @return {void}
-   */
-  next(value?: T): void {
-    if (!this.isStopped) {
-      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 {any} [err] The `error` exception.
-   * @return {void}
-   */
-  error(err?: any): void {
-    if (!this.isStopped) {
-      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.
-   * @return {void}
-   */
-  complete(): void {
-    if (!this.isStopped) {
-      this.isStopped = true;
-      this._complete();
-    }
-  }
-
-  unsubscribe(): void {
-    if (this.closed) {
-      return;
-    }
-    this.isStopped = true;
-    super.unsubscribe();
-  }
-
-  protected _next(value: T): void {
-    this.destination.next(value);
-  }
-
-  protected _error(err: any): void {
-    this.destination.error(err);
-    this.unsubscribe();
-  }
-
-  protected _complete(): void {
-    this.destination.complete();
-    this.unsubscribe();
-  }
-
-  /** @deprecated This is an internal implementation detail, do not use. */
-  _unsubscribeAndRecycle(): Subscriber<T> {
-    const {  _parentOrParents } = this;
-    this._parentOrParents = null;
-    this.unsubscribe();
-    this.closed = false;
-    this.isStopped = false;
-    this._parentOrParents = _parentOrParents;
-    return this;
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-export class SafeSubscriber<T> extends Subscriber<T> {
-
-  private _context: any;
-
-  constructor(private _parentSubscriber: Subscriber<T>,
-              observerOrNext?: PartialObserver<T> | ((value: T) => void),
-              error?: (e?: any) => void,
-              complete?: () => void) {
-    super();
-
-    let next: ((value: T) => void);
-    let context: any = this;
-
-    if (isFunction(observerOrNext)) {
-      next = (<((value: T) => void)> observerOrNext);
-    } else if (observerOrNext) {
-      next = (<PartialObserver<T>> observerOrNext).next;
-      error = (<PartialObserver<T>> observerOrNext).error;
-      complete = (<PartialObserver<T>> observerOrNext).complete;
-      if (observerOrNext !== emptyObserver) {
-        context = Object.create(observerOrNext);
-        if (isFunction(context.unsubscribe)) {
-          this.add(<() => void> context.unsubscribe.bind(context));
-        }
-        context.unsubscribe = this.unsubscribe.bind(this);
-      }
-    }
-
-    this._context = context;
-    this._next = next;
-    this._error = error;
-    this._complete = complete;
-  }
-
-  next(value?: T): void {
-    if (!this.isStopped && this._next) {
-      const { _parentSubscriber } = this;
-      if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-        this.__tryOrUnsub(this._next, value);
-      } else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {
-        this.unsubscribe();
-      }
-    }
-  }
-
-  error(err?: any): void {
-    if (!this.isStopped) {
-      const { _parentSubscriber } = this;
-      const { useDeprecatedSynchronousErrorHandling } = config;
-      if (this._error) {
-        if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-          this.__tryOrUnsub(this._error, err);
-          this.unsubscribe();
-        } else {
-          this.__tryOrSetError(_parentSubscriber, this._error, err);
-          this.unsubscribe();
-        }
-      } else if (!_parentSubscriber.syncErrorThrowable) {
-        this.unsubscribe();
-        if (useDeprecatedSynchronousErrorHandling) {
-          throw err;
-        }
-        hostReportError(err);
-      } else {
-        if (useDeprecatedSynchronousErrorHandling) {
-          _parentSubscriber.syncErrorValue = err;
-          _parentSubscriber.syncErrorThrown = true;
-        } else {
-          hostReportError(err);
-        }
-        this.unsubscribe();
-      }
-    }
-  }
-
-  complete(): void {
-    if (!this.isStopped) {
-      const { _parentSubscriber } = this;
-      if (this._complete) {
-        const wrappedComplete = () => this._complete.call(this._context);
-
-        if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-          this.__tryOrUnsub(wrappedComplete);
-          this.unsubscribe();
-        } else {
-          this.__tryOrSetError(_parentSubscriber, wrappedComplete);
-          this.unsubscribe();
-        }
-      } else {
-        this.unsubscribe();
-      }
-    }
-  }
-
-  private __tryOrUnsub(fn: Function, value?: any): void {
-    try {
-      fn.call(this._context, value);
-    } catch (err) {
-      this.unsubscribe();
-      if (config.useDeprecatedSynchronousErrorHandling) {
-        throw err;
-      } else {
-        hostReportError(err);
-      }
-    }
-  }
-
-  private __tryOrSetError(parent: Subscriber<T>, fn: Function, value?: any): boolean {
-    if (!config.useDeprecatedSynchronousErrorHandling) {
-      throw new Error('bad call');
-    }
-    try {
-      fn.call(this._context, value);
-    } catch (err) {
-      if (config.useDeprecatedSynchronousErrorHandling) {
-        parent.syncErrorValue = err;
-        parent.syncErrorThrown = true;
-        return true;
-      } else {
-        hostReportError(err);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /** @internal This is an internal implementation detail, do not use. */
-  _unsubscribe(): void {
-    const { _parentSubscriber } = this;
-    this._context = null;
-    this._parentSubscriber = null;
-    _parentSubscriber.unsubscribe();
-  }
-}

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

@@ -1,224 +0,0 @@
-import { isArray } from './util/isArray';
-import { isObject } from './util/isObject';
-import { isFunction } from './util/isFunction';
-import { UnsubscriptionError } from './util/UnsubscriptionError';
-import { SubscriptionLike, TeardownLogic } from './types';
-
-/**
- * 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.
- *
- * @class Subscription
- */
-export class Subscription implements SubscriptionLike {
-  /** @nocollapse */
-  public static EMPTY: Subscription = (function(empty: any) {
-    empty.closed = true;
-    return empty;
-  }(new Subscription()));
-
-  /**
-   * A flag to indicate whether this Subscription has already been unsubscribed.
-   * @type {boolean}
-   */
-  public closed: boolean = false;
-
-  /** @internal */
-  protected _parentOrParents: Subscription | Subscription[] = null;
-  /** @internal */
-  private _subscriptions: SubscriptionLike[] = null;
-
-  /**
-   * @param {function(): void} [unsubscribe] A function describing how to
-   * perform the disposal of resources when the `unsubscribe` method is called.
-   */
-  constructor(unsubscribe?: () => void) {
-    if (unsubscribe) {
-      (this as any)._ctorUnsubscribe = true;
-      (this as any)._unsubscribe = unsubscribe;
-    }
-  }
-
-  /**
-   * 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.
-   * @return {void}
-   */
-  unsubscribe(): void {
-    let errors: any[];
-
-    if (this.closed) {
-      return;
-    }
-
-    let { _parentOrParents, _ctorUnsubscribe, _unsubscribe, _subscriptions } = (this as any);
-
-    this.closed = true;
-    this._parentOrParents = null;
-    // null out _subscriptions first so any child subscriptions that attempt
-    // to remove themselves from this subscription will noop
-    this._subscriptions = null;
-
-    if (_parentOrParents instanceof Subscription) {
-      _parentOrParents.remove(this);
-    } else if (_parentOrParents !== null) {
-      for (let index = 0; index < _parentOrParents.length; ++index) {
-        const parent = _parentOrParents[index];
-        parent.remove(this);
-      }
-    }
-
-    if (isFunction(_unsubscribe)) {
-      // It's only possible to null _unsubscribe - to release the reference to
-      // any teardown function passed in the constructor - if the property was
-      // actually assigned in the constructor, as there are some classes that
-      // are derived from Subscriber (which derives from Subscription) that
-      // implement an _unsubscribe method as a mechanism for obtaining
-      // unsubscription notifications and some of those subscribers are
-      // recycled. Also, in some of those subscribers, _unsubscribe switches
-      // from a prototype method to an instance property - see notifyNext in
-      // RetryWhenSubscriber.
-      if (_ctorUnsubscribe) {
-        (this as any)._unsubscribe = undefined;
-      }
-      try {
-        _unsubscribe.call(this);
-      } catch (e) {
-        errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];
-      }
-    }
-
-    if (isArray(_subscriptions)) {
-      let index = -1;
-      let len = _subscriptions.length;
-
-      while (++index < len) {
-        const sub = _subscriptions[index];
-        if (isObject(sub)) {
-          try {
-            sub.unsubscribe();
-          } catch (e) {
-            errors = errors || [];
-            if (e instanceof UnsubscriptionError) {
-              errors = errors.concat(flattenUnsubscriptionErrors(e.errors));
-            } else {
-              errors.push(e);
-            }
-          }
-        }
-      }
-    }
-
-    if (errors) {
-      throw new UnsubscriptionError(errors);
-    }
-  }
-
-  /**
-   * Adds a tear down to be called during the unsubscribe() of this
-   * Subscription. Can also be used to add a child subscription.
-   *
-   * If the tear down being added is a subscription that is already
-   * unsubscribed, is the same reference `add` is being called on, or is
-   * `Subscription.EMPTY`, it will not be added.
-   *
-   * If this subscription is already in an `closed` state, the passed
-   * tear down logic will be executed immediately.
-   *
-   * When a parent subscription is unsubscribed, any child subscriptions that were added to it are also unsubscribed.
-   *
-   * @param {TeardownLogic} teardown The additional logic to execute on
-   * teardown.
-   * @return {Subscription} Returns the Subscription used or created to be
-   * added to the inner subscriptions list. This Subscription can be used with
-   * `remove()` to remove the passed teardown logic from the inner subscriptions
-   * list.
-   */
-  add(teardown: TeardownLogic): Subscription {
-    let subscription = (<Subscription>teardown);
-
-    if (!teardown) {
-      return Subscription.EMPTY;
-    }
-
-    switch (typeof teardown) {
-      case 'function':
-        subscription = new Subscription(<(() => void)>teardown);
-      case 'object':
-        if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {
-          // This also covers the case where `subscription` is `Subscription.EMPTY`, which is always in `closed` state.
-          return subscription;
-        } else if (this.closed) {
-          subscription.unsubscribe();
-          return subscription;
-        } else if (!(subscription instanceof Subscription)) {
-          const tmp = subscription;
-          subscription = new Subscription();
-          subscription._subscriptions = [tmp];
-        }
-        break;
-      default: {
-        throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');
-      }
-    }
-
-    // Add `this` as parent of `subscription` if that's not already the case.
-    let { _parentOrParents } = subscription;
-    if (_parentOrParents === null) {
-      // If we don't have a parent, then set `subscription._parents` to
-      // the `this`, which is the common case that we optimize for.
-      subscription._parentOrParents = this;
-    } else if (_parentOrParents instanceof Subscription) {
-      if (_parentOrParents === this) {
-        // The `subscription` already has `this` as a parent.
-        return subscription;
-      }
-      // If there's already one parent, but not multiple, allocate an
-      // Array to store the rest of the parent Subscriptions.
-      subscription._parentOrParents = [_parentOrParents, this];
-    } else if (_parentOrParents.indexOf(this) === -1) {
-      // Only add `this` to the _parentOrParents list if it's not already there.
-      _parentOrParents.push(this);
-    } else {
-      // The `subscription` already has `this` as a parent.
-      return subscription;
-    }
-
-    // Optimize for the common case when adding the first subscription.
-    const subscriptions = this._subscriptions;
-    if (subscriptions === null) {
-      this._subscriptions = [subscription];
-    } else {
-      subscriptions.push(subscription);
-    }
-
-    return subscription;
-  }
-
-  /**
-   * Removes a Subscription from the internal list of subscriptions that will
-   * unsubscribe during the unsubscribe process of this Subscription.
-   * @param {Subscription} subscription The subscription to remove.
-   * @return {void}
-   */
-  remove(subscription: Subscription): void {
-    const subscriptions = this._subscriptions;
-    if (subscriptions) {
-      const subscriptionIndex = subscriptions.indexOf(subscription);
-      if (subscriptionIndex !== -1) {
-        subscriptions.splice(subscriptionIndex, 1);
-      }
-    }
-  }
-}
-
-function flattenUnsubscriptionErrors(errors: any[]) {
- return errors.reduce((errs, err) => errs.concat((err instanceof UnsubscriptionError) ? err.errors : err), []);
-}

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

@@ -1,35 +0,0 @@
-let _enable_super_gross_mode_that_will_cause_bad_things = false;
-
-/**
- * The global configuration object for RxJS, used to configure things
- * like what Promise contructor should used to create Promises
- */
-export const config = {
-  /**
-   * The promise constructor used by default for methods such as
-   * {@link toPromise} and {@link forEach}
-   */
-  Promise: undefined as PromiseConstructorLike,
-
-  /**
-   * If true, turns on synchronous error rethrowing, which is a deprecated behavior
-   * in v6 and higher. This behavior enables bad patterns like wrapping a subscribe
-   * call in a try/catch block. It also enables producer interference, a nasty bug
-   * where a multicast can be broken for all observers by a downstream consumer with
-   * an unhandled error. DO NOT USE THIS FLAG UNLESS IT'S NEEDED TO BY TIME
-   * FOR MIGRATION REASONS.
-   */
-  set useDeprecatedSynchronousErrorHandling(value: boolean) {
-    if (value) {
-      const error = new Error();
-      console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n' + error.stack);
-    } else if (_enable_super_gross_mode_that_will_cause_bad_things) {
-      console.log('RxJS: Back to a better error behavior. Thank you. <3');
-    }
-    _enable_super_gross_mode_that_will_cause_bad_things = value;
-  },
-
-  get useDeprecatedSynchronousErrorHandling() {
-    return _enable_super_gross_mode_that_will_cause_bad_things;
-  },
-};

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

@@ -1,120 +0,0 @@
-/** @prettier */
-import { Subscription } from './Subscription';
-import { Subscriber } from './Subscriber';
-import { Observable } from './Observable';
-import { subscribeTo } from './util/subscribeTo';
-
-interface SimpleOuterSubscriberLike<T> {
-  /**
-   * A handler for inner next notifications from the inner subscription
-   * @param innerValue the value nexted by the inner producer
-   */
-  notifyNext(innerValue: T): void;
-  /**
-   * A handler for inner error notifications from the inner subscription
-   * @param err the error from the inner producer
-   */
-  notifyError(err: any): void;
-  /**
-   * A handler for inner complete notifications from the inner subscription.
-   */
-  notifyComplete(): void;
-}
-
-export class SimpleInnerSubscriber<T> extends Subscriber<T> {
-  constructor(private parent: SimpleOuterSubscriberLike<any>) {
-    super();
-  }
-
-  protected _next(value: T): void {
-    this.parent.notifyNext(value);
-  }
-
-  protected _error(error: any): void {
-    this.parent.notifyError(error);
-    this.unsubscribe();
-  }
-
-  protected _complete(): void {
-    this.parent.notifyComplete();
-    this.unsubscribe();
-  }
-}
-
-export class ComplexInnerSubscriber<T, R> extends Subscriber<R> {
-  constructor(private parent: ComplexOuterSubscriber<T, R>, public outerValue: T, public outerIndex: number) {
-    super();
-  }
-
-  protected _next(value: R): void {
-    this.parent.notifyNext(this.outerValue, value, this.outerIndex, this);
-  }
-
-  protected _error(error: any): void {
-    this.parent.notifyError(error);
-    this.unsubscribe();
-  }
-
-  protected _complete(): void {
-    this.parent.notifyComplete(this);
-    this.unsubscribe();
-  }
-}
-
-export class SimpleOuterSubscriber<T, R> extends Subscriber<T> implements SimpleOuterSubscriberLike<R> {
-  notifyNext(innerValue: R): void {
-    this.destination.next(innerValue);
-  }
-
-  notifyError(err: any): void {
-    this.destination.error(err);
-  }
-
-  notifyComplete(): void {
-    this.destination.complete();
-  }
-}
-
-/**
- * DO NOT USE (formerly "OuterSubscriber")
- * TODO: We want to refactor this and remove it. It is retaining values it shouldn't for long
- * periods of time.
- */
-export class ComplexOuterSubscriber<T, R> extends Subscriber<T> {
-  /**
-   * @param _outerValue Used by: bufferToggle, delayWhen, windowToggle
-   * @param innerValue Used by: subclass default, combineLatest, race, bufferToggle, windowToggle, withLatestFrom
-   * @param _outerIndex Used by: combineLatest, race, withLatestFrom
-   * @param _innerSub Used by: delayWhen
-   */
-  notifyNext(_outerValue: T, innerValue: R, _outerIndex: number, _innerSub: ComplexInnerSubscriber<T, R>): void {
-    this.destination.next(innerValue);
-  }
-
-  notifyError(error: any): void {
-    this.destination.error(error);
-  }
-
-  /**
-   * @param _innerSub Used by: race, bufferToggle, delayWhen, windowToggle, windowWhen
-   */
-  notifyComplete(_innerSub: ComplexInnerSubscriber<T, R>): void {
-    this.destination.complete();
-  }
-}
-
-export function innerSubscribe(result: any, innerSubscriber: Subscriber<any>): Subscription | undefined {
-  if (innerSubscriber.closed) {
-    return undefined;
-  }
-  if (result instanceof Observable) {
-    return result.subscribe(innerSubscriber);
-  }
-  let subscription: Subscription;
-  try {
-    subscription = subscribeTo(result)(innerSubscriber) as Subscription;
-  } catch (error) {
-    innerSubscriber.error(error);
-  }
-  return subscription;
-}