data-path 1.0.0

package/dist/index.js

@@ -0,0 +1,527 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  path: () => path,
+  unsafePath: () => unsafePath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants.ts
+var PATH_SEGMENTS = /* @__PURE__ */ Symbol("PATH_SEGMENTS");
+var WILDCARD = "*";
+var DEEP_WILDCARD = "**";
+
+// src/utils.ts
+function isCanonicalArrayIndex(key) {
+  const num = Number(key);
+  return Number.isInteger(num) && num >= 0 && num < 2 ** 32 && String(num) === key;
+}
+function resolveSegments(target) {
+  if (typeof target === "function") {
+    const proxy = createPathProxy([]);
+    const result = target(proxy);
+    return result?.[PATH_SEGMENTS] ?? [];
+  }
+  if (target && typeof target === "object" && "segments" in target) {
+    return target.segments;
+  }
+  return [];
+}
+function createPathProxy(segments) {
+  return new Proxy(
+    { [PATH_SEGMENTS]: segments },
+    {
+      get(target, key) {
+        if (key === PATH_SEGMENTS)
+          return target[PATH_SEGMENTS];
+        if (typeof key === "string" && key !== "Symbol") {
+          const next = isCanonicalArrayIndex(key) ? Number(key) : key;
+          return createPathProxy([...segments, next]);
+        }
+        return typeof key === "symbol" ? void 0 : createPathProxy(segments);
+      }
+    }
+  );
+}
+function segmentsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((s, i) => s === b[i]);
+}
+function matchesPrefix(full, prefix) {
+  if (prefix.length > full.length) return false;
+  let p = 0;
+  let f = 0;
+  while (p < prefix.length && f < full.length) {
+    if (prefix[p] === DEEP_WILDCARD) {
+      if (p === prefix.length - 1) return true;
+      const restPrefix = prefix.slice(p + 1);
+      for (let skip = 0; f + skip <= full.length; skip++) {
+        if (matchesPrefix(full.slice(f + skip), restPrefix)) return true;
+      }
+      return false;
+    }
+    if (prefix[p] !== WILDCARD && prefix[p] !== full[f]) return false;
+    p++;
+    f++;
+  }
+  return p === prefix.length;
+}
+function patternMatches(pattern, concrete) {
+  if (pattern.length !== concrete.length) return false;
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== WILDCARD && pattern[i] !== DEEP_WILDCARD && pattern[i] !== concrete[i])
+      return false;
+  }
+  return true;
+}
+
+// src/impl/path-impl.ts
+var TemplatePathCtor;
+function setTemplatePathCtor(ctor) {
+  TemplatePathCtor = ctor;
+}
+var PathImpl = class _PathImpl {
+  segments;
+  constructor(segments) {
+    this.segments = segments;
+  }
+  /**
+   * The number of segments in this path.
+   */
+  get length() {
+    return this.segments.length;
+  }
+  /**
+   * The string representation of the path (e.g. "users.0.name").
+   * Useful for binding paths to form libraries or UI components.
+   *
+   * @example
+   * path<Root>().users[0].name.$; // "users.0.name"
+   */
+  get $() {
+    return this.toString();
+  }
+  /**
+   * Returns the string representation of the path (e.g. "users.0.name").
+   *
+   * @example
+   * path<Root>().users[0].name.toString(); // "users.0.name"
+   */
+  toString() {
+    return this.segments.join(".");
+  }
+  /**
+   * Extracts the value at this path from the given data object.
+   * Safely handles missing intermediate properties by returning `undefined` instead of throwing an error.
+   *
+   * @example
+   * const namePath = path<User>().name;
+   * const name = namePath.get({ name: "Alice" }); // "Alice"
+   */
+  get(data) {
+    let current = data;
+    for (const seg of this.segments) {
+      if (current == null) return void 0;
+      current = current[seg];
+    }
+    return current;
+  }
+  /**
+   * Returns an accessor function that extracts the value at this path from the given data object.
+   * Useful for array methods like `.map()` or `.filter()`.
+   *
+   * @example
+   * const names = users.map(path<User>().name.fn);
+   */
+  get fn() {
+    return (data) => this.get(data);
+  }
+  /**
+   * Sets the value at this path in the given data object, returning a new updated object (immutable).
+   * If intermediate properties are missing, they are automatically created as objects or arrays
+   * depending on the segment types (numeric keys become arrays).
+   *
+   * @example
+   * const namePath = path<User>().name;
+   * const updatedUser = namePath.set({ name: "Alice" }, "Bob"); // { name: "Bob" }
+   */
+  set(data, value) {
+    if (this.segments.length === 0) return value;
+    const setAt = (obj, segs, val) => {
+      if (segs.length === 1) {
+        const key = segs[0];
+        if (Array.isArray(obj)) {
+          const arr = [...obj];
+          arr[key] = val;
+          return arr;
+        }
+        return { ...obj, [key]: val };
+      }
+      const [first, ...rest] = segs;
+      const baseObj2 = obj;
+      const next = baseObj2[first];
+      const nextCopy = next != null && typeof next === "object" ? Array.isArray(next) ? [...next] : { ...next } : typeof rest[0] === "number" ? [] : {};
+      if (Array.isArray(baseObj2)) {
+        const arr = [...baseObj2];
+        arr[first] = setAt(nextCopy, rest, val);
+        return arr;
+      }
+      return { ...baseObj2, [first]: setAt(nextCopy, rest, val) };
+    };
+    const baseObj = typeof data === "object" && data !== null ? Array.isArray(data) ? [...data] : { ...data } : data;
+    return setAt(baseObj, this.segments, value);
+  }
+  /**
+   * Traverses into a collection (Array or Record) to operate on each item.
+   *
+   * @example
+   * const users = path<Root>().users;
+   * const userNames = users.each(u => u.name); // Path matches all names
+   */
+  each(expr) {
+    let tailSegments = [];
+    if (expr) {
+      const proxy = createPathProxy([]);
+      const result = expr(proxy);
+      tailSegments = result?.[PATH_SEGMENTS] ?? [];
+    }
+    return new TemplatePathCtor([...this.segments, WILDCARD, ...tailSegments]);
+  }
+  /**
+   * Traverses deeply into a structure, matching any nested property.
+   *
+   * @example
+   * const root = path<Root>();
+   * const allIds = root.deep(node => node.id); // Path matches any 'id' at any depth
+   */
+  deep(expr) {
+    let tailSegments = [];
+    if (expr) {
+      const proxy = createPathProxy([]);
+      const result = expr(proxy);
+      tailSegments = result?.[PATH_SEGMENTS] ?? [];
+    }
+    return new TemplatePathCtor([
+      ...this.segments,
+      DEEP_WILDCARD,
+      ...tailSegments
+    ]);
+  }
+  /**
+   * Checks if this path starts with the segments of another path.
+   *
+   * @example
+   * const a = path<Root>().users[0].name;
+   * const b = path<Root>().users;
+   * a.startsWith(b); // true
+   */
+  startsWith(other) {
+    return matchesPrefix(this.segments, resolveSegments(other));
+  }
+  /**
+   * Checks if this path encompasses the segments of another path (i.e., this path is a prefix of the other).
+   *
+   * @example
+   * const a = path<Root>().users;
+   * const b = path<Root>().users[0].name;
+   * a.includes(b); // true
+   */
+  includes(other) {
+    return matchesPrefix(resolveSegments(other), this.segments);
+  }
+  /**
+   * Checks if this path is exactly equal to another path.
+   *
+   * @example
+   * const a = path<Root>().users;
+   * const b = path<Root>().users;
+   * a.equals(b); // true
+   */
+  equals(other) {
+    return segmentsEqual(this.segments, resolveSegments(other));
+  }
+  /**
+   * Matches this path against another path, returning their relationship.
+   *
+   * @example
+   * const a = path<Root>().users[0];
+   * const b = path<Root>().users;
+   * a.match(b); // { relation: 'child', params: {} }
+   */
+  match(other) {
+    const otherSegs = resolveSegments(other);
+    if (segmentsEqual(this.segments, otherSegs)) {
+      return { relation: "equals", params: {} };
+    }
+    if (matchesPrefix(this.segments, otherSegs) && this.segments.length > otherSegs.length) {
+      return { relation: "child", params: {} };
+    }
+    if (matchesPrefix(otherSegs, this.segments) && otherSegs.length > this.segments.length) {
+      return { relation: "parent", params: {} };
+    }
+    if (patternMatches(this.segments, otherSegs)) {
+      return { relation: "includes", params: {} };
+    }
+    if (patternMatches(otherSegs, this.segments)) {
+      return { relation: "included-by", params: {} };
+    }
+    return null;
+  }
+  /**
+   * Appends another path to the end of this path. If the end of this path matches
+   * the beginning of the other path, the overlapping segments are intelligently deduplicated.
+   *
+   * @example
+   * const base = path<Root>().users;
+   * const full = base.merge(p => p[0].name); // equivalent to path<Root>().users[0].name
+   */
+  merge(other) {
+    const a = this.segments;
+    const b = resolveSegments(other);
+    let overlapLen = 0;
+    for (let len = Math.min(a.length, b.length); len >= 1; len--) {
+      const aSuffix = a.slice(-len);
+      const bPrefix = b.slice(0, len);
+      if (segmentsEqual(aSuffix, bPrefix)) {
+        overlapLen = len;
+        break;
+      }
+    }
+    const merged = overlapLen > 0 ? [...a.slice(0, -overlapLen), ...b] : [...a, ...b];
+    return new _PathImpl(merged);
+  }
+  /**
+   * Removes the segments of another path from either the beginning or the end of this path.
+   * Returns `null` if the other path is neither a prefix nor a suffix.
+   *
+   * @example
+   * const full = path<Root>().users[0].name;
+   * const base = path<Root>().users;
+   * const remainder = full.subtract(base); // equivalent to path()[0].name
+   */
+  subtract(other) {
+    const a = this.segments;
+    const b = resolveSegments(other);
+    if (b.length > a.length) return null;
+    if (segmentsEqual(a, b)) return new _PathImpl([]);
+    if (segmentsEqual(a.slice(0, b.length), b)) {
+      return new _PathImpl(a.slice(b.length));
+    }
+    if (segmentsEqual(a.slice(-b.length), b)) {
+      return new _PathImpl(a.slice(0, -b.length));
+    }
+    return null;
+  }
+  /**
+   * Returns a new path containing a subset of the segments, similar to Array.prototype.slice.
+   *
+   * @example
+   * const full = path<Root>().users[0].name;
+   * full.slice(0, 1); // equivalent to path<Root>().users
+   */
+  slice(start, end) {
+    const s = this.segments.slice(start, end);
+    return new _PathImpl(s);
+  }
+  /**
+   * Extends the current path using a lambda expression starting from the resolved value.
+   *
+   * @example
+   * const userPath = path<Root>().users[0];
+   * const namePath = userPath.to(u => u.name);
+   */
+  to(expr) {
+    const proxy = createPathProxy([]);
+    const result = expr(proxy);
+    const tailSegments = result?.[PATH_SEGMENTS] ?? [];
+    return new _PathImpl([...this.segments, ...tailSegments]);
+  }
+};
+
+// src/impl/template-path-impl.ts
+var TemplatePathImpl = class _TemplatePathImpl extends PathImpl {
+  /**
+   * Traverses into a collection (Array or Record) to operate on each item, returning a TemplatePath.
+   *
+   * @example
+   * const users = path<Root>().users;
+   * const userNames = users.each(u => u.name); // TemplatePath matching all names
+   */
+  each(expr) {
+    let tailSegments = [];
+    if (expr) {
+      const proxy = createPathProxy([]);
+      const result = expr(proxy);
+      tailSegments = result?.[PATH_SEGMENTS] ?? [];
+    }
+    return new _TemplatePathImpl([
+      ...this.segments,
+      WILDCARD,
+      ...tailSegments
+    ]);
+  }
+  /**
+   * Traverses deeply into a structure, matching any nested property, returning a TemplatePath.
+   *
+   * @example
+   * const root = path<Root>();
+   * const allIds = root.deep(node => node.id); // TemplatePath matching any 'id' at any depth
+   */
+  deep(expr) {
+    let tailSegments = [];
+    if (expr) {
+      const proxy = createPathProxy([]);
+      const result = expr(proxy);
+      tailSegments = result?.[PATH_SEGMENTS] ?? [];
+    }
+    return new _TemplatePathImpl([
+      ...this.segments,
+      DEEP_WILDCARD,
+      ...tailSegments
+    ]);
+  }
+  /**
+   * Resolves this template path against actual data to return an array of concrete paths
+   * that exist in the given data.
+   *
+   * @example
+   * const template = path<Root>().users.each().name;
+   * const concretePaths = template.expand(data); // [path<Root>().users[0].name, ...]
+   */
+  expand(data) {
+    const results = [];
+    const walk = (currentData, segmentIdx, currentPath) => {
+      if (segmentIdx >= this.segments.length) {
+        results.push(new PathImpl(currentPath));
+        return;
+      }
+      const seg = this.segments[segmentIdx];
+      if (seg === WILDCARD) {
+        if (currentData != null && typeof currentData === "object") {
+          const keys = Array.isArray(currentData) ? Array.from(currentData.keys()) : Object.keys(currentData);
+          for (const key of keys) {
+            walk(
+              currentData[key],
+              segmentIdx + 1,
+              [...currentPath, key]
+            );
+          }
+        }
+      } else if (seg === DEEP_WILDCARD) {
+        walk(currentData, segmentIdx + 1, currentPath);
+        if (currentData != null && typeof currentData === "object") {
+          const keys = Array.isArray(currentData) ? Array.from(currentData.keys()) : Object.keys(currentData);
+          for (const key of keys) {
+            walk(
+              currentData[key],
+              segmentIdx,
+              [...currentPath, key]
+            );
+          }
+        }
+      } else {
+        if (currentData != null && typeof currentData === "object" && seg in currentData) {
+          walk(
+            currentData[seg],
+            segmentIdx + 1,
+            [...currentPath, seg]
+          );
+        }
+      }
+    };
+    walk(data, 0, []);
+    return results;
+  }
+  /**
+   * Extracts an array of values at this template path from the given data object.
+   *
+   * @example
+   * const names = path<Root>().users.each().name.get(data); // string[]
+   */
+  // @ts-expect-error Overriding get to return an array instead of a single value
+  get(data) {
+    return this.expand(data).map((p) => p.get(data));
+  }
+  /**
+   * Returns an accessor function that extracts an array of values at this template path from the given data object.
+   * Useful for array methods like `.map()` or `.filter()`.
+   *
+   * @example
+   * const allNames = companies.map(path<Company>().departments.each().name.fn);
+   */
+  // @ts-expect-error Overriding fn to return an array instead of a single value
+  get fn() {
+    return (data) => this.get(data);
+  }
+  /**
+   * Sets the provided value to all matching paths immutably.
+   *
+   * @example
+   * const updatedData = path<Root>().users.each().name.set(data, "Bob");
+   */
+  set(data, value) {
+    const paths = this.expand(data);
+    let current = data;
+    for (const p of paths) {
+      current = p.set(current, value);
+    }
+    return current;
+  }
+};
+
+// src/path.ts
+setTemplatePathCtor(TemplatePathImpl);
+function path(baseOrExpr, expr) {
+  if (!baseOrExpr) {
+    return new PathImpl([]);
+  }
+  if (typeof baseOrExpr === "function") {
+    const proxy = createPathProxy([]);
+    const result = baseOrExpr(proxy);
+    const segments = result?.[PATH_SEGMENTS] ?? [];
+    return new PathImpl(segments);
+  }
+  const baseSegments = baseOrExpr.segments;
+  if (expr) {
+    if (typeof expr === "function") {
+      const proxy = createPathProxy([]);
+      const result = expr(proxy);
+      const tailSegments = result?.[PATH_SEGMENTS] ?? [];
+      return new PathImpl([...baseSegments, ...tailSegments]);
+    } else if (typeof expr === "object" && "segments" in expr) {
+      return new PathImpl([
+        ...baseSegments,
+        ...expr.segments
+      ]);
+    }
+  }
+  return new PathImpl(baseSegments);
+}
+function unsafePath(raw) {
+  const segments = raw ? raw.split(".").map((s) => s === "" ? s : isCanonicalArrayIndex(s) ? Number(s) : s) : [];
+  return new PathImpl(segments);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  path,
+  unsafePath
+});