@tstdl/base 0.87.13 → 0.88.0-alpha1

package/utils/async-iterable-helpers/last-or-default.js

@@ -1,37 +1,14 @@
-"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 last_or_default_exports = {};
-__export(last_or_default_exports, {
-  lastOrDefaultAsync: () => lastOrDefaultAsync
-});
-module.exports = __toCommonJS(last_or_default_exports);
-var import_filter = require("./filter.js");
-async function lastOrDefaultAsync(iterable, defaultValue, predicate) {
-  const source = predicate == void 0 ? iterable : (0, import_filter.filterAsync)(iterable, predicate);
-  let hasLastItem = false;
-  let lastItem;
-  for await (const item of source) {
-    hasLastItem = true;
-    lastItem = item;
-  }
-  if (hasLastItem) {
-    return lastItem;
-  }
-  return defaultValue;
+import { filterAsync } from './filter.js';
+export async function lastOrDefaultAsync(iterable, defaultValue, predicate) {
+    const source = (predicate == undefined) ? iterable : filterAsync(iterable, predicate);
+    let hasLastItem = false;
+    let lastItem;
+    for await (const item of source) {
+        hasLastItem = true;
+        lastItem = item;
+    }
+    if (hasLastItem) {
+        return lastItem; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    }
+    return defaultValue;
 }

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

@@ -1,37 +1,14 @@
-"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 last_exports = {};
-__export(last_exports, {
-  lastAsync: () => lastAsync
-});
-module.exports = __toCommonJS(last_exports);
-var import_filter = require("./filter.js");
-async function lastAsync(iterable, predicate) {
-  const source = predicate == void 0 ? iterable : (0, import_filter.filterAsync)(iterable, predicate);
-  let hasLastItem = false;
-  let lastItem;
-  for await (const item of source) {
-    hasLastItem = true;
-    lastItem = item;
-  }
-  if (hasLastItem) {
-    return lastItem;
-  }
-  throw new Error("iterable was either empty or no element matched predicate");
+import { filterAsync } from './filter.js';
+export async function lastAsync(iterable, predicate) {
+    const source = (predicate == undefined) ? iterable : filterAsync(iterable, predicate);
+    let hasLastItem = false;
+    let lastItem;
+    for await (const item of source) {
+        hasLastItem = true;
+        lastItem = item;
+    }
+    if (hasLastItem) {
+        return lastItem; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    }
+    throw new Error('iterable was either empty or no element matched predicate');
 }

package/utils/async-iterable-helpers/map-many.js

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

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

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

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

@@ -1,47 +1,26 @@
-"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 materialize_exports = {};
-__export(materialize_exports, {
-  materializeAsync: () => materializeAsync
-});
-module.exports = __toCommonJS(materialize_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-var import_to_array = require("./to-array.js");
-function materializeAsync(iterable) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable) : sync(iterable);
+import { isAsyncIterable } from './is-async-iterable.js';
+import { toArrayAsync } from './to-array.js';
+export function materializeAsync(iterable) {
+    return (isAsyncIterable(iterable))
+        ? async(iterable)
+        : sync(iterable);
 }
 function sync(iterable) {
-  const materialized = [...iterable];
-  const asyncIterable = {
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async *[Symbol.asyncIterator]() {
-      yield* materialized;
-    }
-  };
-  return asyncIterable;
+    const materialized = [...iterable];
+    const asyncIterable = {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        async *[Symbol.asyncIterator]() {
+            yield* materialized;
+        }
+    };
+    return asyncIterable;
 }
 function async(iterable) {
-  const materializedPromise = (0, import_to_array.toArrayAsync)(iterable);
-  const asyncIterable = {
-    async *[Symbol.asyncIterator]() {
-      yield* await materializedPromise;
-    }
-  };
-  return asyncIterable;
+    const materializedPromise = toArrayAsync(iterable);
+    const asyncIterable = {
+        async *[Symbol.asyncIterator]() {
+            yield* await materializedPromise;
+        }
+    };
+    return asyncIterable;
 }

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

@@ -1,63 +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 metadata_exports = {};
-__export(metadata_exports, {
-  metadataAsync: () => metadataAsync
-});
-module.exports = __toCommonJS(metadata_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-function metadataAsync(iterable) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable) : sync(iterable);
+import { isAsyncIterable } from './is-async-iterable.js';
+export function metadataAsync(iterable) {
+    return (isAsyncIterable(iterable))
+        ? async(iterable)
+        : sync(iterable);
 }
+// eslint-disable-next-line @typescript-eslint/require-await
 async function* sync(iterable) {
-  let index = 0;
-  let isFirst = true;
-  let hasPrevious = false;
-  let previous;
-  for (const item of iterable) {
+    let index = 0;
+    let isFirst = true;
+    let hasPrevious = false;
+    let previous;
+    for (const item of iterable) {
+        if (hasPrevious) {
+            yield { index: index++, isFirst, isLast: false, value: previous };
+            isFirst = false;
+        }
+        else {
+            hasPrevious = true;
+        }
+        previous = item;
+    }
     if (hasPrevious) {
-      yield { index: index++, isFirst, isLast: false, value: previous };
-      isFirst = false;
-    } else {
-      hasPrevious = true;
+        yield { index: index++, isFirst, isLast: true, value: previous };
     }
-    previous = item;
-  }
-  if (hasPrevious) {
-    yield { index: index++, isFirst, isLast: true, value: previous };
-  }
 }
 async function* async(iterable) {
-  let index = 0;
-  let isFirst = true;
-  let hasPrevious = false;
-  let previous;
-  for await (const item of iterable) {
+    let index = 0;
+    let isFirst = true;
+    let hasPrevious = false;
+    let previous;
+    for await (const item of iterable) {
+        if (hasPrevious) {
+            yield { index: index++, isFirst, isLast: false, value: previous };
+            isFirst = false;
+        }
+        else {
+            hasPrevious = true;
+        }
+        previous = item;
+    }
     if (hasPrevious) {
-      yield { index: index++, isFirst, isLast: false, value: previous };
-      isFirst = false;
-    } else {
-      hasPrevious = true;
+        yield { index: index++, isFirst, isLast: true, value: previous };
     }
-    previous = item;
-  }
-  if (hasPrevious) {
-    yield { index: index++, isFirst, isLast: true, value: previous };
-  }
 }

package/utils/async-iterable-helpers/multiplex.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 multiplex_exports = {};
-__export(multiplex_exports, {
-  multiplexAsync: () => multiplexAsync
-});
-module.exports = __toCommonJS(multiplex_exports);
-var import_array = require("../array/array.js");
-var import_feedable_async_iterable = require("../feedable-async-iterable.js");
-function multiplexAsync(iterable, count, bufferSize) {
-  if (bufferSize <= 0) {
-    throw new Error("bufferSize must be greater than 0");
-  }
-  const feedableIterables = (0, import_array.createArray)(count, () => new import_feedable_async_iterable.FeedableAsyncIterable());
-  multiplexTo(iterable, feedableIterables, bufferSize);
-  return feedableIterables;
+import { createArray } from '../array/array.js';
+import { FeedableAsyncIterable } from '../feedable-async-iterable.js';
+export function multiplexAsync(iterable, count, bufferSize) {
+    if (bufferSize <= 0) {
+        throw new Error('bufferSize must be greater than 0');
+    }
+    const feedableIterables = createArray(count, () => new FeedableAsyncIterable());
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    multiplexTo(iterable, feedableIterables, bufferSize);
+    return feedableIterables;
 }
 async function multiplexTo(input, outputs, bufferSize) {
-  try {
-    for await (const item of input) {
-      await waitForDrain(outputs, bufferSize);
-      outputs.forEach((feedableIterable) => feedableIterable.feed(item));
+    try {
+        for await (const item of input) {
+            await waitForDrain(outputs, bufferSize);
+            outputs.forEach((feedableIterable) => feedableIterable.feed(item));
+        }
+        outputs.forEach((feedableIterable) => feedableIterable.end());
+    }
+    catch (error) {
+        outputs.forEach((feedableIterable) => feedableIterable.throw(error));
     }
-    outputs.forEach((feedableIterable) => feedableIterable.end());
-  } catch (error) {
-    outputs.forEach((feedableIterable) => feedableIterable.throw(error));
-  }
 }
 async function waitForDrain(feedableIterables, bufferSize) {
-  for (const feedableIterable of feedableIterables) {
-    while (feedableIterable.bufferSize >= bufferSize) {
-      await feedableIterable.$read;
+    for (const feedableIterable of feedableIterables) {
+        while (feedableIterable.bufferSize >= bufferSize) {
+            await feedableIterable.$read;
+        }
     }
-  }
 }

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

@@ -1,56 +1,34 @@
-"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 observable_iterable_exports = {};
-__export(observable_iterable_exports, {
-  observableAsyncIterable: () => observableAsyncIterable
-});
-module.exports = __toCommonJS(observable_iterable_exports);
-var import_token = require("../../cancellation/token.js");
-var import_rxjs = require("rxjs");
-var import_observable_array = require("../../collections/observable/observable-array.js");
-async function* observableAsyncIterable(observable) {
-  const buffer = new import_observable_array.ObservableArray();
-  const completeToken = new import_token.CancellationToken();
-  const errorToken = new import_token.CancellationToken();
-  let error;
-  const subscription = observable.subscribe({
-    next: (value) => buffer.add(value),
-    complete: () => completeToken.set(),
-    error: (_error) => {
-      error = _error;
-      errorToken.set();
+import { CancellationToken } from '../../cancellation/token.js';
+import { merge, take } from 'rxjs';
+import { ObservableArray } from '../../collections/observable/observable-array.js';
+export async function* observableAsyncIterable(observable) {
+    const buffer = new ObservableArray();
+    const completeToken = new CancellationToken();
+    const errorToken = new CancellationToken();
+    let error;
+    const subscription = observable.subscribe({
+        next: (value) => buffer.add(value),
+        complete: () => completeToken.set(),
+        error: (_error) => {
+            error = _error;
+            errorToken.set();
+        }
+    });
+    try {
+        while (buffer.length > 0 || !completeToken.isSet) {
+            if (buffer.length == 0) {
+                await merge(buffer.add$, completeToken.set$, errorToken.set$).pipe(take(1)).toPromise();
+            }
+            while (buffer.length > 0) {
+                const item = buffer.removeFirst();
+                yield item;
+            }
+            if (errorToken.isSet) {
+                throw error;
+            }
+        }
     }
-  });
-  try {
-    while (buffer.length > 0 || !completeToken.isSet) {
-      if (buffer.length == 0) {
-        await (0, import_rxjs.merge)(buffer.add$, completeToken.set$, errorToken.set$).pipe((0, import_rxjs.take)(1)).toPromise();
-      }
-      while (buffer.length > 0) {
-        const item = buffer.removeFirst();
-        yield item;
-      }
-      if (errorToken.isSet) {
-        throw error;
-      }
+    finally {
+        subscription.unsubscribe();
     }
-  } finally {
-    subscription.unsubscribe();
-  }
 }

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

@@ -1,51 +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 pairwise_exports = {};
-__export(pairwise_exports, {
-  pairwiseAsync: () => pairwiseAsync
-});
-module.exports = __toCommonJS(pairwise_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-function pairwiseAsync(iterable) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable) : sync(iterable);
+import { isAsyncIterable } from './is-async-iterable.js';
+export function pairwiseAsync(iterable) {
+    return isAsyncIterable(iterable)
+        ? async(iterable)
+        : sync(iterable);
 }
+// eslint-disable-next-line @typescript-eslint/require-await
 async function* sync(iterable) {
-  let hasPrevious = false;
-  let previous;
-  for (const item of iterable) {
-    if (hasPrevious) {
-      yield [previous, item];
-    } else {
-      hasPrevious = true;
+    let hasPrevious = false;
+    let previous;
+    for (const item of iterable) {
+        if (hasPrevious) {
+            yield [previous, item];
+        }
+        else {
+            hasPrevious = true;
+        }
+        previous = item;
     }
-    previous = item;
-  }
 }
 async function* async(iterable) {
-  let hasPrevious = false;
-  let previous;
-  for await (const item of iterable) {
-    if (hasPrevious) {
-      yield [previous, item];
-    } else {
-      hasPrevious = true;
+    let hasPrevious = false;
+    let previous;
+    for await (const item of iterable) {
+        if (hasPrevious) {
+            yield [previous, item];
+        }
+        else {
+            hasPrevious = true;
+        }
+        previous = item;
     }
-    previous = item;
-  }
 }