@tstdl/base 0.85.14 → 0.86.0-beta2

package/enumerable/enumerable.js

@@ -1,201 +1,178 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all2) => {
-  for (var name in all2)
-    __defProp(target, name, { get: all2[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 enumerable_exports = {};
-__export(enumerable_exports, {
-  Enumerable: () => Enumerable
-});
-module.exports = __toCommonJS(enumerable_exports);
-var import_iterable_helpers = require("../utils/iterable-helpers/index.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_async_enumerable = require("./async-enumerable.js");
-class Enumerable {
-  source;
-  constructor(iterable) {
-    this.source = iterable;
-  }
-  static from(source) {
-    return new Enumerable(source);
-  }
-  static fromDeferred(source) {
-    const deferred = (0, import_iterable_helpers.deferredIterable)(source);
-    return new Enumerable(deferred);
-  }
-  static fromRange(fromInclusive, toInclusive) {
-    const rangeIterable = (0, import_iterable_helpers.range)(fromInclusive, toInclusive);
-    return new Enumerable(rangeIterable);
-  }
-  assert(predicate) {
-    const asserted = (0, import_iterable_helpers.assert)(this.source, predicate);
-    return new Enumerable(asserted);
-  }
-  all(predicate) {
-    return (0, import_iterable_helpers.all)(this.source, predicate);
-  }
-  any(predicate) {
-    return (0, import_iterable_helpers.any)(this.source, predicate);
-  }
-  batch(size) {
-    const batched = (0, import_iterable_helpers.batch)(this.source, size);
-    return new Enumerable(batched);
-  }
-  cast() {
-    return this;
-  }
-  concat(...iterables) {
-    const concatted = (0, import_iterable_helpers.concat)(this.source, ...iterables);
-    return new Enumerable(concatted);
-  }
-  defaultIfEmpty(defaultValue) {
-    const result = (0, import_iterable_helpers.defaultIfEmpty)(this.source, defaultValue);
-    return new Enumerable(result);
-  }
-  difference(iterable, selector) {
-    const result = (0, import_iterable_helpers.difference)(this.source, iterable, selector);
-    return new Enumerable(result);
-  }
-  differenceMany(iterables, selector) {
-    const result = (0, import_iterable_helpers.differenceMany)(this.source, iterables, selector);
-    return new Enumerable(result);
-  }
-  distinct(selector) {
-    const result = (0, import_iterable_helpers.distinct)(this.source, selector);
-    return new Enumerable(result);
-  }
-  includes(value) {
-    return (0, import_iterable_helpers.includes)(this.source, value);
-  }
-  drain() {
-    (0, import_iterable_helpers.drain)(this.source);
-  }
-  filter(predicate) {
-    const filtered = (0, import_iterable_helpers.filter)(this.source, predicate);
-    return new Enumerable(filtered);
-  }
-  filterNullOrUndefined() {
-    return this.filter((item) => (0, import_type_guards.isNotNullOrUndefined)(item));
-  }
-  first(predicate) {
-    return (0, import_iterable_helpers.first)(this.source, predicate);
-  }
-  firstOrDefault(defaultValue, predicate) {
-    return (0, import_iterable_helpers.firstOrDefault)(this.source, defaultValue, predicate);
-  }
-  forEach(func) {
-    (0, import_iterable_helpers.forEach)(this.source, func);
-  }
-  forceCast() {
-    return this;
-  }
-  group(selector) {
-    const grouped = (0, import_iterable_helpers.group)(this.source, selector);
-    return new Enumerable(grouped);
-  }
-  groupSingle(selector) {
-    const grouped = (0, import_iterable_helpers.groupSingle)(this.source, selector);
-    return new Enumerable(grouped);
-  }
-  groupToMap(selector) {
-    return (0, import_iterable_helpers.groupToMap)(this.source, selector);
-  }
-  groupToSingleMap(selector) {
-    return (0, import_iterable_helpers.groupToSingleMap)(this.source, selector);
-  }
-  tap(tapper) {
-    const iterator = (0, import_iterable_helpers.tap)(this.source, tapper);
-    return new Enumerable(iterator);
-  }
-  last(predicate) {
-    return (0, import_iterable_helpers.last)(this.source, predicate);
-  }
-  lastOrDefault(defaultValue, predicate) {
-    return (0, import_iterable_helpers.lastOrDefault)(this.source, defaultValue, predicate);
-  }
-  map(mapper) {
-    const mapped = (0, import_iterable_helpers.map)(this.source, mapper);
-    return new Enumerable(mapped);
-  }
-  mapMany(mapper) {
-    const result = (0, import_iterable_helpers.mapMany)(this.source, mapper);
-    return new Enumerable(result);
-  }
-  materialize() {
-    const materialized = (0, import_iterable_helpers.materialize)(this.source);
-    return new Enumerable(materialized);
-  }
-  metadata() {
-    const metadated = (0, import_iterable_helpers.metadata)(this.source);
-    return new Enumerable(metadated);
-  }
-  pairwise() {
-    const pairwised = (0, import_iterable_helpers.pairwise)(this.source);
-    return new Enumerable(pairwised);
-  }
-  reduce(reducer, initialValue) {
-    return (0, import_iterable_helpers.reduce)(this.source, reducer, initialValue);
-  }
-  single(predicate) {
-    return (0, import_iterable_helpers.single)(this.source, predicate);
-  }
-  singleOrDefault(defaultValue, predicate) {
-    return (0, import_iterable_helpers.singleOrDefault)(this.source, defaultValue, predicate);
-  }
-  skip(count) {
-    const skipped = (0, import_iterable_helpers.skip)(this.source, count);
-    return new Enumerable(skipped);
-  }
-  sort(comparator) {
-    return Enumerable.fromDeferred(() => (0, import_iterable_helpers.sort)(this.source, comparator));
-  }
-  sortToArray(comparator) {
-    return (0, import_iterable_helpers.sort)(this.source, comparator);
-  }
-  take(count) {
-    const taken = (0, import_iterable_helpers.take)(this.source, count);
-    return new Enumerable(taken);
-  }
-  takeUntil(cancellationToken) {
-    const taken = (0, import_iterable_helpers.takeUntil)(this.source, cancellationToken);
-    return new Enumerable(taken);
-  }
-  takeWhile(yieldLastOnFalse, predicate) {
-    const taken = (0, import_iterable_helpers.takeWhile)(this.source, yieldLastOnFalse, predicate);
-    return new Enumerable(taken);
-  }
-  toArray() {
-    return [...this.source];
-  }
-  toAsync() {
-    return import_async_enumerable.AsyncEnumerable.from(this.source);
-  }
-  toIterator() {
-    return this.source[Symbol.iterator]();
-  }
-  toSet() {
-    return new Set(this);
-  }
-  toSync() {
-    return this;
-  }
-  while(predicate) {
-    return (0, import_iterable_helpers.whileSync)(this.source, predicate);
-  }
-  *[Symbol.iterator]() {
-    yield* this.source;
-  }
+import { all, any, assert, batch, concat, defaultIfEmpty, deferredIterable, difference, differenceMany, distinct, drain, filter, first, firstOrDefault, forEach, group, groupSingle, groupToMap, groupToSingleMap, includes, last, lastOrDefault, map, mapMany, materialize, metadata, pairwise, range, reduce, single, singleOrDefault, skip, sort, take, takeUntil, takeWhile, tap, whileSync } from '../utils/iterable-helpers/index.js';
+import { isNotNullOrUndefined } from '../utils/type-guards.js';
+import { AsyncEnumerable } from './async-enumerable.js';
+export class Enumerable {
+    source;
+    constructor(iterable) {
+        this.source = iterable;
+    }
+    static from(source) {
+        return new Enumerable(source);
+    }
+    static fromDeferred(source) {
+        const deferred = deferredIterable(source);
+        return new Enumerable(deferred);
+    }
+    static fromRange(fromInclusive, toInclusive) {
+        const rangeIterable = range(fromInclusive, toInclusive);
+        return new Enumerable(rangeIterable);
+    }
+    assert(predicate) {
+        const asserted = assert(this.source, predicate);
+        return new Enumerable(asserted);
+    }
+    all(predicate) {
+        return all(this.source, predicate);
+    }
+    any(predicate) {
+        return any(this.source, predicate);
+    }
+    batch(size) {
+        const batched = batch(this.source, size);
+        return new Enumerable(batched);
+    }
+    cast() {
+        return this;
+    }
+    concat(...iterables) {
+        const concatted = concat(this.source, ...iterables);
+        return new Enumerable(concatted);
+    }
+    defaultIfEmpty(defaultValue) {
+        const result = defaultIfEmpty(this.source, defaultValue);
+        return new Enumerable(result);
+    }
+    difference(iterable, selector) {
+        const result = difference(this.source, iterable, selector);
+        return new Enumerable(result);
+    }
+    differenceMany(iterables, selector) {
+        const result = differenceMany(this.source, iterables, selector);
+        return new Enumerable(result);
+    }
+    distinct(selector) {
+        const result = distinct(this.source, selector);
+        return new Enumerable(result);
+    }
+    includes(value) {
+        return includes(this.source, value);
+    }
+    drain() {
+        drain(this.source);
+    }
+    filter(predicate) {
+        const filtered = filter(this.source, predicate);
+        return new Enumerable(filtered);
+    }
+    filterNullOrUndefined() {
+        return this.filter((item) => isNotNullOrUndefined(item));
+    }
+    first(predicate) {
+        return first(this.source, predicate);
+    }
+    firstOrDefault(defaultValue, predicate) {
+        return firstOrDefault(this.source, defaultValue, predicate);
+    }
+    forEach(func) {
+        forEach(this.source, func);
+    }
+    forceCast() {
+        return this;
+    }
+    group(selector) {
+        const grouped = group(this.source, selector);
+        return new Enumerable(grouped);
+    }
+    groupSingle(selector) {
+        const grouped = groupSingle(this.source, selector);
+        return new Enumerable(grouped);
+    }
+    groupToMap(selector) {
+        return groupToMap(this.source, selector);
+    }
+    groupToSingleMap(selector) {
+        return groupToSingleMap(this.source, selector);
+    }
+    tap(tapper) {
+        const iterator = tap(this.source, tapper);
+        return new Enumerable(iterator);
+    }
+    last(predicate) {
+        return last(this.source, predicate);
+    }
+    lastOrDefault(defaultValue, predicate) {
+        return lastOrDefault(this.source, defaultValue, predicate);
+    }
+    map(mapper) {
+        const mapped = map(this.source, mapper);
+        return new Enumerable(mapped);
+    }
+    mapMany(mapper) {
+        const result = mapMany(this.source, mapper);
+        return new Enumerable(result);
+    }
+    materialize() {
+        const materialized = materialize(this.source);
+        return new Enumerable(materialized);
+    }
+    metadata() {
+        const metadated = metadata(this.source);
+        return new Enumerable(metadated);
+    }
+    pairwise() {
+        const pairwised = pairwise(this.source);
+        return new Enumerable(pairwised);
+    }
+    reduce(reducer, initialValue) {
+        return reduce(this.source, reducer, initialValue);
+    }
+    single(predicate) {
+        return single(this.source, predicate);
+    }
+    singleOrDefault(defaultValue, predicate) {
+        return singleOrDefault(this.source, defaultValue, predicate);
+    }
+    skip(count) {
+        const skipped = skip(this.source, count);
+        return new Enumerable(skipped);
+    }
+    sort(comparator) {
+        return Enumerable.fromDeferred(() => sort(this.source, comparator));
+    }
+    sortToArray(comparator) {
+        return sort(this.source, comparator);
+    }
+    take(count) {
+        const taken = take(this.source, count);
+        return new Enumerable(taken);
+    }
+    takeUntil(cancellationToken) {
+        const taken = takeUntil(this.source, cancellationToken);
+        return new Enumerable(taken);
+    }
+    takeWhile(yieldLastOnFalse, predicate) {
+        const taken = takeWhile(this.source, yieldLastOnFalse, predicate);
+        return new Enumerable(taken);
+    }
+    toArray() {
+        return [...this.source];
+    }
+    toAsync() {
+        return AsyncEnumerable.from(this.source);
+    }
+    toIterator() {
+        return this.source[Symbol.iterator]();
+    }
+    toSet() {
+        return new Set(this);
+    }
+    toSync() {
+        return this;
+    }
+    while(predicate) {
+        return whileSync(this.source, predicate);
+    }
+    *[Symbol.iterator]() {
+        yield* this.source;
+    }
 }

package/enumerable/index.js

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

package/environment.js

@@ -1,61 +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 environment_exports = {};
-__export(environment_exports, {
-  hardwareConcurrency: () => hardwareConcurrency,
-  isBrowser: () => isBrowser,
-  isBrowserWindow: () => isBrowserWindow,
-  isBrowserWorker: () => isBrowserWorker,
-  isCjs: () => isCjs,
-  isDedicatedWorker: () => isDedicatedWorker,
-  isDeno: () => isDeno,
-  isEsm: () => isEsm,
-  isNode: () => isNode,
-  isNodeWorker: () => isNodeWorker,
-  isServiceWorker: () => isServiceWorker,
-  isSharedWorker: () => isSharedWorker,
-  isWorker: () => isWorker
-});
-module.exports = __toCommonJS(environment_exports);
-var import_import = require("./import.js");
-var import_require = require("./require.js");
-const isCjs = typeof require == "function" && typeof module == "object";
-const isEsm = !isCjs;
-const isBrowserWindow = typeof window != "undefined" && typeof window.document != "undefined";
-const isDedicatedWorker = checkIfIsWorker("DedicatedWorkerGlobalScope");
-const isSharedWorker = checkIfIsWorker("SharedWorkerGlobalScope");
-const isServiceWorker = checkIfIsWorker("ServiceWorkerGlobalScope");
-const isBrowserWorker = isDedicatedWorker || isSharedWorker || isServiceWorker;
-const isBrowser = isBrowserWindow || isBrowserWorker;
-const isNode = typeof process == "object" && typeof process.versions?.node == "string";
-const isNodeWorker = async () => isNode && await checkIfIsNodeWorkerThread();
-const isDeno = typeof Deno == "object" && typeof Deno.version?.deno == "string";
-const isWorker = async () => isBrowserWorker || await isNodeWorker();
-const hardwareConcurrency = isNode ? isCjs ? (0, import_require.dynamicRequire)("os").cpus().length : void 0 : globalThis.navigator?.hardwareConcurrency;
+import { dynamicImport } from './import.js';
+import { dynamicRequire } from './require.js';
+export const isCjs = (typeof require == 'function') && (typeof module == 'object');
+export const isEsm = !isCjs;
+export const isBrowserWindow = (typeof window != 'undefined') && (typeof window.document != 'undefined');
+export const isDedicatedWorker = checkIfIsWorker('DedicatedWorkerGlobalScope');
+export const isSharedWorker = checkIfIsWorker('SharedWorkerGlobalScope');
+export const isServiceWorker = checkIfIsWorker('ServiceWorkerGlobalScope');
+export const isBrowserWorker = isDedicatedWorker || isSharedWorker || isServiceWorker;
+export const isBrowser = isBrowserWindow || isBrowserWorker;
+export const isNode = (typeof process == 'object') && (typeof process.versions?.node == 'string');
+export const isNodeWorker = async () => isNode && (await checkIfIsNodeWorkerThread());
+export const isDeno = (typeof Deno == 'object') && (typeof Deno.version?.deno == 'string');
+export const isWorker = async () => isBrowserWorker || (await isNodeWorker());
+export const hardwareConcurrency = isNode
+    ? (isCjs ? (dynamicRequire('os')).cpus().length : undefined)
+    : globalThis.navigator?.hardwareConcurrency;
 function checkIfIsWorker(constructorName) {
-  return typeof globalThis == "object" && globalThis.constructor.name == constructorName;
+    return (typeof globalThis == 'object') && (globalThis.constructor.name == constructorName);
 }
 async function checkIfIsNodeWorkerThread() {
-  try {
-    const nodeWorkerThreads = await (0, import_import.dynamicImport)("nodeworker_threads");
-    return !nodeWorkerThreads.isMainThread;
-  } catch {
-    return false;
-  }
+    try {
+        const nodeWorkerThreads = await dynamicImport('nodeworker_threads');
+        return !nodeWorkerThreads.isMainThread;
+    }
+    catch {
+        return false;
+    }
 }

package/error/api.error.js

@@ -1,34 +1,11 @@
-"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 api_error_exports = {};
-__export(api_error_exports, {
-  ApiError: () => ApiError
-});
-module.exports = __toCommonJS(api_error_exports);
-var import_custom_error = require("./custom.error.js");
-class ApiError extends import_custom_error.CustomError {
-  static errorName = "ApiError";
-  details;
-  response;
-  constructor(response) {
-    super({ name: "ApiError", message: `${response.error.name} - ${response.error.message}` });
-    this.response = response;
-    this.details = response.error.details;
-  }
+import { CustomError } from './custom.error.js';
+export class ApiError extends CustomError {
+    static errorName = 'ApiError';
+    details;
+    response;
+    constructor(response) {
+        super({ name: 'ApiError', message: `${response.error.name} - ${response.error.message}` });
+        this.response = response;
+        this.details = response.error.details;
+    }
 }

package/error/assertion.error.js

@@ -1,30 +1,7 @@
-"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 assertion_error_exports = {};
-__export(assertion_error_exports, {
-  AssertionError: () => AssertionError
-});
-module.exports = __toCommonJS(assertion_error_exports);
-var import_custom_error = require("./custom.error.js");
-class AssertionError extends import_custom_error.CustomError {
-  static errorName = "AssertionError";
-  constructor(message) {
-    super({ message });
-  }
+import { CustomError } from './custom.error.js';
+export class AssertionError extends CustomError {
+    static errorName = 'AssertionError';
+    constructor(message) {
+        super({ message });
+    }
 }

package/error/bad-request.error.js

@@ -1,30 +1,7 @@
-"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 bad_request_error_exports = {};
-__export(bad_request_error_exports, {
-  BadRequestError: () => BadRequestError
-});
-module.exports = __toCommonJS(bad_request_error_exports);
-var import_custom_error = require("./custom.error.js");
-class BadRequestError extends import_custom_error.CustomError {
-  static errorName = "BadRequestError";
-  constructor(message = "bad request") {
-    super({ message });
-  }
+import { CustomError } from './custom.error.js';
+export class BadRequestError extends CustomError {
+    static errorName = 'BadRequestError';
+    constructor(message = 'bad request') {
+        super({ message });
+    }
 }