@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/utils/feedable-async-iterable.js

@@ -1,51 +1,74 @@
-import { CircularBuffer } from '../data-structures/circular-buffer.js';
-import { firstValueFrom, Subject } from 'rxjs';
-import { CancellationToken } from './cancellation-token.js';
-export class FeedableAsyncIterable {
-    readSubject;
-    closedToken;
-    buffer;
-    get $read() {
-        return firstValueFrom(this.readSubject);
+"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 feedable_async_iterable_exports = {};
+__export(feedable_async_iterable_exports, {
+  FeedableAsyncIterable: () => FeedableAsyncIterable
+});
+module.exports = __toCommonJS(feedable_async_iterable_exports);
+var import_circular_buffer = require("../data-structures/circular-buffer.js");
+var import_rxjs = require("rxjs");
+var import_cancellation_token = require("./cancellation-token.js");
+class FeedableAsyncIterable {
+  readSubject;
+  closedToken;
+  buffer;
+  get $read() {
+    return (0, import_rxjs.firstValueFrom)(this.readSubject);
+  }
+  get $empty() {
+    return this.buffer.$onEmpty;
+  }
+  get closed() {
+    return this.closedToken.isSet;
+  }
+  get bufferSize() {
+    return this.buffer.size;
+  }
+  constructor() {
+    this.readSubject = new import_rxjs.Subject();
+    this.closedToken = new import_cancellation_token.CancellationToken();
+    this.buffer = new import_circular_buffer.CircularBuffer();
+  }
+  feed(item) {
+    if (this.closed) {
+      throw new Error("feedable is already closed");
     }
-    get $empty() {
-        return this.buffer.$onEmpty;
+    this.buffer.add({ item, error: void 0 });
+  }
+  end() {
+    this.closedToken.set();
+  }
+  throw(error) {
+    if (this.closed) {
+      throw new Error("feedable is already closed");
     }
-    get closed() {
-        return this.closedToken.isSet;
-    }
-    get bufferSize() {
-        return this.buffer.size;
-    }
-    constructor() {
-        this.readSubject = new Subject();
-        this.closedToken = new CancellationToken();
-        this.buffer = new CircularBuffer();
-    }
-    feed(item) {
-        if (this.closed) {
-            throw new Error('feedable is already closed');
-        }
-        this.buffer.add({ item, error: undefined });
-    }
-    end() {
-        this.closedToken.set();
-    }
-    throw(error) {
-        if (this.closed) {
-            throw new Error('feedable is already closed');
-        }
-        this.buffer.add({ item: undefined, error });
-        this.end();
-    }
-    async *[Symbol.asyncIterator]() {
-        const consumer = this.buffer.consumeAsync(this.closedToken, true);
-        for await (const entry of consumer) {
-            if (entry.error != undefined) {
-                throw entry.error;
-            }
-            yield entry.item;
-            this.readSubject.next();
-        }
+    this.buffer.add({ item: void 0, error });
+    this.end();
+  }
+  async *[Symbol.asyncIterator]() {
+    const consumer = this.buffer.consumeAsync(this.closedToken, true);
+    for await (const entry of consumer) {
+      if (entry.error != void 0) {
+        throw entry.error;
+      }
+      yield entry.item;
+      this.readSubject.next();
     }
+  }
 }

package/utils/file-reader.js

@@ -1,21 +1,47 @@
-import { DetailsError } from '../error/details.error.js';
-export async function readAsText(blob, encoding) {
-    return setup((reader) => reader.readAsText(blob, encoding));
+"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 file_reader_exports = {};
+__export(file_reader_exports, {
+  readAsArrayBuffer: () => readAsArrayBuffer,
+  readAsBinaryString: () => readAsBinaryString,
+  readAsDataUrl: () => readAsDataUrl,
+  readAsText: () => readAsText
+});
+module.exports = __toCommonJS(file_reader_exports);
+var import_details_error = require("../error/details.error.js");
+async function readAsText(blob, encoding) {
+  return setup((reader) => reader.readAsText(blob, encoding));
 }
-export async function readAsArrayBuffer(blob) {
-    return setup((reader) => reader.readAsArrayBuffer(blob));
+async function readAsArrayBuffer(blob) {
+  return setup((reader) => reader.readAsArrayBuffer(blob));
 }
-export async function readAsBinaryString(blob) {
-    return setup((reader) => reader.readAsBinaryString(blob));
+async function readAsBinaryString(blob) {
+  return setup((reader) => reader.readAsBinaryString(blob));
 }
-export async function readAsDataUrl(blob) {
-    return setup((reader) => reader.readAsDataURL(blob));
+async function readAsDataUrl(blob) {
+  return setup((reader) => reader.readAsDataURL(blob));
 }
 async function setup(dispatcher) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => resolve(reader.result);
-        reader.onerror = () => reject(new DetailsError(reader.error.message, reader.error));
-        dispatcher(reader);
-    });
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(new import_details_error.DetailsError(reader.error.message, reader.error));
+    dispatcher(reader);
+  });
 }

package/utils/format-error.js

@@ -1,39 +1,60 @@
-import { decycle } from './object/decycle.js';
-import { objectKeys } from './object/object.js';
-import { isDefined, isFunction, isUndefined } from './type-guards.js';
-// eslint-disable-next-line max-statements, complexity
-export function formatError(error, options = {}) {
-    const { includeRest = 'if-no-extra-info', includeExtraInfo = true, includeStack = true } = options;
-    let name;
-    let message;
-    let stack;
-    let rest;
-    let extraInfo;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    const wrappedError = error?.rejection ?? error?.reason ?? error?.error;
-    if ((error instanceof Error) && !(error.message.startsWith('Uncaught') && (wrappedError instanceof Error))) {
-        ({ name, message, stack, ...rest } = error);
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        if (includeExtraInfo && isFunction(error.getExtraInfo)) {
-            extraInfo = error.getExtraInfo();
-        }
+"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 format_error_exports = {};
+__export(format_error_exports, {
+  formatError: () => formatError
+});
+module.exports = __toCommonJS(format_error_exports);
+var import_decycle = require("./object/decycle.js");
+var import_object = require("./object/object.js");
+var import_type_guards = require("./type-guards.js");
+function formatError(error, options = {}) {
+  const { includeRest = "if-no-extra-info", includeExtraInfo = true, includeStack = true } = options;
+  let name;
+  let message;
+  let stack;
+  let rest;
+  let extraInfo;
+  const wrappedError = error?.rejection ?? error?.reason ?? error?.error;
+  if (error instanceof Error && !(error.message.startsWith("Uncaught") && wrappedError instanceof Error)) {
+    ({ name, message, stack, ...rest } = error);
+    if (includeExtraInfo && (0, import_type_guards.isFunction)(error.getExtraInfo)) {
+      extraInfo = error.getExtraInfo();
     }
-    else if (wrappedError instanceof Error) {
-        return formatError(wrappedError, options);
+  } else if (wrappedError instanceof Error) {
+    return formatError(wrappedError, options);
+  }
+  if ((0, import_type_guards.isUndefined)(name) && ((0, import_type_guards.isUndefined)(message) || message.trim().length == 0)) {
+    try {
+      const decycledError = (0, import_decycle.decycle)(error);
+      message = JSON.stringify(decycledError, null, 2);
+    } catch {
+      throw error;
     }
-    if (isUndefined(name) && (isUndefined(message) || message.trim().length == 0)) {
-        try {
-            const decycledError = decycle(error);
-            message = JSON.stringify(decycledError, null, 2);
-        }
-        catch {
-            throw error;
-        }
-    }
-    const nameString = (options.includeName ?? true) ? `${name ?? 'Error'}: ` : '';
-    const decycledRest = isDefined(rest) ? decycle(rest) : undefined;
-    const restString = (((includeRest == true) || ((includeRest == 'if-no-extra-info') && isUndefined(extraInfo))) && isDefined(decycledRest) && (objectKeys(rest ?? {}).length > 0)) ? `\n${JSON.stringify(decycledRest, null, 2)}` : '';
-    const extraInfoString = isDefined(extraInfo) ? `\n${JSON.stringify(extraInfo, null, 2)}` : '';
-    const stackString = (includeStack && isDefined(stack)) ? `\n${stack}` : '';
-    return `${nameString}${message}${restString}${extraInfoString}${stackString}`;
+  }
+  const nameString = options.includeName ?? true ? `${name ?? "Error"}: ` : "";
+  const decycledRest = (0, import_type_guards.isDefined)(rest) ? (0, import_decycle.decycle)(rest) : void 0;
+  const restString = (includeRest == true || includeRest == "if-no-extra-info" && (0, import_type_guards.isUndefined)(extraInfo)) && (0, import_type_guards.isDefined)(decycledRest) && (0, import_object.objectKeys)(rest ?? {}).length > 0 ? `
+${JSON.stringify(decycledRest, null, 2)}` : "";
+  const extraInfoString = (0, import_type_guards.isDefined)(extraInfo) ? `
+${JSON.stringify(extraInfo, null, 2)}` : "";
+  const stackString = includeStack && (0, import_type_guards.isDefined)(stack) ? `
+${stack}` : "";
+  return `${nameString}${message}${restString}${extraInfoString}${stackString}`;
 }

package/utils/format.js

@@ -1,34 +1,55 @@
-const siByteSizes = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
-const iecByteSizes = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
-export function formatDuration(milliseconds, precision) {
-    let value;
-    let suffix;
-    if (milliseconds >= (10 ** 3)) {
-        value = milliseconds / (10 ** 3);
-        suffix = 's';
-    }
-    else if (milliseconds >= 1) {
-        value = milliseconds;
-        suffix = 'ms';
-    }
-    else if (milliseconds >= 1 / (10 ** 3)) {
-        value = milliseconds * (10 ** 3);
-        suffix = 'us';
-    }
-    else {
-        value = milliseconds * (10 ** 6);
-        suffix = 'ns';
-    }
-    const trimmed = parseFloat(value.toFixed(precision));
-    const result = `${trimmed} ${suffix}`;
-    return result;
+"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 format_exports = {};
+__export(format_exports, {
+  formatBytes: () => formatBytes,
+  formatDuration: () => formatDuration
+});
+module.exports = __toCommonJS(format_exports);
+const siByteSizes = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+const iecByteSizes = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
+function formatDuration(milliseconds, precision) {
+  let value;
+  let suffix;
+  if (milliseconds >= 10 ** 3) {
+    value = milliseconds / 10 ** 3;
+    suffix = "s";
+  } else if (milliseconds >= 1) {
+    value = milliseconds;
+    suffix = "ms";
+  } else if (milliseconds >= 1 / 10 ** 3) {
+    value = milliseconds * 10 ** 3;
+    suffix = "us";
+  } else {
+    value = milliseconds * 10 ** 6;
+    suffix = "ns";
+  }
+  const trimmed = parseFloat(value.toFixed(precision));
+  const result = `${trimmed} ${suffix}`;
+  return result;
 }
-export function formatBytes(bytes, { decimals = 2, unit = 'IEC' } = {}) {
-    const iec = unit == 'IEC';
-    const base = iec ? 1024 : 1000;
-    const exponent = Math.floor(Math.log(bytes) / Math.log(base));
-    const prefix = (iec ? iecByteSizes : siByteSizes)[exponent];
-    const result = (bytes / (base ** exponent));
-    const formattedResult = Intl.NumberFormat(undefined, { useGrouping: false, maximumFractionDigits: decimals }).format(result);
-    return `${formattedResult} ${prefix}`;
+function formatBytes(bytes, { decimals = 2, unit = "IEC" } = {}) {
+  const iec = unit == "IEC";
+  const base = iec ? 1024 : 1e3;
+  const exponent = Math.floor(Math.log(bytes) / Math.log(base));
+  const prefix = (iec ? iecByteSizes : siByteSizes)[exponent];
+  const result = bytes / base ** exponent;
+  const formattedResult = Intl.NumberFormat(void 0, { useGrouping: false, maximumFractionDigits: decimals }).format(result);
+  return `${formattedResult} ${prefix}`;
 }

package/utils/function/index.js

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

package/utils/function/memoize.js

@@ -1,42 +1,57 @@
-import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
-import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
-/**
- * memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
- * @param fn function memoize
- * @returns memoized function
- */ export function memoize(fn, options = {}) {
-    const cache = new MultiKeyMap((options.weak ?? false) ? () => new IterableWeakMap() : undefined);
-    const name = getMemoizedName(fn);
-    return {
-        [name](...parameters) {
-            if (cache.has(parameters)) {
-                return cache.get(parameters);
-            }
-            const result = fn.call(this, ...parameters);
-            cache.set(parameters, result);
-            return result;
-        }
-    }[name];
+"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 memoize_exports = {};
+__export(memoize_exports, {
+  memoize: () => memoize,
+  memoizeSingle: () => memoizeSingle
+});
+module.exports = __toCommonJS(memoize_exports);
+var import_iterable_weak_map = require("../../data-structures/iterable-weak-map.js");
+var import_multi_key_map = require("../../data-structures/multi-key-map.js");
+function memoize(fn, options = {}) {
+  const cache = new import_multi_key_map.MultiKeyMap(options.weak ?? false ? () => new import_iterable_weak_map.IterableWeakMap() : void 0);
+  const name = getMemoizedName(fn);
+  return {
+    [name](...parameters) {
+      if (cache.has(parameters)) {
+        return cache.get(parameters);
+      }
+      const result = fn.call(this, ...parameters);
+      cache.set(parameters, result);
+      return result;
+    }
+  }[name];
 }
-/**
- * memoizes a function with a single parameter. Faster than {@link memoize}
- * @param fn function memoize
- * @returns memoized function
- */
-export function memoizeSingle(fn, options = {}) {
-    const cache = (options.weak ?? false) ? new IterableWeakMap() : new Map();
-    const name = getMemoizedName(fn);
-    return {
-        [name](parameter) {
-            if (cache.has(parameter)) {
-                return cache.get(parameter);
-            }
-            const result = fn.call(this, parameter);
-            cache.set(parameter, result);
-            return result;
-        }
-    }[name];
+function memoizeSingle(fn, options = {}) {
+  const cache = options.weak ?? false ? new import_iterable_weak_map.IterableWeakMap() : /* @__PURE__ */ new Map();
+  const name = getMemoizedName(fn);
+  return {
+    [name](parameter) {
+      if (cache.has(parameter)) {
+        return cache.get(parameter);
+      }
+      const result = fn.call(this, parameter);
+      cache.set(parameter, result);
+      return result;
+    }
+  }[name];
 }
 function getMemoizedName(fn) {
-    return `memoized${fn.name[0]?.toUpperCase() ?? ''}${fn.name.slice(1)}`;
+  return `memoized${fn.name[0]?.toUpperCase() ?? ""}${fn.name.slice(1)}`;
 }

package/utils/function/throttle.js

@@ -1,27 +1,49 @@
-import { currentTimestamp } from '../date-time.js';
-export const didNotRun = Symbol('did-not-run');
-export function throttleFunction(func, interval, queue = false) {
-    let lastCall = 0;
-    let pending = false;
-    let nextArgs;
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    const throttled = (...args) => {
-        const nextAllowedCall = lastCall + interval;
-        const now = currentTimestamp(); // eslint-disable-line no-shadow
-        if (now >= nextAllowedCall) {
-            pending = false;
-            lastCall = now;
-            return func(...args);
-        }
-        else if (queue) {
-            nextArgs = args;
-            if (!pending) {
-                const delay = nextAllowedCall - now;
-                setTimeout(() => throttled(...nextArgs), delay);
-                pending = true;
-            }
-        }
-        return didNotRun;
-    };
-    return throttled;
+"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 throttle_exports = {};
+__export(throttle_exports, {
+  didNotRun: () => didNotRun,
+  throttleFunction: () => throttleFunction
+});
+module.exports = __toCommonJS(throttle_exports);
+var import_date_time = require("../date-time.js");
+const didNotRun = Symbol("did-not-run");
+function throttleFunction(func, interval, queue = false) {
+  let lastCall = 0;
+  let pending = false;
+  let nextArgs;
+  const throttled = (...args) => {
+    const nextAllowedCall = lastCall + interval;
+    const now = (0, import_date_time.currentTimestamp)();
+    if (now >= nextAllowedCall) {
+      pending = false;
+      lastCall = now;
+      return func(...args);
+    } else if (queue) {
+      nextArgs = args;
+      if (!pending) {
+        const delay = nextAllowedCall - now;
+        setTimeout(() => throttled(...nextArgs), delay);
+        pending = true;
+      }
+    }
+    return didNotRun;
+  };
+  return throttled;
 }