@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/disposable/async-disposer.js

@@ -1,99 +1,111 @@
-import { isDefined } from '../utils/type-guards.js';
-import { MultiError } from '../error/multi.error.js';
-import { CancellationToken } from '../utils/cancellation-token.js';
-import { dispose, disposeAsync, isAsyncDisposable, isDisposable } from './disposable.js';
-const deferrerToken = Symbol('DeferrerToken');
-export class AsyncDisposer {
-    deferrers;
-    tasks;
-    _disposingToken;
-    _disposedToken;
-    get disposingToken() {
-        return this._disposingToken;
+"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_multi_error = require("../error/multi.error.js");
+var import_cancellation_token = require("../utils/cancellation-token.js");
+var import_disposable = require("./disposable.js");
+const deferrerToken = Symbol("DeferrerToken");
+class AsyncDisposer {
+  deferrers;
+  tasks;
+  _disposingToken;
+  _disposedToken;
+  get disposingToken() {
+    return this._disposingToken;
+  }
+  get disposedToken() {
+    return this._disposedToken;
+  }
+  get disposing() {
+    return this._disposingToken.isSet;
+  }
+  get disposed() {
+    return this._disposedToken.isSet;
+  }
+  constructor() {
+    this.deferrers = /* @__PURE__ */ new Set();
+    this.tasks = [];
+    this._disposingToken = new import_cancellation_token.CancellationToken();
+    this._disposedToken = new import_cancellation_token.CancellationToken();
+  }
+  getDeferrer() {
+    const deferrer = {
+      [deferrerToken]: new import_cancellation_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 disposedToken() {
-        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 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);
+      }
     }
-    constructor() {
-        this.deferrers = new Set();
-        this.tasks = [];
-        this._disposingToken = new CancellationToken();
-        this._disposedToken = new CancellationToken();
-    }
-    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 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();
-    }
-    async [disposeAsync]() {
-        return this.dispose();
+    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;
     }
+    this._disposedToken.set();
+  }
+  async [import_disposable.disposeAsync]() {
+    return this.dispose();
+  }
 }

package/disposable/disposable.js

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

package/disposable/index.js

@@ -1,3 +1,20 @@
-export * from './async-disposer.js';
-export * from './disposable.js';
-export * from './using.js';
+"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);

package/disposable/using.js

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

package/distributed-loop/controller.js

@@ -1 +1,16 @@
-export {};
+"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);

package/distributed-loop/distributed-loop.d.ts

@@ -1,12 +1,12 @@
-import type { Injectable } from '../container/index.js';
-import { type resolveArgumentType } from '../container/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+import type { Resolvable } from '../injector/interfaces.js';
 import { LockProvider } from '../lock/index.js';
 import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import type { LoopController } from './controller.js';
 export type LoopFunction = (controller: LoopController) => any | Promise<any>;
 /** loop key */
 export type DistributedLoopArgument = string;
-export declare class DistributedLoop implements Injectable<DistributedLoopArgument> {
+export declare class DistributedLoop implements Resolvable<DistributedLoopArgument> {
     private readonly key;
     private readonly lockProvider;
     readonly [resolveArgumentType]: string;

package/distributed-loop/distributed-loop.js

@@ -1,84 +1,111 @@
-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;
+"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+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_injector = require("../injector/index.js");
+var import_lock = require("../lock/index.js");
+var import_deferred_promise = require("../promise/deferred-promise.js");
+var import_cancellation_token = require("../utils/cancellation-token.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;
 };
-import { injectable, injectArg } from '../container/index.js';
-import { LockProvider } from '../lock/index.js';
-import { DeferredPromise } from '../promise/deferred-promise.js';
-import { CancellationToken } from '../utils/cancellation-token.js';
-import { Timer } from '../utils/timer.js';
-import { cancelableTimeout } from '../utils/timing.js';
-export 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 cancellationToken} is set or stop on the {@link LoopController} is called
-     * @param interval in millseconds
-     * @param accuracy in millseconds
-     * @param func handler to run
-     * @param cancellationToken token to cancel loop (same as calling stop on the {@link LoopController})
-     */
-    run(interval, accuracy, func, cancellationToken) {
-        const $stopped = new DeferredPromise();
-        const stopToken = cancellationToken?.createChild() ?? new CancellationToken();
-        const stopFunction = async () => {
-            if (!stopToken.isSet) {
-                stopToken.set();
-            }
-            await $stopped;
-        };
-        const controller = {
-            stop: stopFunction,
-            $stopped
-        };
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        (async () => {
-            const lock = this.lockProvider.get(this.key);
-            const timer = new Timer();
-            try {
-                // eslint-disable-next-line no-unmodified-loop-condition
-                while (!stopToken.isSet) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                    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;
-    }
+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 cancellationToken} is set or stop on the {@link LoopController} is called
+   * @param interval in millseconds
+   * @param accuracy in millseconds
+   * @param func handler to run
+   * @param cancellationToken token to cancel loop (same as calling stop on the {@link LoopController})
+   */
+  run(interval, accuracy, func, cancellationToken) {
+    const $stopped = new import_deferred_promise.DeferredPromise();
+    const stopToken = cancellationToken?.createChild() ?? new import_cancellation_token.CancellationToken();
+    const stopFunction = async () => {
+      if (!stopToken.isSet) {
+        stopToken.set();
+      }
+      await $stopped;
+    };
+    const controller = {
+      stop: stopFunction,
+      $stopped
+    };
+    (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;
+  }
 };
 DistributedLoop = __decorate([
-    injectable(),
-    __param(0, injectArg()),
-    __metadata("design:paramtypes", [String, LockProvider])
+  (0, import_injector.Injectable)(),
+  __param(0, (0, import_injector.InjectArg)()),
+  __metadata("design:paramtypes", [String, import_lock.LockProvider])
 ], DistributedLoop);

package/distributed-loop/index.js

@@ -1,3 +1,20 @@
-export * from './controller.js';
-export * from './distributed-loop.js';
-export * from './provider.js';
+"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);