@tstdl/base 0.87.13 → 0.88.0-alpha1

package/utils/async-iterable-helpers/to-async-iterator.js

@@ -1,57 +1,35 @@
-"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 to_async_iterator_exports = {};
-__export(to_async_iterator_exports, {
-  iterableToAsyncIterator: () => iterableToAsyncIterator,
-  iteratorToAsyncIterator: () => iteratorToAsyncIterator
-});
-module.exports = __toCommonJS(to_async_iterator_exports);
-var import_is_iterable = require("../iterable-helpers/is-iterable.js");
-var import_type_guards = require("../type-guards.js");
-var import_is_async_iterable = require("./is-async-iterable.js");
-function iterableToAsyncIterator(iterable) {
-  let asyncIterator;
-  if ((0, import_is_iterable.isIterable)(iterable)) {
-    const iterator = iterable[Symbol.iterator]();
-    asyncIterator = iteratorToAsyncIterator(iterator);
-  } else if ((0, import_is_async_iterable.isAsyncIterable)(iterable)) {
-    asyncIterator = iterable[Symbol.asyncIterator]();
-  } else {
-    throw new Error("parameter is neither iterable nor async-iterable");
-  }
-  return asyncIterator;
-}
-function iteratorToAsyncIterator(iterator) {
-  const asyncIterator = {
-    async next(...args) {
-      return iterator.next(...args);
+import { isIterable } from '../iterable-helpers/is-iterable.js';
+import { isDefined } from '../type-guards.js';
+import { isAsyncIterable } from './is-async-iterable.js';
+export function iterableToAsyncIterator(iterable) {
+    let asyncIterator;
+    if (isIterable(iterable)) {
+        const iterator = iterable[Symbol.iterator]();
+        asyncIterator = iteratorToAsyncIterator(iterator);
     }
-  };
-  if ((0, import_type_guards.isDefined)(iterator.return)) {
-    asyncIterator.return = async function _return(value) {
-      return iterator.return(await value);
-    };
-  }
-  if ((0, import_type_guards.isDefined)(iterator.throw)) {
-    asyncIterator.throw = async function _throw(error) {
-      return iterator.throw(error);
+    else if (isAsyncIterable(iterable)) {
+        asyncIterator = iterable[Symbol.asyncIterator]();
+    }
+    else {
+        throw new Error('parameter is neither iterable nor async-iterable');
+    }
+    return asyncIterator;
+}
+export function iteratorToAsyncIterator(iterator) {
+    const asyncIterator = {
+        async next(...args) {
+            return iterator.next(...args);
+        }
     };
-  }
-  return asyncIterator;
+    if (isDefined(iterator.return)) { // eslint-disable-line @typescript-eslint/unbound-method
+        asyncIterator.return = async function _return(value) {
+            return iterator.return(await value);
+        };
+    }
+    if (isDefined(iterator.throw)) { // eslint-disable-line @typescript-eslint/unbound-method
+        asyncIterator.throw = async function _throw(error) {
+            return iterator.throw(error);
+        };
+    }
+    return asyncIterator;
 }

package/utils/async-iterable-helpers/to-set.js

@@ -1,34 +1,11 @@
-"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 to_set_exports = {};
-__export(to_set_exports, {
-  toSetAsync: () => toSetAsync
-});
-module.exports = __toCommonJS(to_set_exports);
-var import_is_iterable = require("../iterable-helpers/is-iterable.js");
-async function toSetAsync(iterable) {
-  if ((0, import_is_iterable.isIterable)(iterable)) {
-    return new Set(iterable);
-  }
-  const set = /* @__PURE__ */ new Set();
-  for await (const item of iterable) {
-    set.add(item);
-  }
-  return set;
+import { isIterable } from '../iterable-helpers/is-iterable.js';
+export async function toSetAsync(iterable) {
+    if (isIterable(iterable)) {
+        return new Set(iterable);
+    }
+    const set = new Set();
+    for await (const item of iterable) {
+        set.add(item);
+    }
+    return set;
 }

package/utils/async-iterable-helpers/to-sync-iterable.js

@@ -1,28 +1,7 @@
-"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 to_sync_iterable_exports = {};
-__export(to_sync_iterable_exports, {
-  toSync: () => toSync
-});
-module.exports = __toCommonJS(to_sync_iterable_exports);
-var import_is_iterable = require("../iterable-helpers/is-iterable.js");
-var import_to_array = require("./to-array.js");
-async function toSync(iterable) {
-  return (0, import_is_iterable.isIterable)(iterable) ? iterable : (0, import_to_array.toArrayAsync)(iterable);
+import { isIterable } from '../iterable-helpers/is-iterable.js';
+import { toArrayAsync } from './to-array.js';
+export async function toSync(iterable) {
+    return (isIterable(iterable))
+        ? iterable
+        : toArrayAsync(iterable);
 }

package/utils/async-iterable-helpers/types.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 types_exports = {};
-module.exports = __toCommonJS(types_exports);
+export {};

package/utils/async-iterable-helpers/while.js

@@ -1,53 +1,32 @@
-"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 while_exports = {};
-__export(while_exports, {
-  whileAsync: () => whileAsync
-});
-module.exports = __toCommonJS(while_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-function whileAsync(iterable, predicate) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, predicate) : sync(iterable, predicate);
+import { isAsyncIterable } from './is-async-iterable.js';
+export function whileAsync(iterable, predicate) {
+    return (isAsyncIterable(iterable))
+        ? async(iterable, predicate)
+        : sync(iterable, predicate);
 }
 async function* sync(iterable, predicate) {
-  let index = 0;
-  for (const item of iterable) {
-    yield item;
-    let goOn = predicate(item, index++);
-    if (goOn instanceof Promise) {
-      goOn = await goOn;
+    let index = 0;
+    for (const item of iterable) {
+        yield item;
+        let goOn = predicate(item, index++);
+        if (goOn instanceof Promise) {
+            goOn = await goOn;
+        }
+        if (!goOn) {
+            return;
+        }
     }
-    if (!goOn) {
-      return;
-    }
-  }
 }
 async function* async(iterable, predicate) {
-  let index = 0;
-  for await (const item of iterable) {
-    yield item;
-    let goOn = predicate(item, index++);
-    if (goOn instanceof Promise) {
-      goOn = await goOn;
-    }
-    if (!goOn) {
-      return;
+    let index = 0;
+    for await (const item of iterable) {
+        yield item;
+        let goOn = predicate(item, index++);
+        if (goOn instanceof Promise) {
+            goOn = await goOn;
+        }
+        if (!goOn) {
+            return;
+        }
     }
-  }
 }

package/utils/async-iterator-iterable-iterator.js

@@ -1,66 +1,45 @@
-"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_iterator_iterable_iterator_exports = {};
-__export(async_iterator_iterable_iterator_exports, {
-  AsyncIteratorIterableIterator: () => AsyncIteratorIterableIterator
-});
-module.exports = __toCommonJS(async_iterator_iterable_iterator_exports);
-var import_type_guards = require("./type-guards.js");
-class AsyncIteratorIterableIterator {
-  iterator;
-  keepOpen;
-  constructor(iterator, keepOpen = false) {
-    this.iterator = iterator;
-    this.keepOpen = keepOpen;
-  }
-  async next(...args) {
-    return this.iterator.next(...args);
-  }
-  async return(value) {
-    (0, import_type_guards.assertDefined)(this.iterator.return, "underlying iterator has no return function defined");
-    return this.iterator.return(value);
-  }
-  async throw(error) {
-    (0, import_type_guards.assertDefined)(this.iterator.throw, "underlying iterator has no throw function defined");
-    return this.iterator.throw(error);
-  }
-  async *[Symbol.asyncIterator]() {
-    let finished = false;
-    try {
-      while (true) {
-        const result = await this.iterator.next();
-        if (result.done == true) {
-          finished = true;
-          return;
-        }
+import { assertDefined } from './type-guards.js';
+export class AsyncIteratorIterableIterator {
+    iterator;
+    keepOpen;
+    constructor(iterator, keepOpen = false) {
+        this.iterator = iterator;
+        this.keepOpen = keepOpen;
+    }
+    async next(...args) {
+        return this.iterator.next(...args);
+    }
+    async return(value) {
+        assertDefined(this.iterator.return, 'underlying iterator has no return function defined'); // eslint-disable-line @typescript-eslint/unbound-method
+        return this.iterator.return(value);
+    }
+    async throw(error) {
+        assertDefined(this.iterator.throw, 'underlying iterator has no throw function defined'); // eslint-disable-line @typescript-eslint/unbound-method
+        return this.iterator.throw(error);
+    }
+    async *[Symbol.asyncIterator]() {
+        let finished = false;
         try {
-          yield result.value;
-        } catch (error) {
-          if (this.iterator.throw != void 0) {
-            await this.iterator.throw(error);
-          }
+            while (true) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+                const result = await this.iterator.next();
+                if (result.done == true) {
+                    finished = true;
+                    return;
+                }
+                try {
+                    yield result.value;
+                }
+                catch (error) {
+                    if (this.iterator.throw != undefined) {
+                        await this.iterator.throw(error);
+                    }
+                }
+            }
+        }
+        finally {
+            if (!finished && !this.keepOpen && this.iterator.return != undefined) {
+                await this.iterator.return();
+            }
         }
-      }
-    } finally {
-      if (!finished && !this.keepOpen && this.iterator.return != void 0) {
-        await this.iterator.return();
-      }
     }
-  }
 }

package/utils/backoff.js

@@ -1,119 +1,119 @@
-"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 backoff_exports = {};
-__export(backoff_exports, {
-  BackoffHelper: () => BackoffHelper,
-  autoBackoffLoop: () => autoBackoffLoop,
-  backoffGenerator: () => backoffGenerator,
-  backoffLoop: () => backoffLoop
-});
-module.exports = __toCommonJS(backoff_exports);
-var import_token = require("../cancellation/token.js");
-var import_noop = require("./noop.js");
-var import_timing = require("./timing.js");
-var import_type_guards = require("./type-guards.js");
-class BackoffHelper {
-  strategy;
-  initialDelay;
-  increase;
-  maximumDelay;
-  delay;
-  constructor({ strategy, initialDelay, increase, maximumDelay }) {
-    this.strategy = strategy;
-    this.initialDelay = initialDelay;
-    this.increase = increase;
-    this.maximumDelay = maximumDelay ?? Number.MAX_SAFE_INTEGER;
-    this.reset();
-  }
-  reset() {
-    this.delay = this.initialDelay;
-  }
-  backoff() {
-    this.delay = getNewDelay(this.strategy, this.delay, this.increase, this.maximumDelay);
-    return this.delay;
-  }
-}
-async function autoBackoffLoop(options, loopFunction, extras) {
-  const errorHandler = extras?.errorHandler ?? import_noop.noop;
-  return backoffLoop(options, async (controller) => {
-    try {
-      await loopFunction(controller);
-    } catch (error) {
-      errorHandler(error);
-      controller.backoff();
+import { CancellationToken } from '../cancellation/token.js';
+import { noop } from './noop.js';
+import { cancelableTimeout } from './timing.js';
+import { isDefined } from './type-guards.js';
+export class BackoffHelper {
+    strategy;
+    initialDelay;
+    increase;
+    maximumDelay;
+    delay;
+    constructor({ strategy, initialDelay, increase, maximumDelay }) {
+        this.strategy = strategy;
+        this.initialDelay = initialDelay;
+        this.increase = increase;
+        this.maximumDelay = maximumDelay ?? Number.MAX_SAFE_INTEGER;
+        this.reset();
     }
-  }, { cancellationSignal: extras?.cancellationSignal });
-}
-async function backoffLoop(options, loopFunction, extras) {
-  const backoffHelper = new BackoffHelper(options);
-  const loopCancellationToken = extras?.cancellationSignal?.createChild({ unset: false, complete: false }) ?? new import_token.CancellationToken();
-  let backoff = false;
-  const controller = {
-    backoff: () => backoff = true,
-    break: () => loopCancellationToken.set()
-  };
-  while (!loopCancellationToken.isSet) {
-    await loopFunction(controller);
-    if (loopCancellationToken.isSet) {
-      return;
+    reset() {
+        this.delay = this.initialDelay;
     }
-    if (backoff) {
-      backoff = false;
-      const milliseconds = backoffHelper.backoff();
-      await (0, import_timing.cancelableTimeout)(milliseconds, loopCancellationToken);
-    } else {
-      backoffHelper.reset();
+    backoff() {
+        this.delay = getNewDelay(this.strategy, this.delay, this.increase, this.maximumDelay);
+        return this.delay;
     }
-  }
 }
-async function* backoffGenerator(options, cancellationSignal) {
-  const backoffHelper = new BackoffHelper(options);
-  while (cancellationSignal.isUnset) {
+/**
+ * runs a function until token is set or controller returns and automatically backsoff if function throws. Warning: swallows errors
+ * @param options backoff options
+ * @param cancellationToken token to cancel loop
+ * @param loopFunction function to call
+ */
+export async function autoBackoffLoop(options, loopFunction, extras) {
+    const errorHandler = extras?.errorHandler ?? noop;
+    return backoffLoop(options, async (controller) => {
+        try {
+            await loopFunction(controller);
+        }
+        catch (error) {
+            errorHandler(error);
+            controller.backoff();
+        }
+    }, { cancellationSignal: extras?.cancellationSignal });
+}
+/**
+ * runs a function until token is set or controller returns.
+ * @param options backoff options
+ * @param cancellationToken signal to cancel loop
+ * @param loopFunction function to call
+ */
+export async function backoffLoop(options, loopFunction, extras) {
+    const backoffHelper = new BackoffHelper(options);
+    const loopCancellationToken = extras?.cancellationSignal?.createChild({ unset: false, complete: false }) ?? new CancellationToken();
     let backoff = false;
-    let timeoutToken = cancellationSignal;
-    const backoffFunction = (continueToken) => {
-      backoff = true;
-      if ((0, import_type_guards.isDefined)(continueToken)) {
-        timeoutToken = cancellationSignal.createChild().inherit(continueToken);
-      }
+    const controller = {
+        backoff: () => backoff = true,
+        break: () => loopCancellationToken.set()
     };
-    yield backoffFunction;
-    if (backoff) {
-      const milliseconds = backoffHelper.backoff();
-      await (0, import_timing.cancelableTimeout)(milliseconds, timeoutToken);
-    } else {
-      backoffHelper.reset();
+    while (!loopCancellationToken.isSet) {
+        await loopFunction(controller);
+        if (loopCancellationToken.isSet) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+            return;
+        }
+        if (backoff) {
+            backoff = false;
+            const milliseconds = backoffHelper.backoff();
+            await cancelableTimeout(milliseconds, loopCancellationToken);
+        }
+        else {
+            backoffHelper.reset();
+        }
+    }
+}
+/**
+ * generates endless function which, when called, backs off next iteration
+ * @param options backoff options
+ * @param cancellationSignal signal to cancel loop
+ * @example
+ * for await (const backoff of backoffGenerator(options, token)) {
+ *  if (iWantToBackoff) {
+ *    backoff();
+ *  }
+ * }
+ */
+export async function* backoffGenerator(options, cancellationSignal) {
+    const backoffHelper = new BackoffHelper(options);
+    while (cancellationSignal.isUnset) {
+        let backoff = false;
+        let timeoutToken = cancellationSignal;
+        const backoffFunction = (continueToken) => {
+            backoff = true;
+            if (isDefined(continueToken)) {
+                timeoutToken = cancellationSignal.createChild().inherit(continueToken);
+            }
+        };
+        yield backoffFunction;
+        if (backoff) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+            const milliseconds = backoffHelper.backoff();
+            await cancelableTimeout(milliseconds, timeoutToken);
+        }
+        else {
+            backoffHelper.reset();
+        }
     }
-  }
 }
 function getNewDelay(strategy, currentDelay, increase, maximumDelay) {
-  let newDelay;
-  switch (strategy) {
-    case "linear":
-      newDelay = currentDelay + increase;
-      break;
-    case "exponential":
-      newDelay = currentDelay * increase;
-      break;
-    default:
-      throw new Error("unknown backoff-strategy");
-  }
-  newDelay = Math.min(newDelay, maximumDelay);
-  return newDelay;
+    let newDelay;
+    switch (strategy) {
+        case 'linear':
+            newDelay = currentDelay + increase;
+            break;
+        case 'exponential':
+            newDelay = currentDelay * increase;
+            break;
+        default:
+            throw new Error('unknown backoff-strategy');
+    }
+    newDelay = Math.min(newDelay, maximumDelay);
+    return newDelay;
 }