@tstdl/base 0.85.14 → 0.86.0-beta2

package/enumerable/async-enumerable.js

@@ -1,262 +1,239 @@
-"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_enumerable_exports = {};
-__export(async_enumerable_exports, {
-  AsyncEnumerable: () => AsyncEnumerable
-});
-module.exports = __toCommonJS(async_enumerable_exports);
-var import_any_iterable_iterator = require("../utils/any-iterable-iterator.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_async_iterable_helpers = require("../utils/async-iterable-helpers/index.js");
-var import_observable_iterable = require("../utils/async-iterable-helpers/observable-iterable.js");
-var import_parallel = require("../utils/async-iterable-helpers/parallel/index.js");
-var import_iterable_helpers = require("../utils/iterable-helpers/index.js");
-var import_enumerable = require("./enumerable.js");
-class AsyncEnumerable {
-  source;
-  constructor(source) {
-    this.source = source;
-  }
-  static from(source) {
-    return new AsyncEnumerable(source);
-  }
-  static fromDeferred(source) {
-    const deferred = (0, import_async_iterable_helpers.deferredAsyncIterable)(source);
-    return new AsyncEnumerable(deferred);
-  }
-  static fromObservable(observable) {
-    const iterable = (0, import_observable_iterable.observableAsyncIterable)(observable);
-    return new AsyncEnumerable(iterable);
-  }
-  static fromRange(fromInclusive, toInclusive) {
-    const rangeIterable = (0, import_iterable_helpers.range)(fromInclusive, toInclusive);
-    return new AsyncEnumerable(rangeIterable);
-  }
-  assert(predicate) {
-    const asserted = (0, import_async_iterable_helpers.assertAsync)(this.source, predicate);
-    return new AsyncEnumerable(asserted);
-  }
-  async all(predicate) {
-    return (0, import_async_iterable_helpers.allAsync)(this.source, predicate);
-  }
-  async any(predicate) {
-    return (0, import_async_iterable_helpers.anyAsync)(this.source, predicate);
-  }
-  batch(size) {
-    const result = (0, import_async_iterable_helpers.batchAsync)(this.source, size);
-    return new AsyncEnumerable(result);
-  }
-  buffer(size) {
-    const result = (0, import_async_iterable_helpers.bufferAsync)(this.source, size);
-    return new AsyncEnumerable(result);
-  }
-  cast() {
-    return this;
-  }
-  concat(...iterables) {
-    const concatted = (0, import_async_iterable_helpers.concatAsync)(this.source, ...iterables);
-    return new AsyncEnumerable(concatted);
-  }
-  defaultIfEmpty(defaultValue) {
-    const result = (0, import_async_iterable_helpers.defaultIfEmptyAsync)(this.source, defaultValue);
-    return new AsyncEnumerable(result);
-  }
-  difference(iterable, selector) {
-    const result = (0, import_async_iterable_helpers.differenceAsync)(this.source, iterable, selector);
-    return new AsyncEnumerable(result);
-  }
-  differenceMany(iterables, selector) {
-    const result = (0, import_async_iterable_helpers.differenceManyAsync)(this.source, iterables, selector);
-    return new AsyncEnumerable(result);
-  }
-  distinct(selector) {
-    const result = (0, import_async_iterable_helpers.distinctAsync)(this.source, selector);
-    return new AsyncEnumerable(result);
-  }
-  async drain() {
-    await (0, import_async_iterable_helpers.drainAsync)(this.source);
-  }
-  async includes(value) {
-    return (0, import_async_iterable_helpers.includesAsync)(this.source, value);
-  }
-  filter(predicate) {
-    const filtered = (0, import_async_iterable_helpers.filterAsync)(this.source, predicate);
-    return new AsyncEnumerable(filtered);
-  }
-  filterNullOrUndefined() {
-    return this.filter((item) => (0, import_type_guards.isNotNullOrUndefined)(item));
-  }
-  async first(predicate) {
-    return (0, import_async_iterable_helpers.firstAsync)(this.source, predicate);
-  }
-  async firstOrDefault(defaultValue, predicate) {
-    return (0, import_async_iterable_helpers.firstOrDefaultAsync)(this.source, defaultValue, predicate);
-  }
-  forceCast() {
-    return this;
-  }
-  async forEach(func) {
-    await (0, import_async_iterable_helpers.forEachAsync)(this.source, func);
-  }
-  group(selector) {
-    const grouped = (0, import_async_iterable_helpers.groupAsync)(this.source, selector);
-    return new AsyncEnumerable(grouped);
-  }
-  groupSingle(selector) {
-    const grouped = (0, import_async_iterable_helpers.groupSingleAsync)(this.source, selector);
-    return new AsyncEnumerable(grouped);
-  }
-  async groupToMap(selector) {
-    return (0, import_async_iterable_helpers.groupToMapAsync)(this.source, selector);
-  }
-  async groupToSingleMap(selector) {
-    return (0, import_async_iterable_helpers.groupToSingleMapAsync)(this.source, selector);
-  }
-  tap(tapper) {
-    const iterator = (0, import_async_iterable_helpers.tapAsync)(this.source, tapper);
-    return new AsyncEnumerable(iterator);
-  }
-  interruptEvery(value) {
-    const interrupted = (0, import_async_iterable_helpers.interruptEveryAsync)(this.source, value);
-    return new AsyncEnumerable(interrupted);
-  }
-  interruptPerSecond(value) {
-    const interrupted = (0, import_async_iterable_helpers.interruptPerSecondAsync)(this.source, value);
-    return new AsyncEnumerable(interrupted);
-  }
-  async last(predicate) {
-    return (0, import_async_iterable_helpers.lastAsync)(this.source, predicate);
-  }
-  async lastOrDefault(defaultValue, predicate) {
-    return (0, import_async_iterable_helpers.lastOrDefaultAsync)(this.source, defaultValue, predicate);
-  }
-  map(mapper) {
-    const result = (0, import_async_iterable_helpers.mapAsync)(this.source, mapper);
-    return new AsyncEnumerable(result);
-  }
-  mapMany(mapper) {
-    const result = (0, import_async_iterable_helpers.mapManyAsync)(this.source, mapper);
-    return new AsyncEnumerable(result);
-  }
-  materialize() {
-    const materialized = (0, import_async_iterable_helpers.materializeAsync)(this.source);
-    return new AsyncEnumerable(materialized);
-  }
-  metadata() {
-    const metadated = (0, import_async_iterable_helpers.metadataAsync)(this.source);
-    return new AsyncEnumerable(metadated);
-  }
-  multiplex(count, bufferSize = 0) {
-    const iterables = (0, import_async_iterable_helpers.multiplexAsync)(this.source, count, bufferSize);
-    const enumerables = iterables.map((iterable) => new AsyncEnumerable(iterable));
-    return enumerables;
-  }
-  pairwise() {
-    const pairwised = (0, import_async_iterable_helpers.pairwiseAsync)(this.source);
-    return new AsyncEnumerable(pairwised);
-  }
-  async reduce(reducer, initialValue) {
-    return (0, import_async_iterable_helpers.reduceAsync)(this.source, reducer, initialValue);
-  }
-  retry(throwOnRetryFalse, predicate) {
-    const result = (0, import_async_iterable_helpers.retryAsync)(this.source, throwOnRetryFalse, predicate);
-    return new AsyncEnumerable(result);
-  }
-  async single(predicate) {
-    return (0, import_async_iterable_helpers.singleAsync)(this.source, predicate);
-  }
-  async singleOrDefault(defaultValue, predicate) {
-    return (0, import_async_iterable_helpers.singleOrDefaultAsync)(this.source, defaultValue, predicate);
-  }
-  skip(count) {
-    const skipped = (0, import_async_iterable_helpers.skipAsync)(this.source, count);
-    return new AsyncEnumerable(skipped);
-  }
-  sort(comparator) {
-    return AsyncEnumerable.fromDeferred(async () => (0, import_async_iterable_helpers.sortAsync)(this.source, comparator));
-  }
-  async sortToArray(comparator) {
-    return (0, import_async_iterable_helpers.sortAsync)(this.source, comparator);
-  }
-  take(count) {
-    const taken = (0, import_async_iterable_helpers.takeAsync)(this.source, count);
-    return new AsyncEnumerable(taken);
-  }
-  takeUntil(cancellationToken) {
-    const taken = (0, import_async_iterable_helpers.takeUntilAsync)(this.source, cancellationToken);
-    return new AsyncEnumerable(taken);
-  }
-  takeWhile(yieldLastOnFalse, predicate) {
-    const taken = (0, import_async_iterable_helpers.takeWhileAsync)(this.source, yieldLastOnFalse, predicate);
-    return new AsyncEnumerable(taken);
-  }
-  throttle(delayOrThrottleFunction) {
-    const result = (0, import_async_iterable_helpers.throttle)(this.source, delayOrThrottleFunction);
-    return new AsyncEnumerable(result);
-  }
-  async toArray() {
-    return (0, import_async_iterable_helpers.toArrayAsync)(this.source);
-  }
-  toAsync() {
-    return this;
-  }
-  toIterator() {
-    const iterator = (0, import_async_iterable_helpers.iterableToAsyncIterator)(this.source);
-    return iterator;
-  }
-  async toSet() {
-    const iterable = await this.toSync();
-    return new Set(iterable);
-  }
-  async toSync() {
-    const syncIterable = await (0, import_async_iterable_helpers.toSync)(this.source);
-    return import_enumerable.Enumerable.from(syncIterable);
-  }
-  while(predicate) {
-    const whiled = (0, import_async_iterable_helpers.whileAsync)(this.source, predicate);
-    return new AsyncEnumerable(whiled);
-  }
-  parallelFilter(concurrency, keepOrder, predicate) {
-    const result = (0, import_parallel.parallelFilter)(this.source, concurrency, keepOrder, predicate);
-    return new AsyncEnumerable(result);
-  }
-  async parallelForEach(concurrency, func) {
-    return (0, import_parallel.parallelForEach)(this.source, concurrency, func);
-  }
-  async parallelGroup(concurrency, selector) {
-    return (0, import_parallel.parallelGroup)(this.source, concurrency, selector);
-  }
-  parallelTap(concurrency, keepOrder, tapper) {
-    const result = (0, import_parallel.parallelTap)(this.source, concurrency, keepOrder, tapper);
-    return new AsyncEnumerable(result);
-  }
-  parallelMap(concurrency, keepOrder, func) {
-    const result = (0, import_parallel.parallelMap)(this.source, concurrency, keepOrder, func);
-    return new AsyncEnumerable(result);
-  }
-  [Symbol.asyncIterator]() {
-    if ((0, import_async_iterable_helpers.isAsyncIterableIterator)(this.source)) {
-      return this.source[Symbol.asyncIterator]();
-    }
-    if ((0, import_any_iterable_iterator.isAnyIterable)(this.source)) {
-      return (0, import_async_iterable_helpers.iterableToAsyncIterableIterator)(this.source);
-    }
-    throw new Error("source is neither iterable nor async-iterable");
-  }
+import { isAnyIterable } from '../utils/any-iterable-iterator.js';
+import { isNotNullOrUndefined } from '../utils/type-guards.js';
+import { allAsync, anyAsync, assertAsync, batchAsync, bufferAsync, concatAsync, defaultIfEmptyAsync, deferredAsyncIterable, differenceAsync, differenceManyAsync, distinctAsync, drainAsync, filterAsync, firstAsync, firstOrDefaultAsync, forEachAsync, groupAsync, groupSingleAsync, groupToMapAsync, groupToSingleMapAsync, includesAsync, interruptEveryAsync, interruptPerSecondAsync, isAsyncIterableIterator, iterableToAsyncIterableIterator, iterableToAsyncIterator, lastAsync, lastOrDefaultAsync, mapAsync, mapManyAsync, materializeAsync, metadataAsync, multiplexAsync, pairwiseAsync, reduceAsync, retryAsync, singleAsync, singleOrDefaultAsync, skipAsync, sortAsync, takeAsync, takeUntilAsync, takeWhileAsync, tapAsync, throttle, toArrayAsync, toSync, whileAsync } from '../utils/async-iterable-helpers/index.js';
+import { observableAsyncIterable } from '../utils/async-iterable-helpers/observable-iterable.js';
+import { parallelFilter, parallelForEach, parallelGroup, parallelMap, parallelTap } from '../utils/async-iterable-helpers/parallel/index.js';
+import { range } from '../utils/iterable-helpers/index.js';
+import { Enumerable } from './enumerable.js';
+export class AsyncEnumerable {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    static from(source) {
+        return new AsyncEnumerable(source);
+    }
+    static fromDeferred(source) {
+        const deferred = deferredAsyncIterable(source);
+        return new AsyncEnumerable(deferred);
+    }
+    static fromObservable(observable) {
+        const iterable = observableAsyncIterable(observable);
+        return new AsyncEnumerable(iterable);
+    }
+    static fromRange(fromInclusive, toInclusive) {
+        const rangeIterable = range(fromInclusive, toInclusive);
+        return new AsyncEnumerable(rangeIterable);
+    }
+    assert(predicate) {
+        const asserted = assertAsync(this.source, predicate);
+        return new AsyncEnumerable(asserted);
+    }
+    async all(predicate) {
+        return allAsync(this.source, predicate);
+    }
+    async any(predicate) {
+        return anyAsync(this.source, predicate);
+    }
+    batch(size) {
+        const result = batchAsync(this.source, size);
+        return new AsyncEnumerable(result);
+    }
+    buffer(size) {
+        const result = bufferAsync(this.source, size);
+        return new AsyncEnumerable(result);
+    }
+    cast() {
+        return this;
+    }
+    concat(...iterables) {
+        const concatted = concatAsync(this.source, ...iterables);
+        return new AsyncEnumerable(concatted);
+    }
+    defaultIfEmpty(defaultValue) {
+        const result = defaultIfEmptyAsync(this.source, defaultValue);
+        return new AsyncEnumerable(result);
+    }
+    difference(iterable, selector) {
+        const result = differenceAsync(this.source, iterable, selector);
+        return new AsyncEnumerable(result);
+    }
+    differenceMany(iterables, selector) {
+        const result = differenceManyAsync(this.source, iterables, selector);
+        return new AsyncEnumerable(result);
+    }
+    distinct(selector) {
+        const result = distinctAsync(this.source, selector);
+        return new AsyncEnumerable(result);
+    }
+    async drain() {
+        await drainAsync(this.source);
+    }
+    async includes(value) {
+        return includesAsync(this.source, value);
+    }
+    filter(predicate) {
+        const filtered = filterAsync(this.source, predicate);
+        return new AsyncEnumerable(filtered);
+    }
+    filterNullOrUndefined() {
+        return this.filter((item) => isNotNullOrUndefined(item));
+    }
+    async first(predicate) {
+        return firstAsync(this.source, predicate);
+    }
+    async firstOrDefault(defaultValue, predicate) {
+        return firstOrDefaultAsync(this.source, defaultValue, predicate);
+    }
+    forceCast() {
+        return this;
+    }
+    async forEach(func) {
+        await forEachAsync(this.source, func);
+    }
+    group(selector) {
+        const grouped = groupAsync(this.source, selector);
+        return new AsyncEnumerable(grouped);
+    }
+    groupSingle(selector) {
+        const grouped = groupSingleAsync(this.source, selector);
+        return new AsyncEnumerable(grouped);
+    }
+    async groupToMap(selector) {
+        return groupToMapAsync(this.source, selector);
+    }
+    async groupToSingleMap(selector) {
+        return groupToSingleMapAsync(this.source, selector);
+    }
+    tap(tapper) {
+        const iterator = tapAsync(this.source, tapper);
+        return new AsyncEnumerable(iterator);
+    }
+    interruptEvery(value) {
+        const interrupted = interruptEveryAsync(this.source, value);
+        return new AsyncEnumerable(interrupted);
+    }
+    interruptPerSecond(value) {
+        const interrupted = interruptPerSecondAsync(this.source, value);
+        return new AsyncEnumerable(interrupted);
+    }
+    async last(predicate) {
+        return lastAsync(this.source, predicate);
+    }
+    async lastOrDefault(defaultValue, predicate) {
+        return lastOrDefaultAsync(this.source, defaultValue, predicate);
+    }
+    map(mapper) {
+        const result = mapAsync(this.source, mapper);
+        return new AsyncEnumerable(result);
+    }
+    mapMany(mapper) {
+        const result = mapManyAsync(this.source, mapper);
+        return new AsyncEnumerable(result);
+    }
+    materialize() {
+        const materialized = materializeAsync(this.source);
+        return new AsyncEnumerable(materialized);
+    }
+    metadata() {
+        const metadated = metadataAsync(this.source);
+        return new AsyncEnumerable(metadated);
+    }
+    multiplex(count, bufferSize = 0) {
+        const iterables = multiplexAsync(this.source, count, bufferSize);
+        const enumerables = iterables.map((iterable) => new AsyncEnumerable(iterable));
+        return enumerables;
+    }
+    pairwise() {
+        const pairwised = pairwiseAsync(this.source);
+        return new AsyncEnumerable(pairwised);
+    }
+    async reduce(reducer, initialValue) {
+        return reduceAsync(this.source, reducer, initialValue);
+    }
+    retry(throwOnRetryFalse, predicate) {
+        const result = retryAsync(this.source, throwOnRetryFalse, predicate);
+        return new AsyncEnumerable(result);
+    }
+    async single(predicate) {
+        return singleAsync(this.source, predicate);
+    }
+    async singleOrDefault(defaultValue, predicate) {
+        return singleOrDefaultAsync(this.source, defaultValue, predicate);
+    }
+    skip(count) {
+        const skipped = skipAsync(this.source, count);
+        return new AsyncEnumerable(skipped);
+    }
+    sort(comparator) {
+        return AsyncEnumerable.fromDeferred(async () => sortAsync(this.source, comparator));
+    }
+    async sortToArray(comparator) {
+        return sortAsync(this.source, comparator);
+    }
+    take(count) {
+        const taken = takeAsync(this.source, count);
+        return new AsyncEnumerable(taken);
+    }
+    takeUntil(cancellationToken) {
+        const taken = takeUntilAsync(this.source, cancellationToken);
+        return new AsyncEnumerable(taken);
+    }
+    takeWhile(yieldLastOnFalse, predicate) {
+        const taken = takeWhileAsync(this.source, yieldLastOnFalse, predicate);
+        return new AsyncEnumerable(taken);
+    }
+    throttle(delayOrThrottleFunction) {
+        const result = throttle(this.source, delayOrThrottleFunction);
+        return new AsyncEnumerable(result);
+    }
+    async toArray() {
+        return toArrayAsync(this.source);
+    }
+    toAsync() {
+        return this;
+    }
+    toIterator() {
+        const iterator = iterableToAsyncIterator(this.source);
+        return iterator;
+    }
+    async toSet() {
+        const iterable = await this.toSync();
+        return new Set(iterable);
+    }
+    async toSync() {
+        const syncIterable = await toSync(this.source);
+        return Enumerable.from(syncIterable);
+    }
+    while(predicate) {
+        const whiled = whileAsync(this.source, predicate);
+        return new AsyncEnumerable(whiled);
+    }
+    parallelFilter(concurrency, keepOrder, predicate) {
+        const result = parallelFilter(this.source, concurrency, keepOrder, predicate);
+        return new AsyncEnumerable(result);
+    }
+    async parallelForEach(concurrency, func) {
+        return parallelForEach(this.source, concurrency, func);
+    }
+    async parallelGroup(concurrency, selector) {
+        return parallelGroup(this.source, concurrency, selector);
+    }
+    parallelTap(concurrency, keepOrder, tapper) {
+        const result = parallelTap(this.source, concurrency, keepOrder, tapper);
+        return new AsyncEnumerable(result);
+    }
+    parallelMap(concurrency, keepOrder, func) {
+        const result = parallelMap(this.source, concurrency, keepOrder, func);
+        return new AsyncEnumerable(result);
+    }
+    [Symbol.asyncIterator]() {
+        if (isAsyncIterableIterator(this.source)) {
+            return this.source[Symbol.asyncIterator]();
+        }
+        if (isAnyIterable(this.source)) {
+            return iterableToAsyncIterableIterator(this.source);
+        }
+        throw new Error('source is neither iterable nor async-iterable');
+    }
 }

package/enumerable/enumerable-methods.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 enumerable_methods_exports = {};
-module.exports = __toCommonJS(enumerable_methods_exports);
+export {};