@tstdl/base 0.87.13 → 0.88.0-alpha1

package/disposable/async-disposer.js

@@ -1,137 +1,125 @@
-"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 async_disposer_exports = {};
-__export(async_disposer_exports, {
-  AsyncDisposer: () => AsyncDisposer
-});
-module.exports = __toCommonJS(async_disposer_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_token = require("../cancellation/token.js");
-var import_multi_error = require("../error/multi.error.js");
-var import_disposable = require("./disposable.js");
-const deferrerToken = Symbol("DeferrerToken");
-class AsyncDisposer {
-  #disposingToken;
-  #disposedToken;
-  #deferrers;
-  #tasks;
-  get disposingSignal() {
-    return this.#disposingToken;
-  }
-  get disposedSignal() {
-    return this.#disposedToken;
-  }
-  get disposing() {
-    return this.#disposingToken.isSet;
-  }
-  get disposed() {
-    return this.#disposedToken.isSet;
-  }
-  [Symbol.toStringTag] = "AsyncDisposable";
-  constructor() {
-    this.#deferrers = /* @__PURE__ */ new Set();
-    this.#tasks = [];
-    this.#disposingToken = new import_token.CancellationToken();
-    this.#disposedToken = new import_token.CancellationToken();
-  }
-  use(value) {
-    if ((0, import_type_guards.isNullOrUndefined)(value)) {
-      return value;
+import { isDefined, isNullOrUndefined } from '../utils/type-guards.js';
+import { CancellationToken } from '../cancellation/token.js';
+import { MultiError } from '../error/multi.error.js';
+import { dispose, disposeAsync, isAsyncDisposable, isDisposable } from './disposable.js';
+const deferrerToken = Symbol('DeferrerToken');
+export class AsyncDisposer {
+    #disposingToken;
+    #disposedToken;
+    #deferrers;
+    #tasks;
+    get disposingSignal() {
+        return this.#disposingToken;
     }
-    this.add(value);
-    return value;
-  }
-  adopt(value, onDisposeAsync) {
-    this.add(async () => onDisposeAsync(value));
-    return value;
-  }
-  move() {
-    const disposer = new AsyncDisposer();
-    disposer.#tasks = this.#tasks;
-    disposer.#deferrers = this.#deferrers;
-    this.#tasks = [];
-    this.#deferrers = /* @__PURE__ */ new Set();
-    this.#disposingToken.set();
-    this.#disposedToken.set();
-    return disposer;
-  }
-  getDeferrer() {
-    const deferrer = {
-      [deferrerToken]: new import_token.CancellationToken(),
-      yield: () => {
-        deferrer[deferrerToken].set();
-        this.#deferrers.delete(deferrer);
-      }
-    };
-    this.#deferrers.add(deferrer);
-    return deferrer;
-  }
-  async defer(func) {
-    const deferrer = this.getDeferrer();
-    try {
-      const result = await func();
-      return result;
-    } finally {
-      deferrer.yield();
+    get disposedSignal() {
+        return this.#disposedToken;
     }
-  }
-  /**
-   *
-   * @param fnOrDisposable
-   */
-  add(fnOrDisposable) {
-    const fn = (0, import_disposable.isAsyncDisposable)(fnOrDisposable) ? async () => fnOrDisposable[import_disposable.disposeAsync]() : (0, import_disposable.isDisposable)(fnOrDisposable) ? () => fnOrDisposable[import_disposable.dispose]() : fnOrDisposable;
-    this.#tasks.push({ taskFunction: fn });
-  }
-  async disposeAsync() {
-    await this.dispose();
-  }
-  async dispose() {
-    if (this.disposing) {
-      return this.#disposedToken.$set;
+    get disposing() {
+        return this.#disposingToken.isSet;
     }
-    this.#disposingToken.set();
-    const errors = [];
-    for (const deferrer of this.#deferrers) {
-      try {
-        await deferrer[deferrerToken];
-      } catch (error2) {
-        errors.push(error2);
-      }
+    get disposed() {
+        return this.#disposedToken.isSet;
     }
-    for (let i = this.#tasks.length - 1; i >= 0; i--) {
-      try {
-        const task = this.#tasks[i];
-        await task.taskFunction();
-      } catch (error2) {
-        errors.push(error2);
-      }
+    [Symbol.toStringTag] = 'AsyncDisposable';
+    constructor() {
+        this.#deferrers = new Set();
+        this.#tasks = [];
+        this.#disposingToken = new CancellationToken();
+        this.#disposedToken = new CancellationToken();
     }
-    const error = errors.length == 1 ? errors[0] : errors.length > 1 ? new import_multi_error.MultiError(errors, "dispose errors") : void 0;
-    if ((0, import_type_guards.isDefined)(error)) {
-      this.#disposedToken.error(error);
-      throw error;
+    use(value) {
+        if (isNullOrUndefined(value)) {
+            return value;
+        }
+        this.add(value);
+        return value;
+    }
+    adopt(value, onDisposeAsync) {
+        this.add(async () => onDisposeAsync(value));
+        return value;
+    }
+    move() {
+        const disposer = new AsyncDisposer();
+        disposer.#tasks = this.#tasks;
+        disposer.#deferrers = this.#deferrers;
+        this.#tasks = [];
+        this.#deferrers = new Set();
+        this.#disposingToken.set();
+        this.#disposedToken.set();
+        return disposer;
+    }
+    getDeferrer() {
+        const deferrer = {
+            [deferrerToken]: new CancellationToken(),
+            yield: () => {
+                deferrer[deferrerToken].set();
+                this.#deferrers.delete(deferrer);
+            }
+        };
+        this.#deferrers.add(deferrer);
+        return deferrer;
+    }
+    async defer(func) {
+        const deferrer = this.getDeferrer();
+        try {
+            const result = await func();
+            return result;
+        }
+        finally {
+            deferrer.yield();
+        }
+    }
+    /**
+     *
+     * @param fnOrDisposable
+     */
+    add(fnOrDisposable) {
+        const fn = isAsyncDisposable(fnOrDisposable)
+            ? async () => fnOrDisposable[disposeAsync]()
+            : isDisposable(fnOrDisposable)
+                ? () => fnOrDisposable[dispose]()
+                : fnOrDisposable;
+        this.#tasks.push({ taskFunction: fn });
+    }
+    async disposeAsync() {
+        await this.dispose();
+    }
+    async dispose() {
+        if (this.disposing) {
+            return this.#disposedToken.$set;
+        }
+        this.#disposingToken.set();
+        const errors = [];
+        for (const deferrer of this.#deferrers) {
+            try {
+                await deferrer[deferrerToken];
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        for (let i = this.#tasks.length - 1; i >= 0; i--) {
+            try {
+                const task = this.#tasks[i];
+                await task.taskFunction();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        const error = (errors.length == 1)
+            ? errors[0]
+            : (errors.length > 1)
+                ? new MultiError(errors, 'dispose errors')
+                : undefined;
+        if (isDefined(error)) {
+            this.#disposedToken.error(error);
+            throw error;
+        }
+        this.#disposedToken.set();
+        return undefined;
+    }
+    async [Symbol.asyncDispose]() {
+        return this.dispose();
     }
-    this.#disposedToken.set();
-    return void 0;
-  }
-  async [Symbol.asyncDispose]() {
-    return this.dispose();
-  }
 }

package/disposable/disposable.js

@@ -1,39 +1,12 @@
-"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 disposable_exports = {};
-__export(disposable_exports, {
-  dispose: () => dispose,
-  disposeAsync: () => disposeAsync,
-  isAsyncDisposable: () => isAsyncDisposable,
-  isDisposable: () => isDisposable,
-  isSyncOrAsyncDisposable: () => isSyncOrAsyncDisposable
-});
-module.exports = __toCommonJS(disposable_exports);
-var import_type_guards = require("../utils/type-guards.js");
-const dispose = Symbol.dispose;
-const disposeAsync = Symbol.asyncDispose;
-function isDisposable(object) {
-  return (0, import_type_guards.isFunction)(object?.[Symbol.dispose]);
+import { isFunction } from '../utils/type-guards.js';
+export const dispose = Symbol.dispose;
+export const disposeAsync = Symbol.asyncDispose;
+export function isDisposable(object) {
+    return isFunction(object?.[Symbol.dispose]);
 }
-function isAsyncDisposable(object) {
-  return (0, import_type_guards.isFunction)(object?.[Symbol.asyncDispose]);
+export function isAsyncDisposable(object) {
+    return isFunction(object?.[Symbol.asyncDispose]);
 }
-function isSyncOrAsyncDisposable(object) {
-  return (0, import_type_guards.isFunction)(object?.[Symbol.dispose] ?? object?.[Symbol.asyncDispose]);
+export function isSyncOrAsyncDisposable(object) {
+    return isFunction(object?.[Symbol.dispose] ?? object?.[Symbol.asyncDispose]);
 }

package/disposable/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 disposable_exports = {};
-module.exports = __toCommonJS(disposable_exports);
-__reExport(disposable_exports, require("./async-disposer.js"), module.exports);
-__reExport(disposable_exports, require("./disposable.js"), module.exports);
-__reExport(disposable_exports, require("./using.js"), module.exports);
+export * from './async-disposer.js';
+export * from './disposable.js';
+export * from './using.js';

package/disposable/using.js

@@ -1,39 +1,17 @@
-"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 using_exports = {};
-__export(using_exports, {
-  using: () => using,
-  usingAsync: () => usingAsync
-});
-module.exports = __toCommonJS(using_exports);
-var import_disposable = require("./disposable.js");
-function using(disposable, user) {
-  try {
-    return user(disposable);
-  } finally {
-    disposable[import_disposable.dispose]();
-  }
+import { dispose, disposeAsync } from './disposable.js';
+export function using(disposable, user) {
+    try {
+        return user(disposable);
+    }
+    finally {
+        disposable[dispose]();
+    }
 }
-async function usingAsync(disposable, user) {
-  try {
-    return await user(disposable);
-  } finally {
-    await disposable[import_disposable.disposeAsync]();
-  }
+export async function usingAsync(disposable, user) {
+    try {
+        return await user(disposable);
+    }
+    finally {
+        await disposable[disposeAsync]();
+    }
 }

package/distributed-loop/controller.js

@@ -1,16 +1 @@
-"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var controller_exports = {};
-module.exports = __toCommonJS(controller_exports);
+export {};

package/distributed-loop/distributed-loop.js

@@ -1,111 +1,83 @@
-"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var distributed_loop_exports = {};
-__export(distributed_loop_exports, {
-  DistributedLoop: () => DistributedLoop
-});
-module.exports = __toCommonJS(distributed_loop_exports);
-var import_cancellation = require("../cancellation/index.js");
-var import_injector = require("../injector/index.js");
-var import_lock = require("../lock/index.js");
-var import_deferred_promise = require("../promise/deferred-promise.js");
-var import_timer = require("../utils/timer.js");
-var import_timing = require("../utils/timing.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-};
-let DistributedLoop = class DistributedLoop2 {
-  key;
-  lockProvider;
-  /**
-   * a loop which runs distributed in the scope of the provided {@link LockProvider}.
-   * There will be at most only one actively running handler at the same time
-   *
-   * you can for example use the MongoLockProvider to have a shared loop over
-   * multiple app processes (cluster) to regularly call an api for updates
-   * @param key loop key to distinguish between multiple loops
-   * @param lockProvider
-   */
-  constructor(key, lockProvider) {
-    this.key = key;
-    this.lockProvider = lockProvider.prefix("loop:");
-  }
-  /**
-   * run the function {@link func} every {@link interval} milliseconds with an accuracy of {@link accuracy}
-   * until {@link cancellationSignal} is set or stop on the {@link LoopController} is called
-   * @param interval in millseconds
-   * @param accuracy in millseconds
-   * @param func handler to run
-   * @param cancellationSignal token to cancel loop (same as calling stop on the {@link LoopController})
-   */
-  run(interval, accuracy, func, cancellationSignal) {
-    const $stopped = new import_deferred_promise.DeferredPromise();
-    const stopToken = cancellationSignal?.createChild() ?? new import_cancellation.CancellationToken();
-    const stopFunction = async () => {
-      if (!stopToken.isSet) {
-        stopToken.set();
-      }
-      await $stopped;
-    };
-    const controller = {
-      stop: stopFunction,
-      $stopped
-    };
-    void (async () => {
-      const lock = this.lockProvider.get(this.key);
-      const timer = new import_timer.Timer();
-      try {
-        while (!stopToken.isSet) {
-          timer.restart();
-          await lock.use(void 0, false, async () => {
-            await func(controller);
-            const timeLeft = interval - timer.milliseconds;
-            const timeoutDuration = timeLeft - accuracy / 2;
-            await (0, import_timing.cancelableTimeout)(timeoutDuration, stopToken);
-          });
-          await (0, import_timing.cancelableTimeout)(accuracy, stopToken);
-        }
-      } finally {
-        $stopped.resolve();
-      }
-    })();
-    return controller;
-  }
+import { CancellationToken } from '../cancellation/index.js';
+import { InjectArg, Injectable, resolveArgumentType } from '../injector/index.js';
+import { LockProvider } from '../lock/index.js';
+import { DeferredPromise } from '../promise/deferred-promise.js';
+import { Timer } from '../utils/timer.js';
+import { cancelableTimeout } from '../utils/timing.js';
+let DistributedLoop = class DistributedLoop {
+    key;
+    lockProvider;
+    /**
+     * a loop which runs distributed in the scope of the provided {@link LockProvider}.
+     * There will be at most only one actively running handler at the same time
+     *
+     * you can for example use the MongoLockProvider to have a shared loop over
+     * multiple app processes (cluster) to regularly call an api for updates
+     * @param key loop key to distinguish between multiple loops
+     * @param lockProvider
+     */
+    constructor(key, lockProvider) {
+        this.key = key;
+        this.lockProvider = lockProvider.prefix('loop:');
+    }
+    /**
+     * run the function {@link func} every {@link interval} milliseconds with an accuracy of {@link accuracy}
+     * until {@link cancellationSignal} is set or stop on the {@link LoopController} is called
+     * @param interval in millseconds
+     * @param accuracy in millseconds
+     * @param func handler to run
+     * @param cancellationSignal token to cancel loop (same as calling stop on the {@link LoopController})
+     */
+    run(interval, accuracy, func, cancellationSignal) {
+        const $stopped = new DeferredPromise();
+        const stopToken = cancellationSignal?.createChild() ?? new CancellationToken();
+        const stopFunction = async () => {
+            if (!stopToken.isSet) {
+                stopToken.set();
+            }
+            await $stopped;
+        };
+        const controller = {
+            stop: stopFunction,
+            $stopped
+        };
+        void (async () => {
+            const lock = this.lockProvider.get(this.key);
+            const timer = new Timer();
+            try {
+                while (!stopToken.isSet) {
+                    timer.restart();
+                    await lock.use(undefined, false, async () => {
+                        await func(controller);
+                        const timeLeft = interval - timer.milliseconds;
+                        const timeoutDuration = timeLeft - (accuracy / 2);
+                        await cancelableTimeout(timeoutDuration, stopToken);
+                    });
+                    await cancelableTimeout(accuracy, stopToken);
+                }
+            }
+            finally {
+                $stopped.resolve();
+            }
+        })();
+        return controller;
+    }
 };
 DistributedLoop = __decorate([
-  (0, import_injector.Injectable)(),
-  __param(0, (0, import_injector.InjectArg)()),
-  __metadata("design:paramtypes", [String, import_lock.LockProvider])
+    Injectable(),
+    __param(0, InjectArg()),
+    __metadata("design:paramtypes", [String, LockProvider])
 ], DistributedLoop);
+export { DistributedLoop };

package/distributed-loop/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 distributed_loop_exports = {};
-module.exports = __toCommonJS(distributed_loop_exports);
-__reExport(distributed_loop_exports, require("./controller.js"), module.exports);
-__reExport(distributed_loop_exports, require("./distributed-loop.js"), module.exports);
-__reExport(distributed_loop_exports, require("./provider.js"), module.exports);
+export * from './controller.js';
+export * from './distributed-loop.js';
+export * from './provider.js';