@tstdl/base 0.87.13 → 0.88.0-alpha1

package/pool/pool.js

@@ -1,146 +1,129 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var pool_exports = {};
-__export(pool_exports, {
-  Pool: () => Pool
-});
-module.exports = __toCommonJS(pool_exports);
-var import_array_list = require("../data-structures/array-list.js");
-var import_set_collection = require("../data-structures/set-collection.js");
-var import_disposable = require("../disposable/disposable.js");
-var import_environment = require("../environment.js");
-var import_type_guards = require("../utils/type-guards.js");
-class Pool {
-  size;
-  disposeOnError;
-  freeInstances;
-  usedInstances;
-  factory;
-  disposer;
-  logger;
-  placeholderInstances;
-  disposed;
-  get length() {
-    return this.freeInstances.size + this.usedInstances.size + this.placeholderInstances;
-  }
-  constructor(factory, disposer, logger, options) {
-    this.size = options?.size ?? ((0, import_type_guards.isDefined)(import_environment.hardwareConcurrency) ? import_environment.hardwareConcurrency / 2 : 4);
-    this.factory = factory;
-    this.disposer = disposer;
-    this.logger = logger;
-    this.disposeOnError = options?.disposeOnError ?? false;
-    this.freeInstances = new import_array_list.ArrayList();
-    this.usedInstances = new import_set_collection.SetCollection();
-    this.placeholderInstances = 0;
-    this.disposed = false;
-  }
-  owns(instance) {
-    return this.usedInstances.includes(instance) || this.freeInstances.includes(instance);
-  }
-  async get() {
-    if (this.disposed) {
-      throw new Error("Pool was disposed.");
+import { ArrayList } from '../data-structures/array-list.js';
+import { SetCollection } from '../data-structures/set-collection.js';
+import { disposeAsync } from '../disposable/disposable.js';
+import { hardwareConcurrency } from '../environment.js';
+import { isDefined } from '../utils/type-guards.js';
+export class Pool {
+    size;
+    disposeOnError;
+    freeInstances;
+    usedInstances;
+    factory;
+    disposer;
+    logger;
+    placeholderInstances;
+    disposed;
+    get length() {
+        return this.freeInstances.size + this.usedInstances.size + this.placeholderInstances;
     }
-    if (this.freeInstances.hasItems) {
-      const instance = this.freeInstances.removeFirst();
-      this.usedInstances.add(instance);
-      return instance;
+    constructor(factory, disposer, logger, options) {
+        this.size = options?.size ?? (isDefined(hardwareConcurrency) ? (hardwareConcurrency / 2) : 4);
+        this.factory = factory;
+        this.disposer = disposer;
+        this.logger = logger;
+        this.disposeOnError = options?.disposeOnError ?? false;
+        this.freeInstances = new ArrayList();
+        this.usedInstances = new SetCollection();
+        this.placeholderInstances = 0;
+        this.disposed = false;
     }
-    if (this.length < this.size) {
-      this.placeholderInstances++;
-      try {
-        const newInstance = await this.factory();
+    owns(instance) {
+        return this.usedInstances.includes(instance) || this.freeInstances.includes(instance);
+    }
+    async get() {
         if (this.disposed) {
-          await this.disposer(newInstance);
-          throw new Error("Pool was disposed.");
+            throw new Error('Pool was disposed.');
         }
-        this.usedInstances.add(newInstance);
-        return newInstance;
-      } finally {
-        this.placeholderInstances--;
-      }
-    }
-    while (!this.freeInstances.hasItems) {
-      await this.freeInstances.$onItems;
-    }
-    return this.get();
-  }
-  async release(instance) {
-    if (this.freeInstances.includes(instance)) {
-      throw new Error("Instance is free already.");
+        if (this.freeInstances.hasItems) {
+            const instance = this.freeInstances.removeFirst();
+            this.usedInstances.add(instance);
+            return instance;
+        }
+        if (this.length < this.size) {
+            this.placeholderInstances++;
+            try {
+                const newInstance = await this.factory();
+                if (this.disposed) {
+                    await this.disposer(newInstance);
+                    throw new Error('Pool was disposed.');
+                }
+                this.usedInstances.add(newInstance);
+                return newInstance;
+            }
+            finally {
+                this.placeholderInstances--;
+            }
+        }
+        while (!this.freeInstances.hasItems) {
+            await this.freeInstances.$onItems;
+        }
+        return this.get();
     }
-    if (!this.usedInstances.has(instance)) {
-      throw new Error("Instance is not from this pool.");
+    async release(instance) {
+        if (this.freeInstances.includes(instance)) {
+            throw new Error('Instance is free already.');
+        }
+        if (!this.usedInstances.has(instance)) {
+            throw new Error('Instance is not from this pool.');
+        }
+        this.usedInstances.delete(instance);
+        this.freeInstances.add(instance);
     }
-    this.usedInstances.delete(instance);
-    this.freeInstances.add(instance);
-  }
-  /**
-   * Get an instance from the pool and use it
-   * @param handler consumer of instance
-   * @returns instance
-   */
-  async use(handler, options = {}) {
-    const instance = await this.get();
-    try {
-      const result = await handler(instance);
-      await this.release(instance);
-      return result;
-    } catch (error) {
-      if (options.disposeOnError ?? this.disposeOnError) {
+    /**
+     * Get an instance from the pool and use it
+     * @param handler consumer of instance
+     * @returns instance
+     */
+    async use(handler, options = {}) {
+        const instance = await this.get();
         try {
-          await this.disposeInstance(instance);
-        } catch (disposeError) {
-          this.logger.error(disposeError);
+            const result = await handler(instance);
+            await this.release(instance);
+            return result;
+        }
+        catch (error) {
+            if (options.disposeOnError ?? this.disposeOnError) {
+                try {
+                    await this.disposeInstance(instance);
+                }
+                catch (disposeError) {
+                    this.logger.error(disposeError);
+                }
+            }
+            else {
+                await this.release(instance);
+            }
+            throw error;
         }
-      } else {
-        await this.release(instance);
-      }
-      throw error;
-    }
-  }
-  async disposeInstance(instance) {
-    let index;
-    if (this.usedInstances.has(instance)) {
-      this.usedInstances.delete(instance);
-    } else if ((0, import_type_guards.isDefined)(index = this.freeInstances.indexOf(instance))) {
-      this.freeInstances.removeAt(index);
-    } else {
-      throw new Error("Instance is not from this pool.");
     }
-    await this.disposer(instance);
-  }
-  async dispose() {
-    return this[import_disposable.disposeAsync]();
-  }
-  async [import_disposable.disposeAsync]() {
-    this.disposed = true;
-    if (this.length == 0) {
-      return;
+    async disposeInstance(instance) {
+        let index;
+        if (this.usedInstances.has(instance)) {
+            this.usedInstances.delete(instance);
+        }
+        else if (isDefined(index = this.freeInstances.indexOf(instance))) {
+            this.freeInstances.removeAt(index);
+        }
+        else {
+            throw new Error('Instance is not from this pool.');
+        }
+        await this.disposer(instance);
     }
-    while (this.freeInstances.size > 0) {
-      const instance = this.freeInstances.removeFirst();
-      await this.disposer(instance);
+    async dispose() {
+        return this[disposeAsync]();
     }
-    for (const instance of this.usedInstances) {
-      await this.disposer(instance);
-      this.usedInstances.delete(instance);
+    async [disposeAsync]() {
+        this.disposed = true;
+        if (this.length == 0) {
+            return;
+        }
+        while (this.freeInstances.size > 0) {
+            const instance = this.freeInstances.removeFirst();
+            await this.disposer(instance);
+        }
+        for (const instance of this.usedInstances) {
+            await this.disposer(instance);
+            this.usedInstances.delete(instance);
+        }
     }
-  }
 }

package/process-shutdown.js

@@ -1,93 +1,69 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var process_shutdown_exports = {};
-__export(process_shutdown_exports, {
-  forceShutdown: () => forceShutdown,
-  getShutdownSignal: () => getShutdownSignal,
-  getShutdownToken: () => getShutdownToken,
-  initializeSignals: () => initializeSignals,
-  requestShutdown: () => requestShutdown,
-  setProcessShutdownLogger: () => setProcessShutdownLogger
-});
-module.exports = __toCommonJS(process_shutdown_exports);
-var import_cancellation = require("./cancellation/index.js");
-var import_type_guards = require("./utils/type-guards.js");
-const quitSignals = ["SIGTERM", "SIGINT", "SIGHUP", "SIGBREAK"];
-const quitEvents = ["uncaughtException", "unhandledRejection", "rejectionHandled"];
+/* eslint-disable no-console */
+import { CancellationToken } from './cancellation/index.js';
+import { isDefined, isUndefined } from './utils/type-guards.js';
+const quitSignals = ['SIGTERM', 'SIGINT', 'SIGHUP', 'SIGBREAK'];
+const quitEvents = ['uncaughtException' /* , 'multipleResolves' */, 'unhandledRejection', 'rejectionHandled'];
 let shutdownToken;
-function getShutdownToken() {
-  if ((0, import_type_guards.isUndefined)(shutdownToken)) {
-    shutdownToken = new import_cancellation.CancellationToken();
-  }
-  return shutdownToken;
+export function getShutdownToken() {
+    if (isUndefined(shutdownToken)) {
+        shutdownToken = new CancellationToken();
+    }
+    return shutdownToken;
 }
-function getShutdownSignal() {
-  return getShutdownToken().signal;
+export function getShutdownSignal() {
+    return getShutdownToken().signal;
 }
 let logger;
-function setProcessShutdownLogger(shutdownLogger) {
-  logger = shutdownLogger;
+// eslint-disable-next-line no-shadow
+export function setProcessShutdownLogger(shutdownLogger) {
+    logger = shutdownLogger;
 }
 let shutdownRequested = false;
-function requestShutdown(exitCode = 1) {
-  if (shutdownRequested) {
-    return;
-  }
-  shutdownRequested = true;
-  getShutdownToken().set();
-  const timeout = setTimeout(() => {
-    logger.warn("forcefully quitting after 20 seconds...");
-    setTimeout(() => process.exit(exitCode), 1);
-  }, 2e4);
-  timeout.unref();
+export function requestShutdown(exitCode = 1) {
+    if (shutdownRequested) {
+        return;
+    }
+    shutdownRequested = true;
+    getShutdownToken().set();
+    const timeout = setTimeout(() => {
+        logger.warn('forcefully quitting after 20 seconds...');
+        setTimeout(() => process.exit(exitCode), 1);
+    }, 20000);
+    timeout.unref();
 }
-function forceShutdown(exitCode = 1) {
-  logger.warn("forcefully quitting");
-  setTimeout(() => process.exit(exitCode), 1);
+export function forceShutdown(exitCode = 1) {
+    logger.warn('forcefully quitting');
+    setTimeout(() => process.exit(exitCode), 1);
 }
 let signalsInitialized = false;
-function initializeSignals() {
-  if (signalsInitialized || typeof process == "undefined") {
-    return;
-  }
-  signalsInitialized = true;
-  let signalCounter = 0;
-  let quitReason;
-  process.on("beforeExit", () => {
-    if ((0, import_type_guards.isDefined)(quitReason)) {
-      console.info("\nquit reason:", ...quitReason);
+export function initializeSignals() {
+    if (signalsInitialized || (typeof process == 'undefined')) {
+        return;
     }
-  });
-  for (const event of quitEvents) {
-    process.on(event, (...args) => {
-      console.error(event, ...args);
-      quitReason = args;
-      requestShutdown();
+    signalsInitialized = true;
+    let signalCounter = 0;
+    let quitReason;
+    process.on('beforeExit', () => {
+        if (isDefined(quitReason)) {
+            console.info('\nquit reason:', ...quitReason);
+        }
     });
-  }
-  for (const quitSignal of quitSignals) {
-    process.on(quitSignal, (signal) => {
-      logger.info(`${signal} received, quitting.`);
-      requestShutdown();
-      if (++signalCounter > 1) {
-        forceShutdown();
-      }
-    });
-  }
+    for (const event of quitEvents) {
+        // eslint-disable-next-line @typescript-eslint/no-loop-func
+        process.on(event, (...args) => {
+            console.error(event, ...args);
+            quitReason = args;
+            requestShutdown();
+        });
+    }
+    for (const quitSignal of quitSignals) {
+        // eslint-disable-next-line @typescript-eslint/no-loop-func
+        process.on(quitSignal, (signal) => {
+            logger.info(`${signal} received, quitting.`);
+            requestShutdown();
+            if (++signalCounter > 1) {
+                forceShutdown();
+            }
+        });
+    }
 }

package/promise/cancelable-promise.js

@@ -1,42 +1,24 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cancelable_promise_exports = {};
-__export(cancelable_promise_exports, {
-  cancelablePromise: () => cancelablePromise
-});
-module.exports = __toCommonJS(cancelable_promise_exports);
-function cancelablePromise(promise, cancelationPromise) {
-  return new Promise((resolve, reject) => {
-    let pending = true;
-    const pendingResolve = (result) => {
-      if (pending) {
-        resolve(result);
-        pending = false;
-      }
-    };
-    const pendingReject = (reason) => {
-      if (pending) {
-        reject(reason);
-        pending = false;
-      }
-    };
-    promise.then((value) => pendingResolve({ canceled: false, value })).catch(pendingReject);
-    cancelationPromise.then(() => pendingResolve({ canceled: true }));
-  });
+// eslint-disable-next-line @typescript-eslint/promise-function-async
+export function cancelablePromise(promise, cancelationPromise) {
+    return new Promise((resolve, reject) => {
+        let pending = true;
+        const pendingResolve = (result) => {
+            if (pending) {
+                resolve(result);
+                pending = false;
+            }
+        };
+        const pendingReject = (reason) => {
+            if (pending) {
+                reject(reason);
+                pending = false;
+            }
+        };
+        promise
+            .then((value) => pendingResolve({ canceled: false, value }))
+            .catch(pendingReject);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        cancelationPromise
+            .then(() => pendingResolve({ canceled: true }));
+    });
 }

package/promise/deferred-promise.js

@@ -1,97 +1,73 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var deferred_promise_exports = {};
-__export(deferred_promise_exports, {
-  DeferredPromise: () => DeferredPromise,
-  PromiseState: () => PromiseState
-});
-module.exports = __toCommonJS(deferred_promise_exports);
-var PromiseState;
-(function(PromiseState2) {
-  PromiseState2[PromiseState2["Pending"] = 0] = "Pending";
-  PromiseState2[PromiseState2["Resolved"] = 1] = "Resolved";
-  PromiseState2[PromiseState2["Rejected"] = 2] = "Rejected";
+export var PromiseState;
+(function (PromiseState) {
+    PromiseState[PromiseState["Pending"] = 0] = "Pending";
+    PromiseState[PromiseState["Resolved"] = 1] = "Resolved";
+    PromiseState[PromiseState["Rejected"] = 2] = "Rejected";
 })(PromiseState || (PromiseState = {}));
-class DeferredPromise {
-  static [Symbol.species] = Promise;
-  backingPromise;
-  resolvePromise;
-  rejectPromise;
-  state;
-  [Symbol.toStringTag] = "DeferredPromise";
-  get resolved() {
-    return this.state == PromiseState.Resolved;
-  }
-  get rejected() {
-    return this.state == PromiseState.Rejected;
-  }
-  get pending() {
-    return this.state == PromiseState.Pending;
-  }
-  get settled() {
-    return this.state != PromiseState.Pending;
-  }
-  constructor(executor) {
-    this.reset();
-    if (executor != void 0) {
-      executor((value) => this.resolve(value), (reason) => this.reject(reason));
+export class DeferredPromise {
+    static [Symbol.species] = Promise;
+    backingPromise;
+    resolvePromise;
+    rejectPromise;
+    state;
+    [Symbol.toStringTag] = 'DeferredPromise';
+    get resolved() {
+        return this.state == PromiseState.Resolved;
     }
-  }
-  // eslint-disable-next-line @typescript-eslint/promise-function-async
-  then(onfulfilled, onrejected) {
-    return this.backingPromise.then(onfulfilled, onrejected);
-  }
-  // eslint-disable-next-line @typescript-eslint/promise-function-async
-  catch(onrejected) {
-    return this.backingPromise.catch(onrejected);
-  }
-  // eslint-disable-next-line @typescript-eslint/promise-function-async
-  finally(onfinally) {
-    return this.backingPromise.finally(onfinally);
-  }
-  resolve(value) {
-    this.ensurePendingState();
-    this.resolvePromise(value);
-    this.state = PromiseState.Resolved;
-  }
-  resolveAndReset(value) {
-    this.resolve(value);
-    this.reset();
-  }
-  reject(reason) {
-    this.ensurePendingState();
-    this.rejectPromise(reason);
-    this.state = PromiseState.Rejected;
-  }
-  reset() {
-    this.backingPromise = new Promise((resolve, reject) => {
-      this.resolvePromise = resolve;
-      this.rejectPromise = reject;
-    });
-    this.state = PromiseState.Pending;
-  }
-  ensurePendingState() {
-    if (this.resolved) {
-      throw new Error("Promise already resolved.");
+    get rejected() {
+        return this.state == PromiseState.Rejected;
     }
-    if (this.rejected) {
-      throw new Error("Promise already rejected.");
+    get pending() {
+        return this.state == PromiseState.Pending;
+    }
+    get settled() {
+        return this.state != PromiseState.Pending;
+    }
+    constructor(executor) {
+        this.reset();
+        if (executor != undefined) {
+            executor((value) => this.resolve(value), (reason) => this.reject(reason));
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    then(onfulfilled, onrejected) {
+        return this.backingPromise.then(onfulfilled, onrejected);
+    }
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    catch(onrejected) {
+        return this.backingPromise.catch(onrejected);
+    }
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    finally(onfinally) {
+        return this.backingPromise.finally(onfinally);
+    }
+    resolve(value) {
+        this.ensurePendingState();
+        this.resolvePromise(value);
+        this.state = PromiseState.Resolved;
+    }
+    resolveAndReset(value) {
+        this.resolve(value);
+        this.reset();
+    }
+    reject(reason) {
+        this.ensurePendingState();
+        this.rejectPromise(reason);
+        this.state = PromiseState.Rejected;
+    }
+    reset() {
+        this.backingPromise = new Promise((resolve, reject) => {
+            this.resolvePromise = resolve;
+            this.rejectPromise = reject;
+        });
+        this.state = PromiseState.Pending;
+    }
+    ensurePendingState() {
+        if (this.resolved) {
+            throw new Error('Promise already resolved.');
+        }
+        if (this.rejected) {
+            throw new Error('Promise already rejected.');
+        }
     }
-  }
 }

package/promise/index.js

@@ -1,20 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var promise_exports = {};
-module.exports = __toCommonJS(promise_exports);
-__reExport(promise_exports, require("./cancelable-promise.js"), module.exports);
-__reExport(promise_exports, require("./deferred-promise.js"), module.exports);
-__reExport(promise_exports, require("./lazy-promise.js"), module.exports);
+export * from './cancelable-promise.js';
+export * from './deferred-promise.js';
+export * from './lazy-promise.js';