@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/utils/array/array-backtracker.js

@@ -1,47 +1,70 @@
-import { BehaviorSubject } from 'rxjs';
-import { differenceSets } from '../set.js';
-import { isDefined } from '../type-guards.js';
-export class ArrayBacktracker {
-    recordMap;
-    recordMapSubject;
-    currentValues;
-    get record() {
-        return this.recordMap;
+"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 array_backtracker_exports = {};
+__export(array_backtracker_exports, {
+  ArrayBacktracker: () => ArrayBacktracker
+});
+module.exports = __toCommonJS(array_backtracker_exports);
+var import_rxjs = require("rxjs");
+var import_set = require("../set.js");
+var import_type_guards = require("../type-guards.js");
+class ArrayBacktracker {
+  recordMap;
+  recordMapSubject;
+  currentValues;
+  get record() {
+    return this.recordMap;
+  }
+  record$;
+  constructor(array) {
+    this.recordMap = /* @__PURE__ */ new Map();
+    this.recordMapSubject = new import_rxjs.BehaviorSubject(this.recordMap);
+    this.currentValues = /* @__PURE__ */ new Set();
+    this.record$ = this.recordMapSubject.asObservable();
+    if ((0, import_type_guards.isDefined)(array)) {
+      this.track(array);
     }
-    record$;
-    constructor(array) {
-        this.recordMap = new Map();
-        this.recordMapSubject = new BehaviorSubject(this.recordMap);
-        this.currentValues = new Set();
-        this.record$ = this.recordMapSubject.asObservable();
-        if (isDefined(array)) {
-            this.track(array);
-        }
+  }
+  /**
+   * gets a clone of the current record
+   */
+  getRecord() {
+    return new Map(this.recordMap);
+  }
+  track(array) {
+    const newValues = new Set(array);
+    const added = (0, import_set.differenceSets)(newValues, this.currentValues);
+    const removed = (0, import_set.differenceSets)(this.currentValues, newValues);
+    if (added.length == 0 && removed.length == 0) {
+      return;
     }
-    /**
-     * gets a clone of the current record
-     */
-    getRecord() {
-        return new Map(this.recordMap);
+    for (const value of added) {
+      this.recordMap.set(value, true);
     }
-    track(array) {
-        const newValues = new Set(array);
-        const added = differenceSets(newValues, this.currentValues);
-        const removed = differenceSets(this.currentValues, newValues);
-        if ((added.length == 0) && (removed.length == 0)) {
-            return;
-        }
-        for (const value of added) {
-            this.recordMap.set(value, true);
-        }
-        for (const value of removed) {
-            this.recordMap.set(value, false);
-        }
-        this.currentValues = newValues;
-        this.recordMapSubject.next(this.recordMap);
-    }
-    clear() {
-        this.recordMap.clear();
-        this.recordMapSubject.next(this.recordMap);
+    for (const value of removed) {
+      this.recordMap.set(value, false);
     }
+    this.currentValues = newValues;
+    this.recordMapSubject.next(this.recordMap);
+  }
+  clear() {
+    this.recordMap.clear();
+    this.recordMapSubject.next(this.recordMap);
+  }
 }

package/utils/array/array.js

@@ -1,85 +1,88 @@
-import { distinct as iterableDistinct } from '../iterable-helpers/distinct.js';
-import { randomInt } from '../math.js';
-import { isArray, isDefined } from '../type-guards.js';
-export function toArray(value) {
-    return isArray(value) ? value : [value];
+"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 array_exports = {};
+__export(array_exports, {
+  createArray: () => createArray,
+  distinct: () => distinct,
+  extractValueOfArrayIfSingleElement: () => extractValueOfArrayIfSingleElement,
+  randomItem: () => randomItem,
+  randomItems: () => randomItems,
+  shuffle: () => shuffle,
+  toArray: () => toArray,
+  toArrayCopy: () => toArrayCopy
+});
+module.exports = __toCommonJS(array_exports);
+var import_distinct = require("../iterable-helpers/distinct.js");
+var import_math = require("../math.js");
+var import_type_guards = require("../type-guards.js");
+function toArray(value) {
+  return (0, import_type_guards.isArray)(value) ? value : [value];
 }
-/**
- * Return copy of value, if it is an array, otherwise puts the single value into an array.
- */
-export function toArrayCopy(value) {
-    return isArray(value) ? [...value] : [value];
+function toArrayCopy(value) {
+  return (0, import_type_guards.isArray)(value) ? [...value] : [value];
 }
-export function extractValueOfArrayIfSingleElement(value) {
-    if (isArray(value) && (value.length == 1)) {
-        return value[0];
-    }
-    return value;
+function extractValueOfArrayIfSingleElement(value) {
+  if ((0, import_type_guards.isArray)(value) && value.length == 1) {
+    return value[0];
+  }
+  return value;
 }
-export function distinct(values, selector) {
-    return [...(isDefined(selector) ? iterableDistinct(values, selector) : new Set(values))];
+function distinct(values, selector) {
+  return [...(0, import_type_guards.isDefined)(selector) ? (0, import_distinct.distinct)(values, selector) : new Set(values)];
 }
-/**
- * creates a new array of specified length and fills it with values from the specified value provider function
- * @param length length of the new array
- * @param valueProvider provider function for the array values
- * @returns created array
- */
-export function createArray(length, valueProvider) {
-    const arr = [];
-    arr.length = length;
-    return arr.fill(undefined).map((_, index) => valueProvider(index));
+function createArray(length, valueProvider) {
+  const arr = [];
+  arr.length = length;
+  return arr.fill(void 0).map((_, index) => valueProvider(index));
 }
-/**
- * shuffles items using "The modern version of the Fisher–Yates shuffle"
- * @param items items to shuffle
- * @returns shuffled items
- */
-export function shuffle(items) {
-    const cloned = [...items];
-    for (let i = 0; i < cloned.length; i++) {
-        const j = randomInt(i, cloned.length - 1);
-        [cloned[i], cloned[j]] = [cloned[j], cloned[i]];
-    }
-    return cloned;
+function shuffle(items) {
+  const cloned = [...items];
+  for (let i = 0; i < cloned.length; i++) {
+    const j = (0, import_math.randomInt)(i, cloned.length - 1);
+    [cloned[i], cloned[j]] = [cloned[j], cloned[i]];
+  }
+  return cloned;
 }
-/**
- * picks a random item from specified array
- * @param array array to pick random item from
- * @param options options
- * @returns random item
- */
-export function randomItem(array, { min, max } = {}) {
-    const _min = isDefined(min) ? Math.max(min, 0) : 0;
-    const _max = isDefined(max) ? Math.min(max, array.length - 1) : array.length - 1;
-    const index = randomInt(_min, _max);
-    return array[index];
+function randomItem(array, { min, max } = {}) {
+  const _min = (0, import_type_guards.isDefined)(min) ? Math.max(min, 0) : 0;
+  const _max = (0, import_type_guards.isDefined)(max) ? Math.min(max, array.length - 1) : array.length - 1;
+  const index = (0, import_math.randomInt)(_min, _max);
+  return array[index];
 }
-/**
- * picks random items from specified array
- * @param array array to pick random items from
- * @param count count of items to pick
- * @param allowDuplicates allow picking an item multiple times - required when count is larger than array length
- * @returns random items
- */
-export function randomItems(array, count, allowDuplicates = false) {
-    if (allowDuplicates) {
-        return createArray(count, () => array[randomInt(0, array.length - 1)]);
-    }
-    if (count > array.length) {
-        throw new Error('count larger than length of array without allowing duplicates');
-    }
-    if (count >= (array.length / 2)) {
-        return shuffle(array).slice(0, count);
+function randomItems(array, count, allowDuplicates = false) {
+  if (allowDuplicates) {
+    return createArray(count, () => array[(0, import_math.randomInt)(0, array.length - 1)]);
+  }
+  if (count > array.length) {
+    throw new Error("count larger than length of array without allowing duplicates");
+  }
+  if (count >= array.length / 2) {
+    return shuffle(array).slice(0, count);
+  }
+  const taken = /* @__PURE__ */ new Set();
+  return createArray(count, () => {
+    while (true) {
+      const index = (0, import_math.randomInt)(0, array.length - 1);
+      if (!taken.has(index)) {
+        taken.add(index);
+        return array[index];
+      }
     }
-    const taken = new Set();
-    return createArray(count, () => {
-        while (true) {
-            const index = randomInt(0, array.length - 1);
-            if (!taken.has(index)) {
-                taken.add(index);
-                return array[index];
-            }
-        }
-    });
+  });
 }

package/utils/array/index.js

@@ -1,2 +1,19 @@
-export * from './array.js';
-export * from './array-backtracker.js';
+"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 array_exports = {};
+module.exports = __toCommonJS(array_exports);
+__reExport(array_exports, require("./array.js"), module.exports);
+__reExport(array_exports, require("./array-backtracker.js"), module.exports);

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

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

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

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

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

@@ -1,29 +1,50 @@
-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);
+"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);
 }
 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;
-        }
-        assertHelper(returnValue);
-        yield item;
+  let index = 0;
+  for (const item of iterable) {
+    let returnValue = predicate(item, index++);
+    if (returnValue instanceof Promise) {
+      returnValue = await returnValue;
     }
+    (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;
-        }
-        assertHelper(returnValue);
-        yield item;
+  let index = 0;
+  for await (const item of iterable) {
+    let returnValue = predicate(item, index++);
+    if (returnValue instanceof Promise) {
+      returnValue = await returnValue;
     }
+    (0, import_type_guards.assert)(returnValue);
+    yield item;
+  }
 }

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

@@ -1,33 +1,53 @@
-import { isAsyncIterable } from './is-async-iterable.js';
-export function batchAsync(iterable, size) {
-    return isAsyncIterable(iterable)
-        ? async(iterable, size)
-        : sync(iterable, size);
+"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);
 }
-// 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 = [];
-        }
-    }
-    if (buffer.length > 0) {
-        yield buffer;
+  let buffer = [];
+  for (const item of iterable) {
+    buffer.push(item);
+    if (buffer.length >= size) {
+      yield buffer;
+      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 = [];
-        }
-    }
-    if (buffer.length > 0) {
-        yield 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;
+  }
 }