@tstdl/base 0.83.0-beta2 → 0.83.0-beta3

package/pool/pool.js

@@ -1,124 +1,140 @@
-import { ArrayList } from '../data-structures/array-list.js';
-import { Set } from '../data-structures/set.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;
+"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 = require("../data-structures/set.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.freeInstances = new import_array_list.ArrayList();
+    this.usedInstances = new import_set.Set();
+    this.placeholderInstances = 0;
+    this.disposed = false;
+  }
+  async get() {
+    if (this.disposed) {
+      throw new Error("Pool was disposed.");
     }
-    constructor(factory, disposer, logger, options) {
-        this.size = options?.size ?? (isDefined(hardwareConcurrency) ? (hardwareConcurrency / 2) : 4);
-        this.factory = factory;
-        this.disposer = disposer;
-        this.logger = logger;
-        this.freeInstances = new ArrayList();
-        this.usedInstances = new Set();
-        this.placeholderInstances = 0;
-        this.disposed = false;
+    if (this.freeInstances.hasItems) {
+      const instance = this.freeInstances.removeFirst();
+      this.usedInstances.add(instance);
+      return instance;
     }
-    async get() {
+    if (this.length < this.size) {
+      this.placeholderInstances++;
+      try {
+        const newInstance = await this.factory();
         if (this.disposed) {
-            throw new Error('Pool was disposed.');
+          await this.disposer(newInstance);
+          throw new Error("Pool was disposed.");
         }
-        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();
+        this.usedInstances.add(newInstance);
+        return newInstance;
+      } finally {
+        this.placeholderInstances--;
+      }
     }
-    async release(instance) {
-        if (!this.usedInstances.has(instance)) {
-            throw new Error('Instance is not from this pool.');
-        }
-        this.usedInstances.delete(instance);
-        this.freeInstances.add(instance);
+    while (!this.freeInstances.hasItems) {
+      await this.freeInstances.$onItems;
     }
-    /**
-     * 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();
+    return this.get();
+  }
+  async release(instance) {
+    if (!this.usedInstances.has(instance)) {
+      throw new Error("Instance is not from this pool.");
+    }
+    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 == true) {
         try {
-            const result = await handler(instance);
-            await this.release(instance);
-            return result;
-        }
-        catch (error) {
-            if (options.disposeOnError == true) {
-                try {
-                    await this.disposeInstance(instance);
-                }
-                catch (disposeError) {
-                    this.logger.error(disposeError);
-                }
-            }
-            else {
-                await this.release(instance);
-            }
-            throw error;
+          await this.disposeInstance(instance);
+        } catch (disposeError) {
+          this.logger.error(disposeError);
         }
+      } else {
+        await this.release(instance);
+      }
+      throw error;
     }
-    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);
+  }
+  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.");
     }
-    async dispose() {
-        return this[disposeAsync]();
+    await this.disposer(instance);
+  }
+  async dispose() {
+    return this[import_disposable.disposeAsync]();
+  }
+  async [import_disposable.disposeAsync]() {
+    this.disposed = true;
+    if (this.length == 0) {
+      return;
     }
-    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);
-        }
-        await this[disposeAsync]();
+    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);
     }
+    await this[import_disposable.disposeAsync]();
+  }
 }
-//# sourceMappingURL=pool.js.map

package/process-shutdown.js

@@ -1,63 +1,85 @@
-/* eslint-disable no-console */
-import { CancellationToken } from './utils/cancellation-token.js';
-import { isDefined } from './utils/type-guards.js';
-import { container } from './container/container.js';
-import { CORE_LOGGER } from './core.js';
-const quitSignals = ['SIGTERM', 'SIGINT', 'SIGHUP', 'SIGBREAK'];
-const quitEvents = ['uncaughtException' /* , 'multipleResolves' */, 'unhandledRejection', 'rejectionHandled'];
-export const shutdownToken = new CancellationToken();
-let logger = container.resolve(CORE_LOGGER);
-// eslint-disable-next-line no-shadow
-export function setProcessShutdownLogger(shutdownLogger) {
-    logger = shutdownLogger;
+"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,
+  initializeSignals: () => initializeSignals,
+  requestShutdown: () => requestShutdown,
+  setProcessShutdownLogger: () => setProcessShutdownLogger,
+  shutdownToken: () => shutdownToken
+});
+module.exports = __toCommonJS(process_shutdown_exports);
+var import_cancellation_token = require("./utils/cancellation-token.js");
+var import_type_guards = require("./utils/type-guards.js");
+var import_container = require("./container/container.js");
+var import_core = require("./core.js");
+const quitSignals = ["SIGTERM", "SIGINT", "SIGHUP", "SIGBREAK"];
+const quitEvents = ["uncaughtException", "unhandledRejection", "rejectionHandled"];
+const shutdownToken = new import_cancellation_token.CancellationToken();
+let logger = import_container.container.resolve(import_core.CORE_LOGGER);
+function setProcessShutdownLogger(shutdownLogger) {
+  logger = shutdownLogger;
 }
 let shutdownRequested = false;
-export function requestShutdown() {
-    if (shutdownRequested) {
-        return;
-    }
-    shutdownRequested = true;
-    shutdownToken.set();
-    const timeout = setTimeout(() => {
-        logger.warn('forcefully quitting after 20 seconds...');
-        setTimeout(() => process.exit(1), 1);
-    }, 20000);
-    timeout.unref();
+function requestShutdown() {
+  if (shutdownRequested) {
+    return;
+  }
+  shutdownRequested = true;
+  shutdownToken.set();
+  const timeout = setTimeout(() => {
+    logger.warn("forcefully quitting after 20 seconds...");
+    setTimeout(() => process.exit(1), 1);
+  }, 2e4);
+  timeout.unref();
 }
-export function forceShutdown() {
-    logger.warn('forcefully quitting');
-    setTimeout(() => process.exit(2), 1);
+function forceShutdown() {
+  logger.warn("forcefully quitting");
+  setTimeout(() => process.exit(2), 1);
 }
 let signalsInitialized = false;
-export function initializeSignals() {
-    if (signalsInitialized) {
-        return;
+function initializeSignals() {
+  if (signalsInitialized) {
+    return;
+  }
+  signalsInitialized = true;
+  let signalCounter = 0;
+  let quitReason;
+  process.on("beforeExit", () => {
+    if ((0, import_type_guards.isDefined)(quitReason)) {
+      console.info("quit reason:", ...quitReason);
     }
-    signalsInitialized = true;
-    let signalCounter = 0;
-    let quitReason;
-    process.on('beforeExit', () => {
-        if (isDefined(quitReason)) {
-            console.info('quit reason:', ...quitReason);
-        }
+  });
+  for (const event of quitEvents) {
+    process.on(event, (...args) => {
+      console.error(event, ...args);
+      quitReason = args;
+      requestShutdown();
     });
-    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();
-            }
-        });
-    }
+  }
+  for (const quitSignal of quitSignals) {
+    process.on(quitSignal, (signal) => {
+      logger.info(`${signal} received, quitting.`);
+      requestShutdown();
+      if (++signalCounter > 1) {
+        forceShutdown();
+      }
+    });
+  }
 }
-//# sourceMappingURL=process-shutdown.js.map

package/promise/cancelable-promise.js

@@ -1,25 +1,42 @@
-// 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 }));
-    });
+"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 }));
+  });
 }
-//# sourceMappingURL=cancelable-promise.js.map

package/promise/deferred-promise.js

@@ -1,75 +1,97 @@
-export var PromiseState;
-(function (PromiseState) {
-    PromiseState[PromiseState["Pending"] = 0] = "Pending";
-    PromiseState[PromiseState["Resolved"] = 1] = "Resolved";
-    PromiseState[PromiseState["Rejected"] = 2] = "Rejected";
+"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";
 })(PromiseState || (PromiseState = {}));
 class DeferredPromise {
-    static [Symbol.species] = Promise;
-    backingPromise;
-    resolvePromise;
-    rejectPromise;
-    state;
-    [Symbol.toStringTag] = 'DeferredPromise';
-    get resolved() {
-        return this.state == PromiseState.Resolved;
+  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));
     }
-    get rejected() {
-        return this.state == PromiseState.Rejected;
+  }
+  // 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 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.');
-        }
+    if (this.rejected) {
+      throw new Error("Promise already rejected.");
     }
+  }
 }
-export { DeferredPromise };
-//# sourceMappingURL=deferred-promise.js.map

package/promise/index.js

@@ -1,4 +1,20 @@
-export * from './cancelable-promise.js';
-export * from './deferred-promise.js';
-export * from './lazy-promise.js';
-//# sourceMappingURL=index.js.map
+"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);