@tstdl/base 0.85.14 → 0.86.0-beta2

package/utils/object/forward-ref.js

@@ -1,78 +1,62 @@
-"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 forward_ref_exports = {};
-__export(forward_ref_exports, {
-  ForwardRef: () => ForwardRef
-});
-module.exports = __toCommonJS(forward_ref_exports);
-var import_proxy = require("../proxy.js");
-var import_type_guards = require("../type-guards.js");
-var import_lazy_property = require("./lazy-property.js");
-const contexts = /* @__PURE__ */ new WeakMap();
-const ForwardRef = {
-  create(options) {
-    const context = getContext(options);
-    const forwardRef = getForwardRefProxy(context);
-    contexts.set(forwardRef, context);
-    return forwardRef;
-  },
-  isForwardRef(value) {
-    return contexts.has(value);
-  },
-  hasRef(forwardRef) {
-    const reference = contexts.get(forwardRef)?.reference;
-    return (0, import_type_guards.isDefined)(reference);
-  },
-  deref(forwardRef) {
-    (0, import_type_guards.assert)(ForwardRef.isForwardRef(forwardRef), "provided value is not a ForwardRef");
-    (0, import_type_guards.assert)(ForwardRef.hasRef(forwardRef), "ForwardRef has no reference");
-    return contexts.get(forwardRef).reference;
-  },
-  tryDeref(forwardRef) {
-    (0, import_type_guards.assert)(ForwardRef.isForwardRef(forwardRef), "provided value is not a ForwardRef");
-    return contexts.get(forwardRef);
-  },
-  setRef(forwardRef, reference) {
-    (0, import_type_guards.assert)(ForwardRef.isForwardRef(forwardRef), "provided value is not a ForwardRef");
-    contexts.get(forwardRef).reference = reference;
-  }
+/* eslint-disable @typescript-eslint/no-unsafe-argument, @typescript-eslint/ban-types */
+import { propertyReflectMethods, reflectMethods } from '../proxy.js';
+import { assert, isDefined, isUndefined } from '../type-guards.js';
+import { lazyObject } from './lazy-property.js';
+const contexts = new WeakMap();
+// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
+export const ForwardRef = {
+    create(options) {
+        const context = getContext(options);
+        const forwardRef = getForwardRefProxy(context);
+        contexts.set(forwardRef, context);
+        return forwardRef;
+    },
+    isForwardRef(value) {
+        return contexts.has(value);
+    },
+    hasRef(forwardRef) {
+        const reference = contexts.get(forwardRef)?.reference;
+        return isDefined(reference);
+    },
+    deref(forwardRef) {
+        assert(ForwardRef.isForwardRef(forwardRef), 'provided value is not a ForwardRef');
+        assert(ForwardRef.hasRef(forwardRef), 'ForwardRef has no reference');
+        return contexts.get(forwardRef).reference;
+    },
+    tryDeref(forwardRef) {
+        assert(ForwardRef.isForwardRef(forwardRef), 'provided value is not a ForwardRef');
+        return contexts.get(forwardRef);
+    },
+    setRef(forwardRef, reference) {
+        assert(ForwardRef.isForwardRef(forwardRef), 'provided value is not a ForwardRef');
+        contexts.get(forwardRef).reference = reference;
+    }
 };
 function getForwardRefProxy(context) {
-  function forwardRef() {
-  }
-  const handler = {};
-  for (const method of import_proxy.reflectMethods) {
-    handler[method] = {
-      [method](_originalTarget, ...args) {
-        if ((0, import_type_guards.isUndefined)(context.reference)) {
-          const message = import_proxy.propertyReflectMethods.has(method) ? `cannot forward "${method}" to property "${args[0].toString()}" on a ForwardRef which has no reference` : `cannot forward "${method}" on a ForwardRef which has no reference`;
-          throw new Error(message);
-        }
-        return Reflect[method](context.reference, ...args);
-      }
-    }[method];
-  }
-  return new Proxy(forwardRef, handler);
+    function forwardRef() { }
+    const handler = {};
+    for (const method of reflectMethods) {
+        handler[method] = {
+            [method](_originalTarget, ...args) {
+                if (isUndefined(context.reference)) {
+                    const message = propertyReflectMethods.has(method)
+                        ? `cannot forward "${method}" to property "${args[0].toString()}" on a ForwardRef which has no reference`
+                        : `cannot forward "${method}" on a ForwardRef which has no reference`;
+                    throw new Error(message);
+                }
+                return Reflect[method](context.reference, ...args);
+            }
+        }[method];
+    }
+    return new Proxy(forwardRef, handler);
 }
 function getContext(options) {
-  const reference = (0, import_type_guards.isDefined)(options?.reference) ? { value: options?.reference } : (0, import_type_guards.isDefined)(options?.initializer) ? { initializer: options?.initializer } : { value: void 0 };
-  return (0, import_lazy_property.lazyObject)({
-    reference
-  });
+    const reference = isDefined(options?.reference)
+        ? { value: options?.reference }
+        : isDefined(options?.initializer)
+            ? { initializer: options?.initializer }
+            : { value: undefined };
+    return lazyObject({
+        reference
+    });
 }

package/utils/object/index.js

@@ -1,24 +1,7 @@
-"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 object_exports = {};
-module.exports = __toCommonJS(object_exports);
-__reExport(object_exports, require("./decycle.js"), module.exports);
-__reExport(object_exports, require("./dereference.js"), module.exports);
-__reExport(object_exports, require("./forward-ref.js"), module.exports);
-__reExport(object_exports, require("./lazy-property.js"), module.exports);
-__reExport(object_exports, require("./merge.js"), module.exports);
-__reExport(object_exports, require("./object.js"), module.exports);
-__reExport(object_exports, require("./property-name.js"), module.exports);
+export * from './decycle.js';
+export * from './dereference.js';
+export * from './forward-ref.js';
+export * from './lazy-property.js';
+export * from './merge.js';
+export * from './object.js';
+export * from './property-name.js';

package/utils/object/lazy-property.js

@@ -1,101 +1,86 @@
-"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 lazy_property_exports = {};
-__export(lazy_property_exports, {
-  isLazyObjectValue: () => isLazyObjectValue,
-  lazyObject: () => lazyObject,
-  lazyObjectValue: () => lazyObjectValue,
-  lazyProperty: () => lazyProperty
-});
-module.exports = __toCommonJS(lazy_property_exports);
-var import_type_guards = require("../type-guards.js");
-var import_object = require("./object.js");
-const lazyObjectValueSymbol = Symbol("LazyObjectValue");
-function lazyProperty(object, propertyKey, initializer, descriptor = {}) {
-  const { configurable = true, enumerable = true, writable = true } = descriptor;
-  let initialized = false;
-  let _value;
-  Object.defineProperty(object, propertyKey, {
-    get() {
-      if (!initialized) {
-        _value = initializer.call(object, propertyKey);
-        initialized = true;
-      }
-      if (configurable) {
-        Object.defineProperty(object, propertyKey, { configurable, enumerable, writable, value: _value });
-      }
-      return _value;
-    },
-    set: !writable ? void 0 : function set(value) {
-      if (configurable) {
-        Object.defineProperty(object, propertyKey, { configurable, enumerable, writable, value });
-      }
-      _value = value;
-      initialized = true;
-    },
-    enumerable,
-    configurable
-  });
+import { isDefined, isFunction, isNullOrUndefined, isObject } from '../type-guards.js';
+import { filterObject, hasOwnProperty, objectEntries } from './object.js';
+const lazyObjectValueSymbol = Symbol('LazyObjectValue');
+/**
+ *
+ * @param object object to define lazy property on
+ * @param propertyKey property key
+ * @param initializer
+ * @param descriptor
+ */
+export function lazyProperty(object, propertyKey, initializer, descriptor = {}) {
+    const { configurable = true, enumerable = true, writable = true } = descriptor;
+    let initialized = false;
+    let _value;
+    Object.defineProperty(object, propertyKey, {
+        get() {
+            if (!initialized) {
+                _value = initializer.call(object, propertyKey);
+                initialized = true;
+            }
+            if (configurable) {
+                Object.defineProperty(object, propertyKey, { configurable, enumerable, writable, value: _value });
+            }
+            return _value;
+        },
+        set: !writable ? undefined
+            : function set(value) {
+                if (configurable) {
+                    Object.defineProperty(object, propertyKey, { configurable, enumerable, writable, value });
+                }
+                _value = value;
+                initialized = true;
+            },
+        enumerable,
+        configurable
+    });
 }
-function lazyObject(initializers) {
-  const object = {};
-  for (const [key, value] of (0, import_object.objectEntries)(initializers)) {
-    const valueIsFunction = (0, import_type_guards.isFunction)(value);
-    const valueIsObject = (0, import_type_guards.isObject)(value);
-    if (!valueIsFunction && !valueIsObject || (0, import_type_guards.isNullOrUndefined)(value)) {
-      object[key] = value;
-      continue;
+// eslint-disable-next-line max-statements, max-lines-per-function
+export function lazyObject(initializers) {
+    const object = {};
+    for (const [key, value] of objectEntries(initializers)) {
+        const valueIsFunction = isFunction(value);
+        const valueIsObject = isObject(value);
+        if ((!valueIsFunction && !valueIsObject) || isNullOrUndefined(value)) {
+            object[key] = value;
+            continue;
+        }
+        if (valueIsFunction) {
+            lazyProperty(object, key, value);
+            continue;
+        }
+        const definition = (isLazyObjectValue(value))
+            ? { value: value.value }
+            : value;
+        const hasGetOrSet = hasOwnProperty(definition, 'get') || hasOwnProperty(definition, 'set');
+        const hasInitializer = hasOwnProperty(definition, 'initializer');
+        const hasValue = hasOwnProperty(definition, 'value');
+        if ((Number(hasGetOrSet) + Number(hasInitializer) + Number(hasValue)) != 1) {
+            throw new Error(`exactly one of value, initializer or get/set must be provided for key "${key}", but got none or multiple`);
+        }
+        const descriptor = {
+            configurable: definition.configurable,
+            enumerable: definition.enumerable,
+            writable: definition.writable
+        };
+        if (hasInitializer) {
+            lazyProperty(object, key, definition.initializer, descriptor);
+            continue;
+        }
+        if (hasValue) {
+            object[key] = definition.value;
+            continue;
+        }
+        if (hasGetOrSet) {
+            Object.defineProperty(object, key, { get: definition.get, set: definition.set, configurable: true, enumerable: true, ...filterObject(descriptor, isDefined) });
+            continue;
+        }
     }
-    if (valueIsFunction) {
-      lazyProperty(object, key, value);
-      continue;
-    }
-    const definition = isLazyObjectValue(value) ? { value: value.value } : value;
-    const hasGetOrSet = (0, import_object.hasOwnProperty)(definition, "get") || (0, import_object.hasOwnProperty)(definition, "set");
-    const hasInitializer = (0, import_object.hasOwnProperty)(definition, "initializer");
-    const hasValue = (0, import_object.hasOwnProperty)(definition, "value");
-    if (Number(hasGetOrSet) + Number(hasInitializer) + Number(hasValue) != 1) {
-      throw new Error(`exactly one of value, initializer or get/set must be provided for key "${key}", but got none or multiple`);
-    }
-    const descriptor = {
-      configurable: definition.configurable,
-      enumerable: definition.enumerable,
-      writable: definition.writable
-    };
-    if (hasInitializer) {
-      lazyProperty(object, key, definition.initializer, descriptor);
-      continue;
-    }
-    if (hasValue) {
-      object[key] = definition.value;
-      continue;
-    }
-    if (hasGetOrSet) {
-      Object.defineProperty(object, key, { get: definition.get, set: definition.set, configurable: true, enumerable: true, ...(0, import_object.filterObject)(descriptor, import_type_guards.isDefined) });
-      continue;
-    }
-  }
-  return object;
+    return object;
 }
-function lazyObjectValue(value) {
-  return { [lazyObjectValueSymbol]: lazyObjectValueSymbol, value };
+export function lazyObjectValue(value) {
+    return { [lazyObjectValueSymbol]: lazyObjectValueSymbol, value };
 }
-function isLazyObjectValue(value) {
-  return (0, import_type_guards.isObject)(value) && value[lazyObjectValueSymbol] == lazyObjectValueSymbol;
+export function isLazyObjectValue(value) {
+    return isObject(value) && value[lazyObjectValueSymbol] == lazyObjectValueSymbol;
 }

package/utils/object/merge.js

@@ -1,81 +1,59 @@
-"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 merge_exports = {};
-__export(merge_exports, {
-  mergeObjects: () => mergeObjects
-});
-module.exports = __toCommonJS(merge_exports);
-var import_comparison = require("../comparison.js");
-var import_equals = require("../equals.js");
-var import_type_guards = require("../type-guards.js");
-var import_object = require("./object.js");
-function mergeObjects(objects, options = {}) {
-  return objects.reduce((merged, object) => _mergeObjects(merged, object, options), {});
+import { compareByValue } from '../comparison.js';
+import { arrayEquals } from '../equals.js';
+import { isArray, isPrimitive, isUndefined } from '../type-guards.js';
+import { hasOwnProperty, objectEntries } from './object.js';
+export function mergeObjects(objects, options = {}) {
+    return objects.reduce((merged, object) => _mergeObjects(merged, object, options), {});
 }
-function _mergeObjects(a, b, options, path = "$") {
-  const merged = { ...a };
-  const bEntries = (0, import_object.objectEntries)(b);
-  for (const [key, valueB] of bEntries) {
-    if (!(0, import_object.hasOwnProperty)(merged, key)) {
-      merged[key] = valueB;
-      continue;
+function _mergeObjects(a, b, options, path = '$') {
+    const merged = { ...a };
+    const bEntries = objectEntries(b);
+    for (const [key, valueB] of bEntries) {
+        if (!hasOwnProperty(merged, key)) {
+            merged[key] = valueB;
+            continue;
+        }
+        merged[key] = mergeValues(merged[key], valueB, options, `${path}.${key}`);
     }
-    merged[key] = mergeValues(merged[key], valueB, options, `${path}.${key}`);
-  }
-  return merged;
+    return merged;
 }
+// eslint-disable-next-line max-statements
 function mergeValues(a, b, options, path) {
-  const typeA = typeof a;
-  const typeB = typeof b;
-  if (typeA != typeB) {
-    throw new Error(`Property type mismatch at ${path}.`);
-  }
-  if ((0, import_type_guards.isPrimitive)(a) || typeA == "function") {
-    if (a == b) {
-      return a;
+    const typeA = typeof a;
+    const typeB = typeof b;
+    if (typeA != typeB) {
+        throw new Error(`Property type mismatch at ${path}.`);
     }
-    throw new Error(`Property value mismatch at ${path}.`);
-  }
-  if ((0, import_type_guards.isArray)(a)) {
-    if (!(0, import_type_guards.isArray)(b)) {
-      throw new Error(`Property type mismatch at ${path}.`);
+    if (isPrimitive(a) || (typeA == 'function')) {
+        if (a == b) {
+            return a;
+        }
+        throw new Error(`Property value mismatch at ${path}.`);
     }
-    return mergeArray(a, b, options, path);
-  }
-  return _mergeObjects(a, b, options, path);
+    if (isArray(a)) {
+        if (!isArray(b)) {
+            throw new Error(`Property type mismatch at ${path}.`);
+        }
+        return mergeArray(a, b, options, path); // eslint-disable-line @typescript-eslint/no-unsafe-return
+    }
+    return _mergeObjects(a, b, options, path);
 }
 function mergeArray(a, b, options, path) {
-  if (options.array == "merge" || (0, import_type_guards.isUndefined)(options.array)) {
-    return [...a, ...b];
-  }
-  if (options.array == "merge-unique") {
-    return [.../* @__PURE__ */ new Set([...a, ...b])];
-  }
-  if (options.array == "equals" || options.array == "equals-sorted") {
-    if (a.length != b.length) {
-      throw new Error(`array length mismatch at ${path}`);
+    if (options.array == 'merge' || isUndefined(options.array)) {
+        return [...a, ...b];
+    }
+    if (options.array == 'merge-unique') {
+        return [...new Set([...a, ...b])];
     }
-    const sort = options.array == "equals-sorted" ? import_comparison.compareByValue : void 0;
-    if (!(0, import_equals.arrayEquals)(a, b, { sort })) {
-      throw new Error(`array values mismatch at ${path}`);
+    if ((options.array == 'equals') || (options.array == 'equals-sorted')) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+        if (a.length != b.length) {
+            throw new Error(`array length mismatch at ${path}`);
+        }
+        const sort = options.array == 'equals-sorted' ? compareByValue : undefined;
+        if (!arrayEquals(a, b, { sort })) {
+            throw new Error(`array values mismatch at ${path}`);
+        }
+        return [...a];
     }
-    return [...a];
-  }
-  throw new Error(`unsupported array option ${options.array}`);
+    throw new Error(`unsupported array option ${options.array}`);
 }