@tstdl/base 0.87.13 → 0.88.0-alpha1

package/utils/object/object.js

@@ -1,141 +1,111 @@
-"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.");
+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];
     }
-  }
-  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]);
+}
+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]);
+        }
     }
-  }
-  return entries;
+    return entries;
 }
-function omit(object, ...keys) {
-  return filterObject(object, (_, key) => !keys.includes(key));
+export function omit(object, ...keys) {
+    return filterObject(object, (_, key) => !keys.includes(key));
 }
-function pick(object, ...keys) {
-  return filterObject(object, (_, key) => keys.includes(key));
+export function pick(object, ...keys) {
+    return filterObject(object, (_, key) => keys.includes(key));
 }

package/utils/object/property-name.js

@@ -1,77 +1,74 @@
-"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 };
+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 };
 }
-function isPropertyName(value) {
-  return (0, import_type_guards.isDefined)(value?.[propertyName]);
+export function isPropertyName(value) {
+    return isDefined(value?.[propertyName]);
 }
-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;
+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;
 }
-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 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 flatPropertyNameOf(expression, options = {}) {
-  const name = expression(getPropertyNameProxy({ deep: options.deep, flat: true }))?.[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');
 }

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

@@ -1,68 +1,45 @@
-"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");
+import { FeedableAsyncIterable } from './feedable-async-iterable.js';
+export class OrderedFeedableAsyncIterable {
+    inBuffer;
+    out;
+    currentIndex = 0;
+    get $read() {
+        return this.out.$read;
     }
-    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);
+    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);
+        }
     }
-  }
 }