@tstdl/base 0.86.0-beta2 → 0.86.0-beta4

package/utils/object/object.js

@@ -1,111 +1,141 @@
-import { filterAsync } from '../async-iterable-helpers/filter.js';
-import { mapAsync } from '../async-iterable-helpers/map.js';
-import { toArrayAsync } from '../async-iterable-helpers/to-array.js';
-import { isArray, isDefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
-export function hasOwnProperty(obj, key) {
-    return Object.hasOwn(obj, key);
-}
-/**
- * returns object entries including those with symbols keys (which Object.entries does not)
- */
-export function objectEntries(object) {
-    const keys = objectKeys(object);
-    return keys.map((key) => [key, object[key]]);
-}
-/**
- * returns object keys including symbols (which Object.keys does not)
- */
-export function objectKeys(object) {
-    return Reflect.ownKeys(object).filter((key) => key != '__proto__');
-}
-export function objectValues(object) {
-    return objectKeys(object).map((key) => object[key]);
-}
-export function fromEntries(entries) {
-    return Object.fromEntries(entries);
-}
-export function mapObject(object, mapper) {
-    const mappedEntries = objectKeys(object).map((key) => mapper(object[key], key));
-    return Object.fromEntries(mappedEntries);
-}
-export async function mapObjectAsync(object, mapper) {
-    const entries = objectKeys(object);
-    const mappedEntries = await toArrayAsync(mapAsync(entries, async (key) => mapper(object[key], key)));
-    return Object.fromEntries(mappedEntries);
-}
-export function mapObjectValues(object, mapper) {
-    return mapObject(object, (value, key) => [key, mapper(value, key)]);
-}
-export async function mapObjectValuesAsync(object, mapper) {
-    return mapObjectAsync(object, async (value, key) => [key, await mapper(value, key)]);
-}
-export function filterObject(object, predicate) {
-    const mappedEntries = objectEntries(object).filter(([key, value]) => predicate(value, key));
-    return Object.fromEntries(mappedEntries);
-}
-export async function filterObjectAsync(object, predicate) {
-    const entries = objectEntries(object);
-    const mappedEntries = await toArrayAsync(filterAsync(entries, async ([key, value]) => predicate(value, key)));
-    return Object.fromEntries(mappedEntries);
-}
-export function filterUndefinedFromRecord(record) {
-    return filterObject(record, isDefined);
-}
-export function filterUndefinedObjectProperties(object) {
-    return filterObject(object, isDefined);
-}
-export function copyObjectProperties(source, target) {
-    for (const key of objectKeys(source)) {
-        target[key] = source[key];
+"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 object_exports = {};
+__export(object_exports, {
+  copyObjectProperties: () => copyObjectProperties,
+  deepObjectEntries: () => deepObjectEntries,
+  filterObject: () => filterObject,
+  filterObjectAsync: () => filterObjectAsync,
+  filterUndefinedFromRecord: () => filterUndefinedFromRecord,
+  filterUndefinedObjectProperties: () => filterUndefinedObjectProperties,
+  fromEntries: () => fromEntries,
+  getGetter: () => getGetter,
+  hasOwnProperty: () => hasOwnProperty,
+  mapObject: () => mapObject,
+  mapObjectAsync: () => mapObjectAsync,
+  mapObjectValues: () => mapObjectValues,
+  mapObjectValuesAsync: () => mapObjectValuesAsync,
+  objectEntries: () => objectEntries,
+  objectKeys: () => objectKeys,
+  objectValues: () => objectValues,
+  omit: () => omit,
+  pick: () => pick
+});
+module.exports = __toCommonJS(object_exports);
+var import_filter = require("../async-iterable-helpers/filter.js");
+var import_map = require("../async-iterable-helpers/map.js");
+var import_to_array = require("../async-iterable-helpers/to-array.js");
+var import_type_guards = require("../type-guards.js");
+function hasOwnProperty(obj, key) {
+  return Object.hasOwn(obj, key);
+}
+function objectEntries(object) {
+  const keys = objectKeys(object);
+  return keys.map((key) => [key, object[key]]);
+}
+function objectKeys(object) {
+  return Reflect.ownKeys(object).filter((key) => key != "__proto__");
+}
+function objectValues(object) {
+  return objectKeys(object).map((key) => object[key]);
+}
+function fromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+function mapObject(object, mapper) {
+  const mappedEntries = objectKeys(object).map((key) => mapper(object[key], key));
+  return Object.fromEntries(mappedEntries);
+}
+async function mapObjectAsync(object, mapper) {
+  const entries = objectKeys(object);
+  const mappedEntries = await (0, import_to_array.toArrayAsync)((0, import_map.mapAsync)(entries, async (key) => mapper(object[key], key)));
+  return Object.fromEntries(mappedEntries);
+}
+function mapObjectValues(object, mapper) {
+  return mapObject(object, (value, key) => [key, mapper(value, key)]);
+}
+async function mapObjectValuesAsync(object, mapper) {
+  return mapObjectAsync(object, async (value, key) => [key, await mapper(value, key)]);
+}
+function filterObject(object, predicate) {
+  const mappedEntries = objectEntries(object).filter(([key, value]) => predicate(value, key));
+  return Object.fromEntries(mappedEntries);
+}
+async function filterObjectAsync(object, predicate) {
+  const entries = objectEntries(object);
+  const mappedEntries = await (0, import_to_array.toArrayAsync)((0, import_filter.filterAsync)(entries, async ([key, value]) => predicate(value, key)));
+  return Object.fromEntries(mappedEntries);
+}
+function filterUndefinedFromRecord(record) {
+  return filterObject(record, import_type_guards.isDefined);
+}
+function filterUndefinedObjectProperties(object) {
+  return filterObject(object, import_type_guards.isDefined);
+}
+function copyObjectProperties(source, target) {
+  for (const key of objectKeys(source)) {
+    target[key] = source[key];
+  }
+}
+function getGetter(obj, property, bind) {
+  if (!(property in obj)) {
+    throw new Error(`Property ${property} does not exist.`);
+  }
+  let objOrPrototype = obj;
+  while (!hasOwnProperty(objOrPrototype, property)) {
+    objOrPrototype = Object.getPrototypeOf(objOrPrototype);
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(objOrPrototype, property);
+  if (descriptor == void 0) {
+    throw new Error("Could not get property descriptor.");
+  }
+  if (descriptor.get == void 0) {
+    throw new Error(`Property ${property} has no getter.`);
+  }
+  const getter = bind ? descriptor.get.bind(obj) : descriptor.get;
+  return getter;
+}
+function deepObjectEntries(object, keepInnerObjects = false, prefix) {
+  const allEntries = objectEntries(object);
+  for (const entry of allEntries) {
+    if ((0, import_type_guards.isSymbol)(entry[0])) {
+      throw new Error("Deep entries does not support symbols.");
     }
-}
-export function getGetter(obj, property, bind) {
-    if (!(property in obj)) {
-        throw new Error(`Property ${property} does not exist.`);
-    }
-    let objOrPrototype = obj;
-    while (!hasOwnProperty(objOrPrototype, property)) {
-        objOrPrototype = Object.getPrototypeOf(objOrPrototype);
-    }
-    const descriptor = Object.getOwnPropertyDescriptor(objOrPrototype, property);
-    if (descriptor == undefined) {
-        throw new Error('Could not get property descriptor.');
-    }
-    if (descriptor.get == undefined) {
-        throw new Error(`Property ${property} has no getter.`);
-    }
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const getter = bind ? descriptor.get.bind(obj) : descriptor.get;
-    return getter;
-}
-export function deepObjectEntries(object, keepInnerObjects = false, prefix) {
-    const allEntries = objectEntries(object);
-    for (const entry of allEntries) {
-        if (isSymbol(entry[0])) {
-            throw new Error('Deep entries does not support symbols.');
-        }
-    }
-    const rawEntries = isUndefined(prefix)
-        ? allEntries
-        : allEntries.map(([key, value]) => [`${prefix}${key}`, value]);
-    const entries = [];
-    for (const [key, value] of rawEntries) {
-        if (isObject(value) || isArray(value)) {
-            if (keepInnerObjects) {
-                entries.push([key, value]);
-            }
-            const innerEntries = deepObjectEntries(value, keepInnerObjects, `${key}.`);
-            entries.push(...innerEntries);
-        }
-        else {
-            entries.push([key, value]);
-        }
+  }
+  const rawEntries = (0, import_type_guards.isUndefined)(prefix) ? allEntries : allEntries.map(([key, value]) => [`${prefix}${key}`, value]);
+  const entries = [];
+  for (const [key, value] of rawEntries) {
+    if ((0, import_type_guards.isObject)(value) || (0, import_type_guards.isArray)(value)) {
+      if (keepInnerObjects) {
+        entries.push([key, value]);
+      }
+      const innerEntries = deepObjectEntries(value, keepInnerObjects, `${key}.`);
+      entries.push(...innerEntries);
+    } else {
+      entries.push([key, value]);
     }
-    return entries;
+  }
+  return entries;
 }
-export function omit(object, ...keys) {
-    return filterObject(object, (_, key) => !keys.includes(key));
+function omit(object, ...keys) {
+  return filterObject(object, (_, key) => !keys.includes(key));
 }
-export function pick(object, ...keys) {
-    return filterObject(object, (_, key) => keys.includes(key));
+function pick(object, ...keys) {
+  return filterObject(object, (_, key) => keys.includes(key));
 }

package/utils/object/property-name.js

@@ -1,74 +1,77 @@
-import { assertString, assertStringPass, isDefined, isUndefined } from '../type-guards.js';
-export const propertyName = Symbol('PropertyName');
-export const cast = Symbol('cast');
-export function getPropertyName(name) {
-    return { [propertyName]: 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 property_name_exports = {};
+__export(property_name_exports, {
+  cast: () => cast,
+  flatPropertyNameOf: () => flatPropertyNameOf,
+  getPropertyName: () => getPropertyName,
+  getPropertyNameProxy: () => getPropertyNameProxy,
+  isPropertyName: () => isPropertyName,
+  propertyName: () => propertyName,
+  propertyNameOf: () => propertyNameOf
+});
+module.exports = __toCommonJS(property_name_exports);
+var import_type_guards = require("../type-guards.js");
+const propertyName = Symbol("PropertyName");
+const cast = Symbol("cast");
+function getPropertyName(name) {
+  return { [propertyName]: name };
 }
-export function isPropertyName(value) {
-    return isDefined(value?.[propertyName]);
+function isPropertyName(value) {
+  return (0, import_type_guards.isDefined)(value?.[propertyName]);
 }
-const propertyNameProxy = Symbol('PropertyNameProxy');
-/**
- * get the path to a property
- *
- * @param options.deep whether to return the whole path to the property or just the last property
- * @param options.flat ignore array accesses (properties consiting only of numbers)
- * @param options.prefix name prefix
- *
- * @example
- * import { getPropertyNameProxy, propertyName } from '@tstdl/base/utils/object.js';
- *
- * const name = getPropertyNameProxy<MyType>().foo.bar[propertyName];
- *
- * name == 'foo.bar' // true
- */
-export function getPropertyNameProxy(options = {}) {
-    const { deep = true, flat = false, prefix } = options;
-    const cache = new Map();
-    const proxy = new Proxy({ [propertyNameProxy]: prefix }, {
-        get: (_target, property) => {
-            if (property == propertyName) {
-                return prefix;
-            }
-            if (property == cast) {
-                return () => proxy;
-            }
-            if (property == 'toString') {
-                return () => prefix;
-            }
-            assertString(property, `Invalid property access on PropertyNameProxy. Property must be a string, but was "${property.toString()}".`);
-            const ignore = (flat && (/\d+/u).test(property));
-            if (ignore) {
-                return proxy;
-            }
-            const cached = cache.get(property);
-            if (isDefined(cached)) {
-                return cached;
-            }
-            const newProxy = getPropertyNameProxy({ deep, flat, prefix: deep ? isUndefined(prefix) ? property : `${prefix}.${property}` : property });
-            cache.set(property, newProxy);
-            return newProxy;
-        }
-    });
-    return proxy;
+const propertyNameProxy = Symbol("PropertyNameProxy");
+function getPropertyNameProxy(options = {}) {
+  const { deep = true, flat = false, prefix } = options;
+  const cache = /* @__PURE__ */ new Map();
+  const proxy = new Proxy({ [propertyNameProxy]: prefix }, {
+    get: (_target, property) => {
+      if (property == propertyName) {
+        return prefix;
+      }
+      if (property == cast) {
+        return () => proxy;
+      }
+      if (property == "toString") {
+        return () => prefix;
+      }
+      (0, import_type_guards.assertString)(property, `Invalid property access on PropertyNameProxy. Property must be a string, but was "${property.toString()}".`);
+      const ignore = flat && /\d+/u.test(property);
+      if (ignore) {
+        return proxy;
+      }
+      const cached = cache.get(property);
+      if ((0, import_type_guards.isDefined)(cached)) {
+        return cached;
+      }
+      const newProxy = getPropertyNameProxy({ deep, flat, prefix: deep ? (0, import_type_guards.isUndefined)(prefix) ? property : `${prefix}.${property}` : property });
+      cache.set(property, newProxy);
+      return newProxy;
+    }
+  });
+  return proxy;
 }
-/**
- * get the path to a property
- * @param expression property selection expression
- * @param options.deep whether to return the whole path to the property or just the last property
- * @returns property name
- */
-export function propertyNameOf(expression, options = {}) {
-    const name = expression(getPropertyNameProxy({ deep: options.deep, flat: false }))?.[propertyName];
-    return assertStringPass(name, 'invalid expression');
+function propertyNameOf(expression, options = {}) {
+  const name = expression(getPropertyNameProxy({ deep: options.deep, flat: false }))?.[propertyName];
+  return (0, import_type_guards.assertStringPass)(name, "invalid expression");
 }
-/**
- * get the flat path to a property (flat = ignore array accesses (properties only consisting of numbers))
- * @param expression property selection expression
- * @param options.deep whether to return the whole path to the property or just the last property
- * @returns property name
- */
-export function flatPropertyNameOf(expression, options = {}) {
-    const name = expression(getPropertyNameProxy({ deep: options.deep, flat: true }))?.[propertyName];
-    return assertStringPass(name, 'invalid expression');
+function flatPropertyNameOf(expression, options = {}) {
+  const name = expression(getPropertyNameProxy({ deep: options.deep, flat: true }))?.[propertyName];
+  return (0, import_type_guards.assertStringPass)(name, "invalid expression");
 }

package/utils/ordered-feedable-async-iterable.js

@@ -1,45 +1,68 @@
-import { FeedableAsyncIterable } from './feedable-async-iterable.js';
-export class OrderedFeedableAsyncIterable {
-    inBuffer;
-    out;
-    currentIndex = 0;
-    get $read() {
-        return this.out.$read;
+"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 ordered_feedable_async_iterable_exports = {};
+__export(ordered_feedable_async_iterable_exports, {
+  OrderedFeedableAsyncIterable: () => OrderedFeedableAsyncIterable
+});
+module.exports = __toCommonJS(ordered_feedable_async_iterable_exports);
+var import_feedable_async_iterable = require("./feedable-async-iterable.js");
+class OrderedFeedableAsyncIterable {
+  inBuffer;
+  out;
+  currentIndex = 0;
+  get $read() {
+    return this.out.$read;
+  }
+  get $empty() {
+    return this.out.$empty;
+  }
+  get closed() {
+    return this.out.closed;
+  }
+  get bufferSize() {
+    return this.out.bufferSize;
+  }
+  constructor() {
+    this.inBuffer = /* @__PURE__ */ new Map();
+    this.out = new import_feedable_async_iterable.FeedableAsyncIterable();
+  }
+  feed(item, index) {
+    if (this.out.closed) {
+      throw new Error("feedable is already closed");
     }
-    get $empty() {
-        return this.out.$empty;
-    }
-    get closed() {
-        return this.out.closed;
-    }
-    get bufferSize() {
-        return this.out.bufferSize;
-    }
-    constructor() {
-        this.inBuffer = new Map();
-        this.out = new FeedableAsyncIterable();
-    }
-    feed(item, index) {
-        if (this.out.closed) {
-            throw new Error('feedable is already closed');
-        }
-        this.inBuffer.set(index, item);
-        this.dispatch();
-    }
-    end() {
-        this.out.end();
-    }
-    throw(error) {
-        this.out.throw(error);
-    }
-    [Symbol.asyncIterator]() {
-        return this.out[Symbol.asyncIterator]();
-    }
-    dispatch() {
-        while (this.inBuffer.has(this.currentIndex)) {
-            const item = this.inBuffer.get(this.currentIndex);
-            this.inBuffer.delete(this.currentIndex++);
-            this.out.feed(item);
-        }
+    this.inBuffer.set(index, item);
+    this.dispatch();
+  }
+  end() {
+    this.out.end();
+  }
+  throw(error) {
+    this.out.throw(error);
+  }
+  [Symbol.asyncIterator]() {
+    return this.out[Symbol.asyncIterator]();
+  }
+  dispatch() {
+    while (this.inBuffer.has(this.currentIndex)) {
+      const item = this.inBuffer.get(this.currentIndex);
+      this.inBuffer.delete(this.currentIndex++);
+      this.out.feed(item);
     }
+  }
 }