@thi.ng/resolve-map 7.1.45 → 7.1.46

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -74,7 +74,7 @@ For Node.js REPL:
 const resolveMap = await import("@thi.ng/resolve-map");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.11 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.01 KB
 
 ## Dependencies
 

package/index.js

@@ -7,268 +7,177 @@ import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { mutInUnsafe } from "@thi.ng/paths/mut-in";
 import { exists } from "@thi.ng/paths/path";
 const RE_ARGS = /^(function\s+\w+)?\s*\(\{([\w\s,:]+)\}/;
-export function resolve(root, opts) {
-    const $opts = { prefix: "@", unwrap: true, ...opts };
-    return isPlainObject(root)
-        ? resolveMap(root, $opts)
-        : isArray(root)
-            ? resolveArray(root, $opts)
-            : root;
+function resolve(root, opts) {
+  const $opts = { prefix: "@", unwrap: true, ...opts };
+  return isPlainObject(root) ? resolveMap(root, $opts) : isArray(root) ? resolveArray(root, $opts) : root;
 }
-/** @internal */
-const resolveMap = (obj, opts, root, path = [], resolved = {}, stack = []) => {
-    root = root || obj;
-    for (let k in obj) {
-        _resolve(root, [...path, k], resolved, stack, opts);
-    }
-    return !opts.unwrap || path.length
-        ? obj
-        : unwrapResolved(obj, resolved);
-};
-/** @internal */
-const resolveArray = (arr, opts, root, path = [], resolved = {}, stack = []) => {
-    root = root || arr;
-    for (let k = 0, n = arr.length; k < n; k++) {
-        _resolve(root, [...path, k], resolved, stack, opts);
-    }
-    return !opts.unwrap || path.length
-        ? arr
-        : unwrapResolved(arr, resolved);
+const resolveMap = (obj, opts, root, path = [], resolved2 = {}, stack = []) => {
+  root = root || obj;
+  for (let k in obj) {
+    _resolve(root, [...path, k], resolved2, stack, opts);
+  }
+  return !opts.unwrap || path.length ? obj : unwrapResolved(obj, resolved2);
 };
-/**
- * The actual recursive resolution mechanism. Takes root object, key
- * path, helper object for marking visited keys and a stack of currently
- * active lookups. The latter is used for cycle detection and `_resolve`
- * will throw an error if a cycle has been detected.
- *
- * @param root -
- * @param path -
- * @param resolved -
- * @param stack -
- *
- * @internal
- */
-const _resolve = (root, path, resolved, stack, opts) => {
-    const pathID = path.join("/");
-    if (stack.indexOf(pathID) >= 0) {
-        illegalArgs(`cyclic references not allowed: ${pathID}`);
-    }
-    // console.log(pp, resolved[pp], stack);
-    let [v, isResolved] = getInUnsafe(root, path);
-    if (!resolved[pathID]) {
-        if (isResolved) {
-            resolved[pathID] = true;
-            return v;
-        }
-        let res = SEMAPHORE;
-        stack.push(pathID);
-        if (isPlainObject(v)) {
-            resolveMap(v, { ...opts, unwrap: false }, root, path, resolved, stack);
-        }
-        else if (isArray(v)) {
-            resolveArray(v, { ...opts, unwrap: false }, root, path, resolved, stack);
-        }
-        else if (!opts.onlyFnRefs &&
-            isString(v) &&
-            v.startsWith(opts.prefix)) {
-            res = _resolve(root, absPath(path, v, opts.prefix.length), resolved, stack, opts);
-        }
-        else if (isFunction(v)) {
-            res = resolveFunction(v, (p) => _resolve(root, absPath(path, p, 0), resolved, stack, opts), pathID, resolved);
-        }
-        else if (!exists(root, path)) {
-            v = resolvePath(root, path, resolved, stack, opts);
-        }
-        if (res !== SEMAPHORE) {
-            mutInUnsafe(root, path, res);
-            v = res;
-        }
-        resolved[pathID] = true;
-        stack.pop();
-    }
-    return v;
+const resolveArray = (arr, opts, root, path = [], resolved2 = {}, stack = []) => {
+  root = root || arr;
+  for (let k = 0, n = arr.length; k < n; k++) {
+    _resolve(root, [...path, k], resolved2, stack, opts);
+  }
+  return !opts.unwrap || path.length ? arr : unwrapResolved(arr, resolved2);
 };
-/**
- * Repeatedly calls `_resolve` by stepwise descending along given path
- * and returns final value. This is to ensure full resolution of deeper
- * values created by functions at intermediate tree levels.
- *
- * E.g. given:
- *
- * ```
- * {a: () => ({b: {c: 1}}), d: "@/a/b/c" }
- * =>
- * { a: { b: { c: 1 } }, d: 1 }
- * ```
- *
- * @param root -
- * @param path -
- * @param resolved -
- *
- * @internal
- */
-const resolvePath = (root, path, resolved, stack, opts) => {
-    // temporarily remove current path to avoid cycle detection
-    let pathID = stack.pop();
-    let v;
-    for (let i = 1, n = path.length; i <= n; i++) {
-        v = _resolve(root, path.slice(0, i), resolved, stack, opts);
-    }
-    // restore
+const _resolve = (root, path, resolved2, stack, opts) => {
+  const pathID = path.join("/");
+  if (stack.indexOf(pathID) >= 0) {
+    illegalArgs(`cyclic references not allowed: ${pathID}`);
+  }
+  let [v, isResolved] = getInUnsafe(root, path);
+  if (!resolved2[pathID]) {
+    if (isResolved) {
+      resolved2[pathID] = true;
+      return v;
+    }
+    let res = SEMAPHORE;
     stack.push(pathID);
-    return v;
+    if (isPlainObject(v)) {
+      resolveMap(
+        v,
+        { ...opts, unwrap: false },
+        root,
+        path,
+        resolved2,
+        stack
+      );
+    } else if (isArray(v)) {
+      resolveArray(
+        v,
+        { ...opts, unwrap: false },
+        root,
+        path,
+        resolved2,
+        stack
+      );
+    } else if (!opts.onlyFnRefs && isString(v) && v.startsWith(opts.prefix)) {
+      res = _resolve(
+        root,
+        absPath(path, v, opts.prefix.length),
+        resolved2,
+        stack,
+        opts
+      );
+    } else if (isFunction(v)) {
+      res = resolveFunction(
+        v,
+        (p) => _resolve(root, absPath(path, p, 0), resolved2, stack, opts),
+        pathID,
+        resolved2
+      );
+    } else if (!exists(root, path)) {
+      v = resolvePath(root, path, resolved2, stack, opts);
+    }
+    if (res !== SEMAPHORE) {
+      mutInUnsafe(root, path, res);
+      v = res;
+    }
+    resolved2[pathID] = true;
+    stack.pop();
+  }
+  return v;
 };
-/**
- * Resolution helper for function values. Checks if the user function
- * uses ES6 object destructuring for its first argument and if so
- * resolves the given keys before calling the function and provides
- * their values as first arg. If no de-structure form is found, calls
- * function only with `resolve` as argument.
- *
- * If the user function returns an array or plain object, all of its
- * nested values are marked as resolved.
- *
- * See `resolve` comments for further details.
- *
- * @param fn -
- * @param resolve -
- * @param pathID - current base path for marking
- * @param resolved -
- *
- * @internal
- */
-const resolveFunction = (fn, resolve, pathID, resolved) => {
-    const match = RE_ARGS.exec(fn.toString());
-    let res;
-    if (match) {
-        const args = match[2]
-            // remove white space and trailing comma
-            .replace(/\s|(,\s*$)/g, "")
-            .split(/,/g)
-            .map((k) => k.split(":")[0])
-            .reduce((acc, k) => ((acc[k] = resolve(k)), acc), {});
-        res = fn(args, resolve);
-    }
-    else {
-        res = fn(resolve);
-    }
-    markResolved(res, pathID, resolved);
-    return res;
+const resolvePath = (root, path, resolved2, stack, opts) => {
+  let pathID = stack.pop();
+  let v;
+  for (let i = 1, n = path.length; i <= n; i++) {
+    v = _resolve(root, path.slice(0, i), resolved2, stack, opts);
+  }
+  stack.push(pathID);
+  return v;
 };
-/** @internal */
-const markResolved = (v, path, resolved) => {
-    resolved[path] = true;
-    if (isPlainObject(v)) {
-        markObjResolved(v, path, resolved);
-    }
-    else if (isArray(v)) {
-        markArrayResolved(v, path, resolved);
-    }
+const resolveFunction = (fn, resolve2, pathID, resolved2) => {
+  const match = RE_ARGS.exec(fn.toString());
+  let res;
+  if (match) {
+    const args = match[2].replace(/\s|(,\s*$)/g, "").split(/,/g).map((k) => k.split(":")[0]).reduce((acc, k) => (acc[k] = resolve2(k), acc), {});
+    res = fn(args, resolve2);
+  } else {
+    res = fn(resolve2);
+  }
+  markResolved(res, pathID, resolved2);
+  return res;
 };
-/** @internal */
-const markObjResolved = (obj, path, resolved) => {
-    let v, p;
-    for (let k in obj) {
-        v = obj[k];
-        p = path + "/" + k;
-        markResolved(v, p, resolved);
-    }
+const markResolved = (v, path, resolved2) => {
+  resolved2[path] = true;
+  if (isPlainObject(v)) {
+    markObjResolved(v, path, resolved2);
+  } else if (isArray(v)) {
+    markArrayResolved(v, path, resolved2);
+  }
 };
-/** @internal */
-const markArrayResolved = (arr, path, resolved) => {
-    let v, p;
-    for (let i = 0, n = arr.length; i < n; i++) {
-        v = arr[i];
-        p = path + "/" + i;
-        markResolved(v, p, resolved);
-    }
+const markObjResolved = (obj, path, resolved2) => {
+  let v, p;
+  for (let k in obj) {
+    v = obj[k];
+    p = path + "/" + k;
+    markResolved(v, p, resolved2);
+  }
 };
-/**
- * Takes the path for the current key and a lookup path string. Converts
- * the possibly relative lookup path into its absolute form.
- *
- * @param curr -
- * @param path -
- * @param idx -
- */
-export const absPath = (curr, path, idx = 1) => {
-    if (path.charAt(idx) === "/") {
-        return path.substring(idx + 1).split("/");
-    }
-    curr = curr.slice(0, curr.length - 1);
-    const sub = path.substring(idx).split("/");
-    for (let i = 0, n = sub.length; i < n; i++) {
-        if (sub[i] === "..") {
-            !curr.length && illegalArgs(`invalid lookup path: ${path}`);
-            curr.pop();
-        }
-        else {
-            return curr.concat(sub.slice(i));
-        }
-    }
-    !curr.length && illegalArgs(`invalid lookup path: ${path}`);
-    return curr;
+const markArrayResolved = (arr, path, resolved2) => {
+  let v, p;
+  for (let i = 0, n = arr.length; i < n; i++) {
+    v = arr[i];
+    p = path + "/" + i;
+    markResolved(v, p, resolved2);
+  }
 };
-/**
- * Value wrapper to protect from future recursive resolution attempts. See
- * {@link resolved} for further details.
- */
-export class Resolved {
-    _value;
-    constructor(_value) {
-        this._value = _value;
-    }
-    deref() {
-        return this._value;
-    }
+const absPath = (curr, path, idx = 1) => {
+  if (path.charAt(idx) === "/") {
+    return path.substring(idx + 1).split("/");
+  }
+  curr = curr.slice(0, curr.length - 1);
+  const sub = path.substring(idx).split("/");
+  for (let i = 0, n = sub.length; i < n; i++) {
+    if (sub[i] === "..") {
+      !curr.length && illegalArgs(`invalid lookup path: ${path}`);
+      curr.pop();
+    } else {
+      return curr.concat(sub.slice(i));
+    }
+  }
+  !curr.length && illegalArgs(`invalid lookup path: ${path}`);
+  return curr;
+};
+class Resolved {
+  constructor(_value) {
+    this._value = _value;
+  }
+  deref() {
+    return this._value;
+  }
 }
-/**
- * Factory function for {@link Resolved} to wrap & protect values from further
- * resolution attempts. The wrapped value can be later obtained via the standard
- * [`IDeref`](https://docs.thi.ng/umbrella/api/interfaces/IDeref.html)
- * interface/mechanism. In lookup functions, the unwrapped value will be
- * supplied, no `.deref()` necessary there.
- *
- * @param val
- */
-export const resolved = (val) => new Resolved(val);
-/**
- * Special version of
- * [`getInUnsafe()`](https://docs.thi.ng/umbrella/paths/functions/getInUnsafe.html)
- * with extra support for intermediate wrapped {@link Resolved} values and
- * returning tuple of: `[val,isResolved]`.
- *
- * @param obj
- * @param path
- *
- * @internal
- */
+const resolved = (val) => new Resolved(val);
 const getInUnsafe = (obj, path) => {
-    const n = path.length - 1;
-    let res = obj;
-    let isResolved = obj instanceof Resolved;
-    for (let i = 0; res != null && i <= n; i++) {
-        res = res[path[i]];
-        if (res instanceof Resolved) {
-            isResolved = true;
-            res = res.deref();
-        }
-    }
-    return [res, isResolved];
+  const n = path.length - 1;
+  let res = obj;
+  let isResolved = obj instanceof Resolved;
+  for (let i = 0; res != null && i <= n; i++) {
+    res = res[path[i]];
+    if (res instanceof Resolved) {
+      isResolved = true;
+      res = res.deref();
+    }
+  }
+  return [res, isResolved];
 };
-/**
- * Unwraps all known values wrapped using {@link Resolved} in-place.
- *
- * @param root
- * @param resolved
- *
- * @internal
- */
-const unwrapResolved = (root, resolved) => {
-    for (let path in resolved) {
-        const $path = path.split("/");
-        const val = getInUnsafe(root, $path);
-        val[1] && mutInUnsafe(root, $path, val[0]);
-    }
-    return root;
+const unwrapResolved = (root, resolved2) => {
+  for (let path in resolved2) {
+    const $path = path.split("/");
+    const val = getInUnsafe(root, $path);
+    val[1] && mutInUnsafe(root, $path, val[0]);
+  }
+  return root;
+};
+export {
+  Resolved,
+  absPath,
+  resolve,
+  resolved
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/resolve-map",
-  "version": "7.1.45",
+  "version": "7.1.46",
   "description": "DAG resolution of vanilla objects & arrays with internally linked values",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,13 +35,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/paths": "^5.1.52"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/paths": "^5.1.53"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -74,5 +77,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }