@tstdl/base 0.87.13 → 0.88.0-alpha1

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

@@ -1,50 +1,29 @@
-"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 assert_exports = {};
-__export(assert_exports, {
-  assertAsync: () => assertAsync
-});
-module.exports = __toCommonJS(assert_exports);
-var import_type_guards = require("../type-guards.js");
-var import_is_async_iterable = require("./is-async-iterable.js");
-function assertAsync(iterable, predicate) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, predicate) : sync(iterable, predicate);
+import { assert as assertHelper } from '../type-guards.js';
+import { isAsyncIterable } from './is-async-iterable.js';
+export function assertAsync(iterable, predicate) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, predicate)
+        : sync(iterable, predicate);
 }
 async function* sync(iterable, predicate) {
-  let index = 0;
-  for (const item of iterable) {
-    let returnValue = predicate(item, index++);
-    if (returnValue instanceof Promise) {
-      returnValue = await returnValue;
+    let index = 0;
+    for (const item of iterable) {
+        let returnValue = predicate(item, index++);
+        if (returnValue instanceof Promise) {
+            returnValue = await returnValue;
+        }
+        assertHelper(returnValue);
+        yield item;
     }
-    (0, import_type_guards.assert)(returnValue);
-    yield item;
-  }
 }
 async function* async(iterable, predicate) {
-  let index = 0;
-  for await (const item of iterable) {
-    let returnValue = predicate(item, index++);
-    if (returnValue instanceof Promise) {
-      returnValue = await returnValue;
+    let index = 0;
+    for await (const item of iterable) {
+        let returnValue = predicate(item, index++);
+        if (returnValue instanceof Promise) {
+            returnValue = await returnValue;
+        }
+        assertHelper(returnValue);
+        yield item;
     }
-    (0, import_type_guards.assert)(returnValue);
-    yield item;
-  }
 }

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

@@ -1,53 +1,33 @@
-"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 batch_exports = {};
-__export(batch_exports, {
-  batchAsync: () => batchAsync
-});
-module.exports = __toCommonJS(batch_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-function batchAsync(iterable, size) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, size) : sync(iterable, size);
+import { isAsyncIterable } from './is-async-iterable.js';
+export function batchAsync(iterable, size) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, size)
+        : sync(iterable, size);
 }
+// eslint-disable-next-line @typescript-eslint/require-await
 async function* sync(iterable, size) {
-  let buffer = [];
-  for (const item of iterable) {
-    buffer.push(item);
-    if (buffer.length >= size) {
-      yield buffer;
-      buffer = [];
+    let buffer = [];
+    for (const item of iterable) {
+        buffer.push(item);
+        if (buffer.length >= size) {
+            yield buffer;
+            buffer = [];
+        }
+    }
+    if (buffer.length > 0) {
+        yield buffer;
     }
-  }
-  if (buffer.length > 0) {
-    yield buffer;
-  }
 }
 async function* async(iterable, size) {
-  let buffer = [];
-  for await (const item of iterable) {
-    buffer.push(item);
-    if (buffer.length >= size) {
-      yield buffer;
-      buffer = [];
+    let buffer = [];
+    for await (const item of iterable) {
+        buffer.push(item);
+        if (buffer.length >= size) {
+            yield buffer;
+            buffer = [];
+        }
+    }
+    if (buffer.length > 0) {
+        yield buffer;
     }
-  }
-  if (buffer.length > 0) {
-    yield buffer;
-  }
 }

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

@@ -1,70 +1,53 @@
-"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 buffer_exports = {};
-__export(buffer_exports, {
-  bufferAsync: () => bufferAsync
-});
-module.exports = __toCommonJS(buffer_exports);
-var import_token = require("../../cancellation/token.js");
-var import_circular_buffer = require("../../data-structures/circular-buffer.js");
-var import_object = require("../object/object.js");
-var import_take_until = require("./take-until.js");
-async function* bufferAsync(iterable, size) {
-  const buffer = new import_circular_buffer.CircularBuffer(Math.max(1, size));
-  const consumerEndedToken = new import_token.CancellationToken();
-  let consumerHasError = false;
-  let consumerError;
-  void (async () => {
-    try {
-      for await (const item of (0, import_take_until.takeUntilAsync)(iterable, consumerEndedToken)) {
-        buffer.add({ end: false, value: item });
-        if (buffer.isFull) {
-          await buffer.$onFreeSlots;
+import { CancellationToken } from '../../cancellation/token.js';
+import { CircularBuffer } from '../../data-structures/circular-buffer.js';
+import { hasOwnProperty } from '../object/object.js';
+import { takeUntilAsync } from './take-until.js';
+// eslint-disable-next-line max-lines-per-function, max-statements
+export async function* bufferAsync(iterable, size) {
+    const buffer = new CircularBuffer(Math.max(1, size));
+    const consumerEndedToken = new CancellationToken();
+    let consumerHasError = false;
+    let consumerError;
+    void (async () => {
+        try {
+            for await (const item of takeUntilAsync(iterable, consumerEndedToken)) {
+                buffer.add({ end: false, value: item });
+                if (buffer.isFull) {
+                    await buffer.$onFreeSlots;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (consumerHasError) {
+                    throw consumerError;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (consumerEndedToken.isSet) {
+                    return;
+                }
+            }
+            buffer.add({ end: true });
         }
-        if (consumerHasError) {
-          throw consumerError;
+        catch (error) {
+            buffer.add({ end: true, error: error });
         }
-        if (consumerEndedToken.isSet) {
-          return;
+    })();
+    try {
+        for await (const item of buffer.consumeAsync()) {
+            if (item.end) {
+                if (hasOwnProperty(item, 'error')) {
+                    throw item.error;
+                }
+                break;
+            }
+            yield item.value;
         }
-      }
-      buffer.add({ end: true });
-    } catch (error) {
-      buffer.add({ end: true, error });
     }
-  })();
-  try {
-    for await (const item of buffer.consumeAsync()) {
-      if (item.end) {
-        if ((0, import_object.hasOwnProperty)(item, "error")) {
-          throw item.error;
-        }
-        break;
-      }
-      yield item.value;
+    catch (error) {
+        consumerHasError = true;
+        consumerError = error;
+        throw error;
+    }
+    finally {
+        consumerEndedToken.set();
+        buffer.clear();
     }
-  } catch (error) {
-    consumerHasError = true;
-    consumerError = error;
-    throw error;
-  } finally {
-    consumerEndedToken.set();
-    buffer.clear();
-  }
 }

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

@@ -1,28 +1,6 @@
-"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 concat_exports = {};
-__export(concat_exports, {
-  concatAsync: () => concatAsync
-});
-module.exports = __toCommonJS(concat_exports);
-async function* concatAsync(...iterables) {
-  for (const iterable of iterables) {
-    yield* iterable;
-  }
+// eslint-disable-next-line @typescript-eslint/require-await
+export async function* concatAsync(...iterables) {
+    for (const iterable of iterables) {
+        yield* iterable;
+    }
 }

package/utils/async-iterable-helpers/default-if-empty.js

@@ -1,33 +1,10 @@
-"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 default_if_empty_exports = {};
-__export(default_if_empty_exports, {
-  defaultIfEmptyAsync: () => defaultIfEmptyAsync
-});
-module.exports = __toCommonJS(default_if_empty_exports);
-async function* defaultIfEmptyAsync(iterable, defaultValue) {
-  let empty = true;
-  for await (const item of iterable) {
-    empty = false;
-    yield item;
-  }
-  if (empty) {
-    yield defaultValue;
-  }
+export async function* defaultIfEmptyAsync(iterable, defaultValue) {
+    let empty = true;
+    for await (const item of iterable) {
+        empty = false;
+        yield item;
+    }
+    if (empty) {
+        yield defaultValue;
+    }
 }

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

@@ -1,27 +1,4 @@
-"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_exports = {};
-__export(deferred_exports, {
-  deferredAsyncIterable: () => deferredAsyncIterable
-});
-module.exports = __toCommonJS(deferred_exports);
-async function* deferredAsyncIterable(source) {
-  const iterable = await source();
-  yield* iterable;
+export async function* deferredAsyncIterable(source) {
+    const iterable = await source();
+    yield* iterable;
 }

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

@@ -1,52 +1,28 @@
-"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 difference_exports = {};
-__export(difference_exports, {
-  differenceAsync: () => differenceAsync,
-  differenceManyAsync: () => differenceManyAsync
-});
-module.exports = __toCommonJS(difference_exports);
-var import_concat = require("./concat.js");
-var import_map = require("./map.js");
-var import_to_array = require("./to-array.js");
-async function* differenceAsync(baseIterable, iterable, selector = (item) => item) {
-  const diffItems = (0, import_map.mapAsync)(iterable, selector);
-  const diffItemsArray = await (0, import_to_array.toArrayAsync)(diffItems);
-  const diffItemsSet = new Set(diffItemsArray);
-  let index = 0;
-  for await (const item of baseIterable) {
-    const selected = await selector(item, index++);
-    if (!diffItemsSet.has(selected)) {
-      yield item;
+import { concatAsync } from './concat.js';
+import { mapAsync } from './map.js';
+import { toArrayAsync } from './to-array.js';
+export async function* differenceAsync(baseIterable, iterable, selector = (item) => item) {
+    const diffItems = mapAsync(iterable, selector);
+    const diffItemsArray = await toArrayAsync(diffItems);
+    const diffItemsSet = new Set(diffItemsArray);
+    let index = 0;
+    for await (const item of baseIterable) {
+        const selected = await selector(item, index++);
+        if (!diffItemsSet.has(selected)) {
+            yield item;
+        }
     }
-  }
 }
-async function* differenceManyAsync(baseIterable, iterables, selector = (item) => item) {
-  const items = (0, import_concat.concatAsync)(...iterables);
-  const diffItems = (0, import_map.mapAsync)(items, selector);
-  const diffItemsArray = await (0, import_to_array.toArrayAsync)(diffItems);
-  const diffItemsSet = new Set(diffItemsArray);
-  let index = 0;
-  for await (const item of baseIterable) {
-    const selected = selector(item, index++);
-    if (!diffItemsSet.has(selected)) {
-      yield item;
+export async function* differenceManyAsync(baseIterable, iterables, selector = (item) => item) {
+    const items = concatAsync(...iterables);
+    const diffItems = mapAsync(items, selector);
+    const diffItemsArray = await toArrayAsync(diffItems);
+    const diffItemsSet = new Set(diffItemsArray);
+    let index = 0;
+    for await (const item of baseIterable) {
+        const selected = selector(item, index++);
+        if (!diffItemsSet.has(selected)) {
+            yield item;
+        }
     }
-  }
 }

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

@@ -1,51 +1,30 @@
-"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 distinct_exports = {};
-__export(distinct_exports, {
-  distinctAsync: () => distinctAsync
-});
-module.exports = __toCommonJS(distinct_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-function distinctAsync(iterable, selector = (item) => item) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, selector) : sync(iterable, selector);
+import { isAsyncIterable } from './is-async-iterable.js';
+export function distinctAsync(iterable, selector = (item) => item) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, selector)
+        : sync(iterable, selector);
 }
 async function* sync(iterable, selector) {
-  const items = /* @__PURE__ */ new Set();
-  let index = 0;
-  for (const item of iterable) {
-    const returnValue = selector(item, index++);
-    const selection = returnValue instanceof Promise ? await returnValue : returnValue;
-    if (!items.has(selection)) {
-      items.add(selection);
-      yield item;
+    const items = new Set();
+    let index = 0;
+    for (const item of iterable) {
+        const returnValue = selector(item, index++);
+        const selection = (returnValue instanceof Promise) ? await returnValue : returnValue;
+        if (!items.has(selection)) {
+            items.add(selection);
+            yield item;
+        }
     }
-  }
 }
 async function* async(iterable, selector) {
-  const items = /* @__PURE__ */ new Set();
-  let index = 0;
-  for await (const item of iterable) {
-    const returnValue = selector(item, index++);
-    const selection = returnValue instanceof Promise ? await returnValue : returnValue;
-    if (!items.has(selection)) {
-      items.add(selection);
-      yield item;
+    const items = new Set();
+    let index = 0;
+    for await (const item of iterable) {
+        const returnValue = selector(item, index++);
+        const selection = (returnValue instanceof Promise) ? await returnValue : returnValue;
+        if (!items.has(selection)) {
+            items.add(selection);
+            yield item;
+        }
     }
-  }
 }

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

@@ -1,27 +1,5 @@
-"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 drain_exports = {};
-__export(drain_exports, {
-  drainAsync: () => drainAsync
-});
-module.exports = __toCommonJS(drain_exports);
-async function drainAsync(iterable) {
-  for await (const _item of iterable) {
-  }
+export async function drainAsync(iterable) {
+    for await (const _item of iterable) {
+        // just drain
+    }
 }

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

@@ -1,51 +1,30 @@
-"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 filter_exports = {};
-__export(filter_exports, {
-  filterAsync: () => filterAsync
-});
-module.exports = __toCommonJS(filter_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-function filterAsync(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 filterAsync(iterable, predicate) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, predicate)
+        : sync(iterable, predicate);
 }
 async function* sync(iterable, predicate) {
-  let index = 0;
-  for (const item of iterable) {
-    let matches = predicate(item, index++);
-    if (matches instanceof Promise) {
-      matches = await matches;
+    let index = 0;
+    for (const item of iterable) {
+        let matches = predicate(item, index++);
+        if (matches instanceof Promise) {
+            matches = await matches;
+        }
+        if (matches) {
+            yield item;
+        }
     }
-    if (matches) {
-      yield item;
-    }
-  }
 }
 async function* async(iterable, predicate) {
-  let index = 0;
-  for await (const item of iterable) {
-    let matches = predicate(item, index++);
-    if (matches instanceof Promise) {
-      matches = await matches;
-    }
-    if (matches) {
-      yield item;
+    let index = 0;
+    for await (const item of iterable) {
+        let matches = predicate(item, index++);
+        if (matches instanceof Promise) {
+            matches = await matches;
+        }
+        if (matches) {
+            yield item;
+        }
     }
-  }
 }