@adminide-stack/core 7.0.3-alpha.10 → 7.0.3-alpha.25

package/lib/core/disposable.js

@@ -1,75 +1,76 @@
 import {Emitter}from'./event.js';/* tslint:disable */
 var Disposable;
 (function (Disposable) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function is(arg) {
-    return !!arg && typeof arg === 'object' && 'dispose' in arg && typeof arg['dispose'] === 'function';
-  }
-  Disposable.is = is;
-  function create(func) {
-    return {
-      dispose: func
-    };
-  }
-  Disposable.create = create;
-  Disposable.NULL = create(() => {});
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function is(arg) {
+        return !!arg && typeof arg === 'object' && 'dispose' in arg && typeof arg['dispose'] === 'function';
+    }
+    Disposable.is = is;
+    function create(func) {
+        return {
+            dispose: func
+        };
+    }
+    Disposable.create = create;
+    Disposable.NULL = create(() => { });
 })(Disposable || (Disposable = {}));
 class DisposableCollection {
-  disposables = [];
-  onDisposeEmitter = new Emitter();
-  constructor(...toDispose) {
-    toDispose.forEach(d => this.push(d));
-  }
-  /**
-   * This event is fired only once
-   * on first dispose of not empty collection.
-   */
-  get onDispose() {
-    return this.onDisposeEmitter.event;
-  }
-  checkDisposed() {
-    if (this.disposed && !this.disposingElements) {
-      this.onDisposeEmitter.fire(undefined);
-      this.onDisposeEmitter.dispose();
+    disposables = [];
+    onDisposeEmitter = new Emitter();
+    constructor(...toDispose) {
+        toDispose.forEach(d => this.push(d));
+    }
+    /**
+     * This event is fired only once
+     * on first dispose of not empty collection.
+     */
+    get onDispose() {
+        return this.onDisposeEmitter.event;
+    }
+    checkDisposed() {
+        if (this.disposed && !this.disposingElements) {
+            this.onDisposeEmitter.fire(undefined);
+            this.onDisposeEmitter.dispose();
+        }
+    }
+    get disposed() {
+        return this.disposables.length === 0;
+    }
+    disposingElements = false;
+    dispose() {
+        if (this.disposed || this.disposingElements) {
+            return;
+        }
+        this.disposingElements = true;
+        while (!this.disposed) {
+            try {
+                this.disposables.pop().dispose();
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        this.disposingElements = false;
+        this.checkDisposed();
     }
-  }
-  get disposed() {
-    return this.disposables.length === 0;
-  }
-  disposingElements = false;
-  dispose() {
-    if (this.disposed || this.disposingElements) {
-      return;
+    push(disposable) {
+        const disposables = this.disposables;
+        disposables.push(disposable);
+        const originalDispose = disposable.dispose.bind(disposable);
+        const toRemove = Disposable.create(() => {
+            const index = disposables.indexOf(disposable);
+            if (index !== -1) {
+                disposables.splice(index, 1);
+            }
+            this.checkDisposed();
+        });
+        disposable.dispose = () => {
+            toRemove.dispose();
+            originalDispose();
+        };
+        return toRemove;
     }
-    this.disposingElements = true;
-    while (!this.disposed) {
-      try {
-        this.disposables.pop().dispose();
-      } catch (e) {
-        console.error(e);
-      }
+    pushAll(disposables) {
+        return disposables.map(disposable => this.push(disposable));
     }
-    this.disposingElements = false;
-    this.checkDisposed();
-  }
-  push(disposable) {
-    const disposables = this.disposables;
-    disposables.push(disposable);
-    const originalDispose = disposable.dispose.bind(disposable);
-    const toRemove = Disposable.create(() => {
-      const index = disposables.indexOf(disposable);
-      if (index !== -1) {
-        disposables.splice(index, 1);
-      }
-      this.checkDisposed();
-    });
-    disposable.dispose = () => {
-      toRemove.dispose();
-      originalDispose();
-    };
-    return toRemove;
-  }
-  pushAll(disposables) {
-    return disposables.map(disposable => this.push(disposable));
-  }
 }export{Disposable,DisposableCollection};//# sourceMappingURL=disposable.js.map

package/lib/core/disposable.js.map

@@ -1 +1 @@
-{"version":3,"file":"disposable.js","sources":["../../src/core/disposable.ts"],"sourcesContent":[null],"names":[],"mappings":"iCAAA;AAUM,IAAW,WAWhB;AAXD,CAAA,UAAiB,UAAU,EAAA;;WAEP,EAAA,CAAA,GAAW,EAAA;WAChB,CAAA,CAAA,GAAC,IAAI,eAAc,YAAa,SAAI,IAAS,OAAO,WAAW,eAAc;;AADxE,EAAA,UAAA,CAAA,EAAA;WAGA,MAAA,CAAA,IAAuB,EAAA;WAC5B;AACH,MAAA,OAAA,EAAA,IAAO;;;AAFC,EAAA,UAAA,CAAA,MAAA;YAKC,CAAA,IAAA,GAAA,eAAkB,CAAA,CAAA;AACvC,CAAC,EAXgB,UAAU,KAAV,UAAU,GAW1B,EAAA,CAAA,CAAA,CAAA;MAEY,oBAAoB,CAAA;aAEC,GAAA,EAAiB;AAC5B,EAAA,gBAAA,GAAmB,IAAA,OAAW,EAAA,CAAA;AAEjD,EAAA,WAAA,CAAA,YAAsC,EAAA;AAClC,IAAA,SAAA,CAAA,OAAU,CAAA,CAAA,IAAS,IAAI,CAAI,IAAC,CAAI,CAAA,CAAA,CAAA,CAAC;;AAGrC;;;AAGG;AACH,EAAA,IAAA,SAAa,GAAA;AACT,IAAA,OAAA,IAAO,CAAI,gBAAiB,CAAA;;eAGT,GAAA;QACnB,IAAI,CAAA,QAAa,IAAA,CAAA,IAAK,CAAI;AACtB,MAAA,IAAA,CAAA,gBAAqB,CAAA,IAAA,CAAA,SAAM,CAAA,CAAA;AAC3B,MAAA,IAAA,CAAA,gBAAK,CAAA,OAAiB,EAAA,CAAA;AACzB,KAAA;;AAGL,EAAA,IAAA,QAAY,GAAA;AACR,IAAA,OAAA,IAAO,YAAK,CAAA,MAAkB,KAAA,CAAA,CAAA;;mBAGT,GAAA;SAClB,GAAA;AACH,IAAA,IAAA,IAAI,SAAK,IAAQ,IAAI,CAAI;aACd;AACV,KAAA;AACD,IAAA,IAAA,CAAA,iBAAK,GAAA,IAAoB,CAAA;AACzB,IAAA,OAAA,CAAA,IAAQ,CAAA,QAAK,EAAA;;sCAEkB,EAAC,CAAA;AAC3B,OAAA,CAAA,OAAA,CAAA,EAAA;AAAC,QAAA,OAAA,CAAA,KAAU,CAAA,CAAA,CAAA,CAAA;AACR,OAAA;AACH,KAAA;AACJ,IAAA,IAAA,CAAA,iBAAA,GAAA,KAAA,CAAA;AACD,IAAA,IAAA,CAAA,aAAK,EAAA,CAAA;;MAER,CAAA,UAAA,EAAA;AAED,IAAA,MAA2B,WAAA,GAAA,IAAA,CAAA,WAAA,CAAA;AACvB,IAAA,WAAiB,CAAA,IAAA,CAAA,UAAO,CAAA,CAAC;AACzB,IAAA,MAAA,eAAiB,GAAA,UAAY,CAAA,OAAA,CAAA,IAAA,CAAA,UAAA,CAAA,CAAA;UACvB,QAAA,GAAA,UAAkB,CAAA,MAAA,CAAA,MAAW;AACnC,MAAA,MAAA,mBAAiB,CAAA,OAAiB,CAAA,UAAM,CAAA,CAAA;eAC9B,KAAA,CAAA,CAAA;AACN,QAAA,WAAS,CAAA,MAAK,CAAC,KAAG,EAAA,CAAA,CAAA,CAAA;AACd,OAAA;AACH,MAAA,IAAA,CAAA,aAAA,EAAA,CAAA;;AAEL,IAAA,UAAG,CAAA,OAAA,GAAA,MAAA;AACH,MAAA,QAAA,CAAA,OAAW,EAAA,CAAA;qBACE,EAAO,CAAA;AAChB,KAAA,CAAA;AACJ,IAAA,OAAE,QAAA,CAAA;AACF,GAAA;SACH,CAAA,WAAA,EAAA;AAED,IAAA,OAAO,WAA0B,CAAA,GAAA,CAAA,UAAA,IAAA,IAAA,CAAA,IAAA,CAAA,UAAA,CAAA,CAAA,CAAA;AAC7B,GAAA;"}
+{"version":3,"file":"disposable.js","sources":["../../src/core/disposable.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/lib/core/event.js

@@ -1,254 +1,250 @@
 /* tslint:disable */
 var Event;
 (function (Event) {
-  const _disposable = {
-    dispose() {}
-  };
-  Event.None = Object.assign(function () {
-    return _disposable;
-  }, {
-    get maxListeners() {
-      return 0;
-    },
-    set maxListeners(maxListeners) {}
-  });
-  /**
-   * Given an event and a `map` function, returns another event which maps each element
-   * through the mapping function.
-   */
-  function map(event, mapFunc) {
-    return Object.assign((listener, thisArgs, disposables) => event(i => listener.call(thisArgs, mapFunc(i)), undefined, disposables), {
-      maxListeners: 0
+    const _disposable = { dispose() { } };
+    Event.None = Object.assign(function () { return _disposable; }, {
+        get maxListeners() { return 0; },
+        set maxListeners(maxListeners) { }
     });
-  }
-  Event.map = map;
+    /**
+     * Given an event and a `map` function, returns another event which maps each element
+     * through the mapping function.
+     */
+    function map(event, mapFunc) {
+        return Object.assign((listener, thisArgs, disposables) => event(i => listener.call(thisArgs, mapFunc(i)), undefined, disposables), {
+            maxListeners: 0,
+        });
+    }
+    Event.map = map;
 })(Event || (Event = {}));
 class CallbackList {
-  _callbacks;
-  _contexts;
-  get length() {
-    return this._callbacks && this._callbacks.length || 0;
-  }
-  add(callback, context = undefined, bucket) {
-    if (!this._callbacks) {
-      this._callbacks = [];
-      this._contexts = [];
-    }
-    this._callbacks.push(callback);
-    this._contexts.push(context);
-    if (Array.isArray(bucket)) {
-      bucket.push({
-        dispose: () => this.remove(callback, context)
-      });
-    }
-  }
-  remove(callback, context = undefined) {
-    if (!this._callbacks) {
-      return;
-    }
-    let foundCallbackWithDifferentContext = false;
-    for (let i = 0; i < this._callbacks.length; i++) {
-      if (this._callbacks[i] === callback) {
-        if (this._contexts[i] === context) {
-          // callback & context match => remove it
-          this._callbacks.splice(i, 1);
-          this._contexts.splice(i, 1);
-          return;
-        } else {
-          foundCallbackWithDifferentContext = true;
-        }
-      }
-    }
-    if (foundCallbackWithDifferentContext) {
-      throw new Error('When adding a listener with a context, you should remove it with the same context');
-    }
-  }
-  // tslint:disable-next-line:typedef
-  [Symbol.iterator]() {
-    if (!this._callbacks) {
-      return [][Symbol.iterator]();
-    }
-    const callbacks = this._callbacks.slice(0);
-    const contexts = this._contexts.slice(0);
-    return callbacks.map((callback, i) => (...args) => callback.apply(contexts[i], args))[Symbol.iterator]();
-  }
-  invoke(...args) {
-    const ret = [];
-    for (const callback of this) {
-      try {
-        ret.push(callback(...args));
-      } catch (e) {
-        console.error(e);
-      }
-    }
-    return ret;
-  }
-  isEmpty() {
-    return !this._callbacks || this._callbacks.length === 0;
-  }
-  dispose() {
-    this._callbacks = undefined;
-    this._contexts = undefined;
-  }
-}
-class Emitter {
-  _options;
-  static LEAK_WARNING_THRESHHOLD = 175;
-  static _noop = function () {};
-  _event;
-  _callbacks;
-  _disposed = false;
-  _leakingStacks;
-  _leakWarnCountdown = 0;
-  constructor(_options) {
-    this._options = _options;
-  }
-  /**
-   * For the public to allow to subscribe
-   * to events from this Emitter
-   */
-  get event() {
-    if (!this._event) {
-      this._event = Object.assign((listener, thisArgs, disposables) => {
+    _callbacks;
+    _contexts;
+    get length() {
+        return this._callbacks && this._callbacks.length || 0;
+    }
+    add(callback, context = undefined, bucket) {
         if (!this._callbacks) {
-          this._callbacks = new CallbackList();
+            this._callbacks = [];
+            this._contexts = [];
         }
-        if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
-          this._options.onFirstListenerAdd(this);
+        this._callbacks.push(callback);
+        this._contexts.push(context);
+        if (Array.isArray(bucket)) {
+            bucket.push({ dispose: () => this.remove(callback, context) });
+        }
+    }
+    remove(callback, context = undefined) {
+        if (!this._callbacks) {
+            return;
         }
-        this._callbacks.add(listener, thisArgs);
-        const removeMaxListenersCheck = this.checkMaxListeners(this._event.maxListeners);
-        const result = {
-          dispose: () => {
-            if (removeMaxListenersCheck) {
-              removeMaxListenersCheck();
+        let foundCallbackWithDifferentContext = false;
+        for (let i = 0; i < this._callbacks.length; i++) {
+            if (this._callbacks[i] === callback) {
+                if (this._contexts[i] === context) {
+                    // callback & context match => remove it
+                    this._callbacks.splice(i, 1);
+                    this._contexts.splice(i, 1);
+                    return;
+                }
+                else {
+                    foundCallbackWithDifferentContext = true;
+                }
             }
-            result.dispose = Emitter._noop;
-            if (!this._disposed) {
-              this._callbacks.remove(listener, thisArgs);
-              result.dispose = Emitter._noop;
-              if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
-                this._options.onLastListenerRemove(this);
-              }
+        }
+        if (foundCallbackWithDifferentContext) {
+            throw new Error('When adding a listener with a context, you should remove it with the same context');
+        }
+    }
+    // tslint:disable-next-line:typedef
+    [Symbol.iterator]() {
+        if (!this._callbacks) {
+            return [][Symbol.iterator]();
+        }
+        const callbacks = this._callbacks.slice(0);
+        const contexts = this._contexts.slice(0);
+        return callbacks.map((callback, i) => (...args) => callback.apply(contexts[i], args))[Symbol.iterator]();
+    }
+    invoke(...args) {
+        const ret = [];
+        for (const callback of this) {
+            try {
+                ret.push(callback(...args));
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        return ret;
+    }
+    isEmpty() {
+        return !this._callbacks || this._callbacks.length === 0;
+    }
+    dispose() {
+        this._callbacks = undefined;
+        this._contexts = undefined;
+    }
+}
+class Emitter {
+    _options;
+    static LEAK_WARNING_THRESHHOLD = 175;
+    static _noop = function () { };
+    _event;
+    _callbacks;
+    _disposed = false;
+    _leakingStacks;
+    _leakWarnCountdown = 0;
+    constructor(_options) {
+        this._options = _options;
+    }
+    /**
+     * For the public to allow to subscribe
+     * to events from this Emitter
+     */
+    get event() {
+        if (!this._event) {
+            this._event = Object.assign((listener, thisArgs, disposables) => {
+                if (!this._callbacks) {
+                    this._callbacks = new CallbackList();
+                }
+                if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
+                    this._options.onFirstListenerAdd(this);
+                }
+                this._callbacks.add(listener, thisArgs);
+                const removeMaxListenersCheck = this.checkMaxListeners(this._event.maxListeners);
+                const result = {
+                    dispose: () => {
+                        if (removeMaxListenersCheck) {
+                            removeMaxListenersCheck();
+                        }
+                        result.dispose = Emitter._noop;
+                        if (!this._disposed) {
+                            this._callbacks.remove(listener, thisArgs);
+                            result.dispose = Emitter._noop;
+                            if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
+                                this._options.onLastListenerRemove(this);
+                            }
+                        }
+                    }
+                };
+                if (Array.isArray(disposables)) {
+                    disposables.push(result);
+                }
+                return result;
+            }, {
+                maxListeners: Emitter.LEAK_WARNING_THRESHHOLD
+            });
+        }
+        return this._event;
+    }
+    checkMaxListeners(maxListeners) {
+        if (maxListeners === 0 || !this._callbacks) {
+            return undefined;
+        }
+        const listenerCount = this._callbacks.length;
+        if (listenerCount <= maxListeners) {
+            return undefined;
+        }
+        const popStack = this.pushLeakingStack();
+        this._leakWarnCountdown -= 1;
+        if (this._leakWarnCountdown <= 0) {
+            // only warn on first exceed and then every time the limit
+            // is exceeded by 50% again
+            this._leakWarnCountdown = maxListeners * 0.5;
+            let topStack;
+            let topCount = 0;
+            this._leakingStacks.forEach((stackCount, stack) => {
+                if (!topStack || topCount < stackCount) {
+                    topStack = stack;
+                    topCount = stackCount;
+                }
+            });
+            // eslint-disable-next-line max-len
+            console.warn(`Possible Emitter memory leak detected. ${listenerCount} listeners added. Use event.maxListeners to increase the limit (${maxListeners}). MOST frequent listener (${topCount}):`);
+            console.warn(topStack);
+        }
+        return popStack;
+    }
+    pushLeakingStack() {
+        if (!this._leakingStacks) {
+            this._leakingStacks = new Map();
+        }
+        const stack = new Error().stack.split('\n').slice(3).join('\n');
+        const count = (this._leakingStacks.get(stack) || 0);
+        this._leakingStacks.set(stack, count + 1);
+        return () => this.popLeakingStack(stack);
+    }
+    popLeakingStack(stack) {
+        if (!this._leakingStacks) {
+            return;
+        }
+        const count = (this._leakingStacks.get(stack) || 0);
+        this._leakingStacks.set(stack, count - 1);
+    }
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event) {
+        if (this._callbacks) {
+            this._callbacks.invoke(event);
+        }
+    }
+    /**
+     * Process each listener one by one.
+     * Return `false` to stop iterating over the listeners, `true` to continue.
+     */
+    async sequence(processor) {
+        if (this._callbacks) {
+            for (const listener of this._callbacks) {
+                if (!await processor(listener)) {
+                    break;
+                }
             }
-          }
-        };
-        if (Array.isArray(disposables)) {
-          disposables.push(result);
-        }
-        return result;
-      }, {
-        maxListeners: Emitter.LEAK_WARNING_THRESHHOLD
-      });
-    }
-    return this._event;
-  }
-  checkMaxListeners(maxListeners) {
-    if (maxListeners === 0 || !this._callbacks) {
-      return undefined;
-    }
-    const listenerCount = this._callbacks.length;
-    if (listenerCount <= maxListeners) {
-      return undefined;
-    }
-    const popStack = this.pushLeakingStack();
-    this._leakWarnCountdown -= 1;
-    if (this._leakWarnCountdown <= 0) {
-      // only warn on first exceed and then every time the limit
-      // is exceeded by 50% again
-      this._leakWarnCountdown = maxListeners * 0.5;
-      let topStack;
-      let topCount = 0;
-      this._leakingStacks.forEach((stackCount, stack) => {
-        if (!topStack || topCount < stackCount) {
-          topStack = stack;
-          topCount = stackCount;
-        }
-      });
-      // eslint-disable-next-line max-len
-      console.warn(`Possible Emitter memory leak detected. ${listenerCount} listeners added. Use event.maxListeners to increase the limit (${maxListeners}). MOST frequent listener (${topCount}):`);
-      console.warn(topStack);
-    }
-    return popStack;
-  }
-  pushLeakingStack() {
-    if (!this._leakingStacks) {
-      this._leakingStacks = new Map();
-    }
-    const stack = new Error().stack.split('\n').slice(3).join('\n');
-    const count = this._leakingStacks.get(stack) || 0;
-    this._leakingStacks.set(stack, count + 1);
-    return () => this.popLeakingStack(stack);
-  }
-  popLeakingStack(stack) {
-    if (!this._leakingStacks) {
-      return;
-    }
-    const count = this._leakingStacks.get(stack) || 0;
-    this._leakingStacks.set(stack, count - 1);
-  }
-  /**
-   * To be kept private to fire an event to
-   * subscribers
-   */
-  fire(event) {
-    if (this._callbacks) {
-      this._callbacks.invoke(event);
-    }
-  }
-  /**
-   * Process each listener one by one.
-   * Return `false` to stop iterating over the listeners, `true` to continue.
-   */
-  async sequence(processor) {
-    if (this._callbacks) {
-      for (const listener of this._callbacks) {
-        if (!(await processor(listener))) {
-          break;
-        }
-      }
-    }
-  }
-  dispose() {
-    if (this._leakingStacks) {
-      this._leakingStacks.clear();
-      this._leakingStacks = undefined;
-    }
-    if (this._callbacks) {
-      this._callbacks.dispose();
-      this._callbacks = undefined;
-    }
-    this._disposed = true;
-  }
+        }
+    }
+    dispose() {
+        if (this._leakingStacks) {
+            this._leakingStacks.clear();
+            this._leakingStacks = undefined;
+        }
+        if (this._callbacks) {
+            this._callbacks.dispose();
+            this._callbacks = undefined;
+        }
+        this._disposed = true;
+    }
 }
 var WaitUntilEvent;
 (function (WaitUntilEvent) {
-  async function fire(emitter, event, timeout = undefined) {
-    const waitables = [];
-    const asyncEvent = Object.assign(event, {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      waitUntil: thenable => {
-        if (Object.isFrozen(waitables)) {
-          throw new Error('waitUntil cannot be called asynchronously.');
-        }
-        waitables.push(thenable);
-      }
-    });
-    try {
-      emitter.fire(asyncEvent);
-      // Asynchronous calls to `waitUntil` should fail.
-      Object.freeze(waitables);
-    } finally {
-      delete asyncEvent['waitUntil'];
-    }
-    if (!waitables.length) {
-      return;
-    }
-    if (timeout !== undefined) {
-      await Promise.race([Promise.all(waitables), new Promise(resolve => setTimeout(resolve, timeout))]);
-    } else {
-      await Promise.all(waitables);
-    }
-  }
-  WaitUntilEvent.fire = fire;
+    async function fire(emitter, event, timeout = undefined) {
+        const waitables = [];
+        const asyncEvent = Object.assign(event, {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            waitUntil: (thenable) => {
+                if (Object.isFrozen(waitables)) {
+                    throw new Error('waitUntil cannot be called asynchronously.');
+                }
+                waitables.push(thenable);
+            }
+        });
+        try {
+            emitter.fire(asyncEvent);
+            // Asynchronous calls to `waitUntil` should fail.
+            Object.freeze(waitables);
+        }
+        finally {
+            delete asyncEvent['waitUntil'];
+        }
+        if (!waitables.length) {
+            return;
+        }
+        if (timeout !== undefined) {
+            await Promise.race([Promise.all(waitables), new Promise(resolve => setTimeout(resolve, timeout))]);
+        }
+        else {
+            await Promise.all(waitables);
+        }
+    }
+    WaitUntilEvent.fire = fire;
 })(WaitUntilEvent || (WaitUntilEvent = {}));export{Emitter,Event,WaitUntilEvent};//# sourceMappingURL=event.js.map