@tstdl/base 0.85.14 → 0.86.0-beta2

package/disposable/disposable.js

@@ -1,35 +1,9 @@
-"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]);
+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]);
 }
-function isAsyncDisposable(object) {
-  return (0, import_type_guards.isFunction)(object?.[disposeAsync]);
+export function isAsyncDisposable(object) {
+    return isFunction(object?.[disposeAsync]);
 }

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,84 @@
-"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_container = require("../container/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;
+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 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;
-  }
+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;
+    }
 };
 DistributedLoop = __decorate([
-  (0, import_container.injectable)(),
-  __param(0, (0, import_container.injectArg)()),
-  __metadata("design:paramtypes", [String, import_lock.LockProvider])
+    injectable(),
+    __param(0, injectArg()),
+    __metadata("design:paramtypes", [String, LockProvider])
 ], 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';

package/distributed-loop/provider.js

@@ -1,53 +1,25 @@
-"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 provider_exports = {};
-__export(provider_exports, {
-  DistributedLoopProvider: () => DistributedLoopProvider
-});
-module.exports = __toCommonJS(provider_exports);
-var import_container = require("../container/index.js");
-var import_lock = require("../lock/index.js");
-var import_distributed_loop = require("./distributed-loop.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 __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-let DistributedLoopProvider = class DistributedLoopProvider2 {
-  lockProvider;
-  constructor(lockProvider) {
-    this.lockProvider = lockProvider;
-  }
-  get(key) {
-    return new import_distributed_loop.DistributedLoop(key, this.lockProvider);
-  }
+import { singleton } from '../container/index.js';
+import { LockProvider } from '../lock/index.js';
+import { DistributedLoop } from './distributed-loop.js';
+export let DistributedLoopProvider = class DistributedLoopProvider {
+    lockProvider;
+    constructor(lockProvider) {
+        this.lockProvider = lockProvider;
+    }
+    get(key) {
+        return new DistributedLoop(key, this.lockProvider);
+    }
 };
 DistributedLoopProvider = __decorate([
-  (0, import_container.singleton)(),
-  __metadata("design:paramtypes", [import_lock.LockProvider])
+    singleton(),
+    __metadata("design:paramtypes", [LockProvider])
 ], DistributedLoopProvider);