data-path 1.0.2 → 2.0.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/constants.ts","../src/utils.ts","../src/impl/base-path-impl.ts","../src/impl/path-impl.ts","../src/path.ts"],"sourcesContent":["export const PATH_SEGMENTS = Symbol(\"PATH_SEGMENTS\");\n\n/**\n * Sentinel for a single-level wildcard segment (`each`).\n *\n * Stored as a unique Symbol — NOT the string `\"*\"` — so that a legitimate\n * object key named `\"*\"` is preserved as a literal segment and never\n * reinterpreted as a wildcard by `.get`, `.expand`, `.covers`, `.match`, etc.\n *\n * Renders as `\"*\"` in `toString()` / `.$` for dot-notation compatibility.\n */\nexport const WILDCARD: unique symbol = Symbol(\"WILDCARD\");\n\n/**\n * Sentinel for a deep wildcard segment (`deep`).\n *\n * Same rationale as {@link WILDCARD}: stored as a unique Symbol so the\n * literal string `\"**\"` remains a valid (literal) object key.\n *\n * Renders as `\"**\"` in `toString()` / `.$`.\n */\nexport const DEEP_WILDCARD: unique symbol = Symbol(\"DEEP_WILDCARD\");\n","import { DEEP_WILDCARD, PATH_SEGMENTS, WILDCARD } from \"./constants.js\";\nimport type { ResolvablePath, Segment } from \"./types.js\";\n\n/**\n * Returns true only for strings that are the canonical representation of a\n * non-negative integer (e.g. \"0\", \"1\", \"123\"). Rejects \"01\", \"1e3\", \"-1\", etc.,\n * so that numeric-looking object keys are preserved as strings.\n */\nexport function isCanonicalArrayIndex(key: string): boolean {\n\tconst num = Number(key);\n\treturn (\n\t\tNumber.isInteger(num) && num >= 0 && num < 2 ** 32 && String(num) === key\n\t);\n}\n\nexport function resolveSegments(\n\ttarget: ResolvablePath<any>,\n): readonly Segment[] {\n\tif (typeof target === \"function\") {\n\t\tconst proxy = createPathProxy([]);\n\t\tconst result = target(proxy) as unknown;\n\t\treturn (\n\t\t\t((result as Record<symbol, unknown>)?.[PATH_SEGMENTS] as Segment[]) ?? []\n\t\t);\n\t}\n\tif (target != null && typeof target === \"object\" && \"segments\" in target) {\n\t\treturn (target as { segments: readonly Segment[] }).segments;\n\t}\n\treturn [];\n}\n\n// Returns `any` intentionally — the proxy is typed by the caller via PathExpression<T, V>\nexport function createPathProxy(segments: readonly Segment[]): any {\n\treturn new Proxy(\n\t\t{ [PATH_SEGMENTS]: segments },\n\t\t{\n\t\t\tget(target, key) {\n\t\t\t\tif (key === PATH_SEGMENTS)\n\t\t\t\t\treturn target[PATH_SEGMENTS as keyof typeof target];\n\t\t\t\t// Symbols (other than PATH_SEGMENTS) return undefined — not recordable segments\n\t\t\t\tif (typeof key === \"symbol\") return undefined;\n\t\t\t\t// Every string key becomes a new path segment\n\t\t\t\tconst next: Segment = isCanonicalArrayIndex(key) ? Number(key) : key;\n\t\t\t\treturn createPathProxy([...segments, next]);\n\t\t\t},\n\t\t},\n\t);\n}\n\nexport function segmentsEqual(\n\ta: readonly Segment[],\n\tb: readonly Segment[],\n): boolean {\n\tif (a.length !== b.length) return false;\n\treturn a.every((s, i) => s === b[i]);\n}\n\nexport function matchesPrefix(\n\tfull: readonly Segment[],\n\tprefix: readonly Segment[],\n): boolean {\n\t// Quick reject: only when prefix is too long even after every `**` collapses\n\t// to zero segments. (Each `**` can skip 0..N segments, so each one effectively\n\t// subtracts one from the minimum prefix length.)\n\tlet minPrefixLen = 0;\n\tfor (const s of prefix) if (s !== DEEP_WILDCARD) minPrefixLen++;\n\tif (minPrefixLen > full.length) return false;\n\n\tlet p = 0;\n\tlet f = 0;\n\twhile (p < prefix.length) {\n\t\tif (prefix[p] === DEEP_WILDCARD) {\n\t\t\tif (p === prefix.length - 1) return true;\n\t\t\tconst restPrefix = prefix.slice(p + 1);\n\t\t\tfor (let skip = 0; f + skip <= full.length; skip++) {\n\t\t\t\tif (matchesPrefix(full.slice(f + skip), restPrefix)) return true;\n\t\t\t}\n\t\t\treturn false;\n\t\t}\n\t\tif (f >= full.length) return false;\n\t\tif (prefix[p] !== WILDCARD && prefix[p] !== full[f]) return false;\n\t\tp++;\n\t\tf++;\n\t}\n\treturn p === prefix.length;\n}\n\n/**\n * Returns `true` iff `pattern` matches `concrete` exactly when wildcards\n * are expanded:\n *   - `WILDCARD` (`*`) consumes exactly one segment.\n *   - `DEEP_WILDCARD` (`**`) consumes zero or more segments.\n *   - all other segments must be `===` to the corresponding concrete segment.\n *\n * Lengths need not match: a single `**` lets the pattern collapse to a\n * shorter concrete or stretch to a longer one. This is the \"covers\"\n * relation used by `.match()` and is broader than `matchesPrefix`, which\n * only requires the pattern to match a leading slice.\n */\nexport function patternMatches(\n\tpattern: readonly Segment[],\n\tconcrete: readonly Segment[],\n): boolean {\n\tfunction walk(pi: number, ci: number): boolean {\n\t\tif (pi === pattern.length) return ci === concrete.length;\n\t\tconst seg = pattern[pi];\n\t\tif (seg === DEEP_WILDCARD) {\n\t\t\tfor (let skip = 0; ci + skip <= concrete.length; skip++) {\n\t\t\t\tif (walk(pi + 1, ci + skip)) return true;\n\t\t\t}\n\t\t\treturn false;\n\t\t}\n\t\tif (ci === concrete.length) return false;\n\t\tif (seg === WILDCARD) return walk(pi + 1, ci + 1);\n\t\tif (seg !== concrete[ci]) return false;\n\t\treturn walk(pi + 1, ci + 1);\n\t}\n\treturn walk(0, 0);\n}\n\nfunction hasWildcardSegment(segments: readonly Segment[]): boolean {\n\tfor (const s of segments) {\n\t\tif (s === WILDCARD || s === DEEP_WILDCARD) return true;\n\t}\n\treturn false;\n}\n\n/**\n * Returns `true` iff `segments` contains a wildcard sentinel\n * (`WILDCARD` or `DEEP_WILDCARD`).\n */\nexport { hasWildcardSegment };\n","import { DEEP_WILDCARD, WILDCARD } from \"../constants.js\";\nimport type {\n\tMatchResult,\n\tPath,\n\tResolvablePath,\n\tSegment,\n\tTemplatePath,\n} from \"../types.js\";\nimport {\n\thasWildcardSegment,\n\tmatchesPrefix,\n\tpatternMatches,\n\tresolveSegments,\n\tsegmentsEqual,\n} from \"../utils.js\";\n\n/**\n * Shared structural base for PathImpl and TemplatePathImpl.\n * Contains all methods that do not depend on how a path reads, writes, or\n * creates new concrete path instances.\n */\nexport abstract class AbstractPathImpl<T = unknown, V = unknown> {\n\treadonly segments: readonly Segment[];\n\n\tconstructor(segments: readonly Segment[]) {\n\t\tthis.segments = segments;\n\t}\n\n\tget length(): number {\n\t\treturn this.segments.length;\n\t}\n\n\tget $(): string {\n\t\treturn this.toString();\n\t}\n\n\ttoString(): string {\n\t\treturn this.segments\n\t\t\t.map((s) =>\n\t\t\t\ts === WILDCARD ? \"*\" : s === DEEP_WILDCARD ? \"**\" : String(s),\n\t\t\t)\n\t\t\t.join(\".\");\n\t}\n\n\tstartsWith(other: ResolvablePath<T>): boolean {\n\t\treturn matchesPrefix(this.segments, resolveSegments(other));\n\t}\n\n\tcovers(other: ResolvablePath<T>): boolean {\n\t\treturn matchesPrefix(resolveSegments(other), this.segments);\n\t}\n\n\tequals(other: ResolvablePath<T>): boolean {\n\t\treturn segmentsEqual(this.segments, resolveSegments(other));\n\t}\n\n\tmatch(other: ResolvablePath<T>): MatchResult | null {\n\t\tconst otherSegs = resolveSegments(other);\n\t\tif (segmentsEqual(this.segments, otherSegs)) return { relation: \"equals\" };\n\n\t\t// Check wildcard coverage BEFORE literal prefix. patternMatches handles\n\t\t// `**` collapsing, so a deep template can fully cover a concrete path of\n\t\t// any length — that's a \"covers\", not \"parent\". Order matters: a literal\n\t\t// prefix check that's wildcard-aware (via matchesPrefix) would otherwise\n\t\t// misclassify \"a.**.b covers a.x.y.b\" as \"parent\".\n\t\tif (patternMatches(this.segments, otherSegs)) return { relation: \"covers\" };\n\t\tif (patternMatches(otherSegs, this.segments))\n\t\t\treturn { relation: \"covered-by\" };\n\n\t\t// Literal parent/child: the shorter side must be wildcard-free, otherwise\n\t\t// it's not a literal prefix.\n\t\tif (\n\t\t\t!hasWildcardSegment(otherSegs) &&\n\t\t\tmatchesPrefix(this.segments, otherSegs) &&\n\t\t\tthis.segments.length > otherSegs.length\n\t\t)\n\t\t\treturn { relation: \"child\" };\n\t\tif (\n\t\t\t!hasWildcardSegment(this.segments) &&\n\t\t\tmatchesPrefix(otherSegs, this.segments) &&\n\t\t\totherSegs.length > this.segments.length\n\t\t)\n\t\t\treturn { relation: \"parent\" };\n\t\treturn null;\n\t}\n\n\t// Abstract — implementations create PathImpl or TemplatePathImpl instances which live in path-impl.ts.\n\t// TemplatePathImpl widens these to also allow returning a TemplatePath when the resulting\n\t// segments still contain wildcards.\n\tabstract parent(): Path<T, unknown> | TemplatePath<T, unknown> | null;\n\tabstract subtract<U>(\n\t\tprefix: ResolvablePath<T, U>,\n\t): Path<U, V> | TemplatePath<U, V> | null;\n\tabstract slice(\n\t\tstart?: number,\n\t\tend?: number,\n\t): Path<T, unknown> | TemplatePath<T, unknown>;\n}\n\n// Re-export constants used by both PathImpl and TemplatePathImpl so callers\n// don't need an extra import just for the wildcard check.\nexport { DEEP_WILDCARD, WILDCARD };\n","import { PATH_SEGMENTS } from \"../constants.js\";\nimport type {\n\tBasePath,\n\tCollectionItem,\n\tPath,\n\tResolvablePath,\n\tSegment,\n\tTemplatePath,\n\tTraversablePathMethods,\n} from \"../types.js\";\nimport { createPathProxy, resolveSegments, segmentsEqual } from \"../utils.js\";\nimport { AbstractPathImpl, DEEP_WILDCARD, WILDCARD } from \"./base-path-impl.js\";\n\n// ---------------------------------------------------------------------------\n// PathImpl — concrete path with no wildcards\n// ---------------------------------------------------------------------------\n\nexport class PathImpl<T = unknown, V = unknown>\n\textends AbstractPathImpl<T, V>\n\timplements BasePath<T, V>, TraversablePathMethods<T, V>\n{\n\treadonly fn: (data: T) => V | undefined;\n\n\tconstructor(segments: readonly Segment[]) {\n\t\tsuper(segments);\n\t\tthis.fn = (data: T) => this.get(data);\n\t}\n\n\tget(data: T): V | undefined {\n\t\tlet current: unknown = data;\n\t\tfor (const seg of this.segments) {\n\t\t\tif (current == null) return undefined;\n\t\t\tcurrent = (current as Record<PropertyKey, unknown>)[seg];\n\t\t}\n\t\treturn current as V | undefined;\n\t}\n\n\tset(data: T, value: V): T {\n\t\tif (this.segments.length === 0) return value as unknown as T;\n\n\t\tconst setAt = (\n\t\t\tobj: unknown,\n\t\t\tsegs: readonly Segment[],\n\t\t\tval: unknown,\n\t\t): unknown => {\n\t\t\tif (segs.length === 1) {\n\t\t\t\tconst key = segs[0];\n\t\t\t\tif (Array.isArray(obj)) {\n\t\t\t\t\tconst arr = [...obj];\n\t\t\t\t\tarr[key as number] = val;\n\t\t\t\t\treturn arr;\n\t\t\t\t}\n\t\t\t\treturn { ...(obj as object), [key]: val };\n\t\t\t}\n\t\t\tconst [first, ...rest] = segs;\n\t\t\tconst baseObj = obj as Record<PropertyKey, unknown>;\n\t\t\tconst next = baseObj[first];\n\t\t\tconst nextCopy =\n\t\t\t\tnext != null && typeof next === \"object\"\n\t\t\t\t\t? Array.isArray(next)\n\t\t\t\t\t\t? [...next]\n\t\t\t\t\t\t: { ...next }\n\t\t\t\t\t: typeof rest[0] === \"number\"\n\t\t\t\t\t\t? []\n\t\t\t\t\t\t: {};\n\t\t\tif (Array.isArray(baseObj)) {\n\t\t\t\tconst arr = [...baseObj];\n\t\t\t\tarr[first as number] = setAt(nextCopy, rest, val) as never;\n\t\t\t\treturn arr;\n\t\t\t}\n\t\t\treturn { ...baseObj, [first]: setAt(nextCopy, rest, val) };\n\t\t};\n\n\t\tconst baseObj =\n\t\t\ttypeof data === \"object\" && data !== null\n\t\t\t\t? Array.isArray(data)\n\t\t\t\t\t? [...data]\n\t\t\t\t\t: { ...data }\n\t\t\t\t: data;\n\t\treturn setAt(baseObj, this.segments, value) as T;\n\t}\n\n\tupdate(data: T, updater: (current: V | undefined) => V): T {\n\t\treturn this.set(data, updater(this.get(data)));\n\t}\n\n\tparent(): Path<T, unknown> | null {\n\t\tif (this.segments.length === 0) return null;\n\t\treturn makeConcrete<T, unknown>(\n\t\t\tthis.segments.slice(0, -1),\n\t\t) as unknown as Path<T, unknown>;\n\t}\n\n\tsubtract<U>(prefix: ResolvablePath<T, U>): Path<U, V> | null {\n\t\tconst a = this.segments;\n\t\tconst b = resolveSegments(prefix);\n\t\tif (b.length > a.length) return null;\n\t\tif (!segmentsEqual(a.slice(0, b.length), b)) return null;\n\t\treturn makeConcrete<U, V>(a.slice(b.length)) as unknown as Path<U, V>;\n\t}\n\n\tslice(start?: number, end?: number): Path<T, unknown> {\n\t\treturn makeConcrete<T, unknown>(\n\t\t\tthis.segments.slice(start, end),\n\t\t) as unknown as Path<T, unknown>;\n\t}\n\n\teach<U = CollectionItem<V>>(\n\t\texpr?: (item: CollectionItem<V>) => U,\n\t): TemplatePath<T, U> {\n\t\tconst tail = expr ? evalExpr(expr as (p: unknown) => unknown) : [];\n\t\treturn new TemplatePathImpl<T, U>([\n\t\t\t...this.segments,\n\t\t\tWILDCARD,\n\t\t\t...tail,\n\t\t]) as unknown as TemplatePath<T, U>;\n\t}\n\n\tdeep<U = V>(expr?: (leaf: V) => U): TemplatePath<T, U> {\n\t\tconst tail = expr ? evalExpr(expr as (p: unknown) => unknown) : [];\n\t\treturn new TemplatePathImpl<T, U>([\n\t\t\t...this.segments,\n\t\t\tDEEP_WILDCARD,\n\t\t\t...tail,\n\t\t]) as unknown as TemplatePath<T, U>;\n\t}\n\n\tto<U>(relative: ResolvablePath<V, U>): Path<T, U> | TemplatePath<T, U> {\n\t\treturn makeFromSegments<T, U>([\n\t\t\t...this.segments,\n\t\t\t...resolveSegments(relative),\n\t\t]) as unknown as Path<T, U> | TemplatePath<T, U>;\n\t}\n\n\tmerge<U>(other: ResolvablePath<T, U>): Path<T, U> | TemplatePath<T, U> {\n\t\treturn makeFromSegments<T, U>(\n\t\t\tmergeSegments(this.segments, resolveSegments(other)),\n\t\t) as unknown as Path<T, U> | TemplatePath<T, U>;\n\t}\n}\n\n/**\n * Returns a concrete `PathImpl` when `segments` contains no wildcard\n * sentinels, otherwise a `TemplatePathImpl` so `.get()` correctly expands\n * matches.\n *\n * Safe by construction: wildcards are unique Symbols (see\n * {@link WILDCARD} / {@link DEEP_WILDCARD}). Legitimate object keys named\n * `\"*\"` or `\"**\"` are stored as strings and never trigger the template\n * branch.\n */\nfunction makeFromSegments<T, V>(\n\tsegments: readonly Segment[],\n): PathImpl<T, V> | TemplatePathImpl<T, V> {\n\treturn hasWildcard(segments)\n\t\t? new TemplatePathImpl<T, V>(segments)\n\t\t: new PathImpl<T, V>(segments);\n}\n\nfunction hasWildcard(segments: readonly Segment[]): boolean {\n\tfor (const s of segments) {\n\t\tif (s === WILDCARD || s === DEEP_WILDCARD) return true;\n\t}\n\treturn false;\n}\n\n// ---------------------------------------------------------------------------\n// TemplatePathImpl — path containing * or ** wildcards\n// ---------------------------------------------------------------------------\n\nexport class TemplatePathImpl<\n\tT = unknown,\n\tV = unknown,\n> extends AbstractPathImpl<T, V> {\n\t// fn returns V[] (not V|undefined) — no covariance conflict since we don't\n\t// extend PathImpl; the declared type here matches TemplatePath<T,V>.fn.\n\treadonly fn: (data: T) => V[];\n\n\tconstructor(segments: readonly Segment[]) {\n\t\tsuper(segments);\n\t\tthis.fn = (data: T) => this.get(data);\n\t}\n\n\tget(data: T): V[] {\n\t\treturn this.expand(data).map(\n\t\t\t// expand() only returns paths where the key exists in data, so get() is safe\n\t\t\t(p) => p.get(data) as V,\n\t\t);\n\t}\n\n\tset(data: T, value: V): T {\n\t\tconst paths = this.expand(data);\n\t\tlet current = data;\n\t\tfor (const p of paths) {\n\t\t\tcurrent = p.set(current, value);\n\t\t}\n\t\treturn current;\n\t}\n\n\t/**\n\t * Applies `updater` to each matched value individually (per-item transform).\n\t * Use `.set(data, constant)` to assign the same value to every match.\n\t */\n\tupdate(data: T, updater: (current: V | undefined) => V): T {\n\t\tconst paths = this.expand(data);\n\t\tlet current = data;\n\t\tfor (const p of paths) {\n\t\t\tcurrent = p.set(current, updater(p.get(current)));\n\t\t}\n\t\treturn current;\n\t}\n\n\tparent(): Path<T, unknown> | TemplatePath<T, unknown> | null {\n\t\tif (this.segments.length === 0) return null;\n\t\treturn makeFromSegments<T, unknown>(\n\t\t\tthis.segments.slice(0, -1),\n\t\t) as unknown as Path<T, unknown> | TemplatePath<T, unknown>;\n\t}\n\n\tsubtract<U>(\n\t\tprefix: ResolvablePath<T, U>,\n\t): Path<U, V> | TemplatePath<U, V> | null {\n\t\tconst a = this.segments;\n\t\tconst b = resolveSegments(prefix);\n\t\tif (b.length > a.length) return null;\n\t\tif (!segmentsEqual(a.slice(0, b.length), b)) return null;\n\t\treturn makeFromSegments<U, V>(a.slice(b.length)) as unknown as\n\t\t\t| Path<U, V>\n\t\t\t| TemplatePath<U, V>;\n\t}\n\n\tslice(\n\t\tstart?: number,\n\t\tend?: number,\n\t): Path<T, unknown> | TemplatePath<T, unknown> {\n\t\treturn makeFromSegments<T, unknown>(\n\t\t\tthis.segments.slice(start, end),\n\t\t) as unknown as Path<T, unknown> | TemplatePath<T, unknown>;\n\t}\n\n\teach<U = CollectionItem<V>>(\n\t\texpr?: (item: CollectionItem<V>) => U,\n\t): TemplatePath<T, U> {\n\t\tconst tail = expr ? evalExpr(expr as (p: unknown) => unknown) : [];\n\t\treturn new TemplatePathImpl<T, U>([\n\t\t\t...this.segments,\n\t\t\tWILDCARD,\n\t\t\t...tail,\n\t\t]) as unknown as TemplatePath<T, U>;\n\t}\n\n\tdeep<U = V>(expr?: (leaf: V) => U): TemplatePath<T, U> {\n\t\tconst tail = expr ? evalExpr(expr as (p: unknown) => unknown) : [];\n\t\treturn new TemplatePathImpl<T, U>([\n\t\t\t...this.segments,\n\t\t\tDEEP_WILDCARD,\n\t\t\t...tail,\n\t\t]) as unknown as TemplatePath<T, U>;\n\t}\n\n\tto<U>(relative: ResolvablePath<V, U>): TemplatePath<T, U> {\n\t\tconst tail = resolveSegments(relative);\n\t\treturn new TemplatePathImpl<T, U>([\n\t\t\t...this.segments,\n\t\t\t...tail,\n\t\t]) as unknown as TemplatePath<T, U>;\n\t}\n\n\tmerge<U>(other: ResolvablePath<T, U>): TemplatePath<T, U> {\n\t\treturn new TemplatePathImpl<T, U>(\n\t\t\tmergeSegments(this.segments, resolveSegments(other)),\n\t\t) as unknown as TemplatePath<T, U>;\n\t}\n\n\t/**\n\t * Resolves this template to all concrete paths that exist in `data`.\n\t */\n\texpand(data: T): Path<T, V>[] {\n\t\tconst results: Path<T, V>[] = [];\n\n\t\tconst walk = (current: unknown, idx: number, acc: Segment[]): void => {\n\t\t\tif (idx >= this.segments.length) {\n\t\t\t\tresults.push(new PathImpl<T, V>(acc));\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst seg = this.segments[idx];\n\n\t\t\tif (seg === WILDCARD) {\n\t\t\t\tif (current != null && typeof current === \"object\") {\n\t\t\t\t\tconst keys = Array.isArray(current)\n\t\t\t\t\t\t? (Array.from(current.keys()) as number[])\n\t\t\t\t\t\t: Object.keys(current);\n\t\t\t\t\tfor (const key of keys) {\n\t\t\t\t\t\twalk((current as Record<PropertyKey, unknown>)[key], idx + 1, [\n\t\t\t\t\t\t\t...acc,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (seg === DEEP_WILDCARD) {\n\t\t\t\t// Try matching rest of pattern at current depth\n\t\t\t\twalk(current, idx + 1, acc);\n\t\t\t\t// Recurse into every child\n\t\t\t\tif (current != null && typeof current === \"object\") {\n\t\t\t\t\tconst keys = Array.isArray(current)\n\t\t\t\t\t\t? (Array.from(current.keys()) as number[])\n\t\t\t\t\t\t: Object.keys(current);\n\t\t\t\t\tfor (const key of keys) {\n\t\t\t\t\t\twalk((current as Record<PropertyKey, unknown>)[key], idx, [\n\t\t\t\t\t\t\t...acc,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (\n\t\t\t\t\tcurrent != null &&\n\t\t\t\t\ttypeof current === \"object\" &&\n\t\t\t\t\tseg in (current as object)\n\t\t\t\t) {\n\t\t\t\t\twalk((current as Record<PropertyKey, unknown>)[seg], idx + 1, [\n\t\t\t\t\t\t...acc,\n\t\t\t\t\t\tseg,\n\t\t\t\t\t]);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\twalk(data, 0, []);\n\t\treturn results;\n\t}\n}\n\n// ---------------------------------------------------------------------------\n// Private helpers\n// ---------------------------------------------------------------------------\n\nfunction makeConcrete<T, V>(segments: readonly Segment[]): PathImpl<T, V> {\n\treturn new PathImpl<T, V>(segments);\n}\n\nfunction evalExpr(expr: (proxy: unknown) => unknown): readonly Segment[] {\n\tconst proxy = createPathProxy([]);\n\tconst result = expr(proxy);\n\treturn (\n\t\t((result as Record<symbol, unknown>)?.[PATH_SEGMENTS] as Segment[]) ?? []\n\t);\n}\n\nfunction mergeSegments(\n\ta: readonly Segment[],\n\tb: readonly Segment[],\n): readonly Segment[] {\n\tlet overlapLen = 0;\n\tfor (let len = Math.min(a.length, b.length); len >= 1; len--) {\n\t\tif (segmentsEqual(a.slice(-len), b.slice(0, len))) {\n\t\t\toverlapLen = len;\n\t\t\tbreak;\n\t\t}\n\t}\n\treturn overlapLen > 0 ? [...a.slice(0, -overlapLen), ...b] : [...a, ...b];\n}\n","import { PATH_SEGMENTS } from \"./constants.js\";\nimport { PathImpl } from \"./impl/path-impl.js\";\nimport type { BasePath, Path, PathExpression, Segment } from \"./types.js\";\nimport { createPathProxy, isCanonicalArrayIndex } from \"./utils.js\";\n\n/**\n * Create a typed path from a lambda expression, from an existing base path, or as a root.\n *\n * @example\n * // Lambda — recommended: annotate the parameter so both T and V are inferred\n * const p = path((user: User) => user.profile.firstName);\n *\n * @example\n * // Both generics explicit\n * const p = path<User, string>((u) => u.profile.firstName);\n *\n * @example\n * // Root path (no segments) — typically extended via .to() or path(root, expr)\n * const root = path<User>();\n *\n * @example\n * // Extend an existing base path\n * const p2 = path(root, (u) => u.profile);\n */\nexport function path<T>(): Path<T, T>;\nexport function path<T, V = unknown>(expr: PathExpression<T, V>): Path<T, V>;\nexport function path<T, U, V = unknown>(\n\tbase: BasePath<T, U>,\n\texpr: PathExpression<U, V>,\n): Path<T, V>;\nexport function path<T, V = unknown>(\n\tbaseOrExpr?: BasePath<T, unknown> | PathExpression<T, V>,\n\texpr?: PathExpression<unknown, V>,\n): Path<T, V> {\n\tif (baseOrExpr === undefined) {\n\t\treturn new PathImpl<T, V>([]);\n\t}\n\n\tif (typeof baseOrExpr === \"function\") {\n\t\tconst proxy = createPathProxy([]);\n\t\tconst result = (baseOrExpr as PathExpression<T, V>)(proxy);\n\t\tconst segments: Segment[] =\n\t\t\t((result as Record<symbol, unknown>)?.[PATH_SEGMENTS] as Segment[]) ?? [];\n\t\treturn new PathImpl<T, V>(segments);\n\t}\n\n\tconst baseSegments = (baseOrExpr as BasePath<T, unknown>).segments;\n\tif (expr !== undefined) {\n\t\tconst proxy = createPathProxy([]);\n\t\tconst result = (expr as PathExpression<unknown, V>)(proxy);\n\t\tconst tailSegments =\n\t\t\t((result as Record<symbol, unknown>)?.[PATH_SEGMENTS] as Segment[]) ?? [];\n\t\treturn new PathImpl<T, V>([...baseSegments, ...tailSegments]);\n\t}\n\n\treturn new PathImpl<T, V>(baseSegments);\n}\n\n/**\n * Create a path from a raw dot-separated string (e.g. `\"users.0.name\"`).\n *\n * Useful for dynamic paths from external sources (API responses, Zod issue paths, etc.).\n * Segments that are canonical non-negative integers are stored as numbers; all others as strings.\n *\n * The optional second generic `V` declares the expected leaf type without a cast:\n * ```ts\n * unsafePath<User, string>(\"profile.firstName\").get(user)  // string | undefined\n * ```\n *\n * @param raw Dot-separated string. Empty string returns a zero-segment root path.\n */\nexport function unsafePath<T, V = unknown>(raw: string): Path<T, V> {\n\tconst segments: Segment[] = raw\n\t\t? raw\n\t\t\t\t.split(\".\")\n\t\t\t\t.map((s) => (s === \"\" ? s : isCanonicalArrayIndex(s) ? Number(s) : s))\n\t\t: [];\n\treturn new PathImpl<T, V>(segments);\n}\n"],"mappings":"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","names":["baseObj"]}

package/package.json

@@ -1,70 +1,111 @@
 {
-  "name": "data-path",
-  "version": "1.0.2",
-  "description": "A simple, modern, zero-dependency, and fully type-safe library for building, comparing, and manipulating object property paths using TypeScript lambda expressions.",
-  "license": "ISC",
-  "type": "commonjs",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
-    "dev": "npm run build -- --watch",
-    "lint": "biome check src",
-    "lint:fix": "biome check --write src",
-    "prepare": "husky",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run --typecheck",
-    "test:watch": "vitest --typecheck"
-  },
-  "keywords": [
-    "typescript",
-    "path",
-    "object-path",
-    "type-safe",
-    "proxy",
-    "dot-notation",
-    "property-path",
-    "accessor",
-    "data-path"
-  ],
-  "author": {
-    "name": "Sergei Shmakov",
-    "url": "https://github.com/sergeyshmakov"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sergeyshmakov/data-path.git"
-  },
-  "bugs": {
-    "url": "https://github.com/sergeyshmakov/data-path/issues"
-  },
-  "homepage": "https://github.com/sergeyshmakov/data-path#readme",
-  "release": {
-    "branches": [
-      "main"
-    ]
-  },
-  "devDependencies": {
-    "@biomejs/biome": "2.4.6",
-    "@commitlint/cli": "^20.4.3",
-    "@commitlint/config-conventional": "^20.4.3",
-    "husky": "^9.1.7",
-    "semantic-release": "^25.0.3",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
-  },
-  "peerDependencies": {
-    "typescript": ">=5.0.0"
-  },
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "volta": {
-    "node": "24.14.0"
-  }
+	"name": "data-path",
+	"version": "2.0.0",
+	"description": "Type-safe object property paths in TypeScript — build, compare, and manipulate with lambda expressions. Zero dependencies.",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.js",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": {
+				"types": "./dist/index.d.cts",
+				"default": "./dist/index.cjs"
+			},
+			"default": "./dist/index.js"
+		}
+	},
+	"sideEffects": false,
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsup src/index.ts --format cjs,esm --dts --clean --sourcemap",
+		"dev": "npm run build -- --watch",
+		"lint": "biome check src",
+		"lint:fix": "biome check --write src",
+		"prepare": "husky",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run --typecheck",
+		"test:watch": "vitest --typecheck"
+	},
+	"keywords": [
+		"typescript",
+		"path",
+		"object-path",
+		"property-path",
+		"type-safe",
+		"proxy",
+		"lambda",
+		"dot-notation",
+		"accessor",
+		"immutable",
+		"path-algebra",
+		"state-management",
+		"form"
+	],
+	"author": {
+		"name": "Sergei Shmakov",
+		"url": "https://github.com/sergeyshmakov"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/sergeyshmakov/data-path.git"
+	},
+	"bugs": {
+		"url": "https://github.com/sergeyshmakov/data-path/issues"
+	},
+	"homepage": "https://sergeyshmakov.github.io/data-path/",
+	"release": {
+		"branches": [
+			"main"
+		],
+		"plugins": [
+			"@semantic-release/commit-analyzer",
+			"@semantic-release/release-notes-generator",
+			[
+				"@semantic-release/changelog",
+				{
+					"changelogFile": "CHANGELOG.md"
+				}
+			],
+			"@semantic-release/npm",
+			[
+				"@semantic-release/git",
+				{
+					"assets": [
+						"package.json",
+						"package-lock.json",
+						"CHANGELOG.md"
+					],
+					"message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+				}
+			],
+			"@semantic-release/github"
+		]
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.4.6",
+		"@commitlint/cli": "^20.4.3",
+		"@commitlint/config-conventional": "^20.4.3",
+		"@semantic-release/changelog": "^6.0.3",
+		"@semantic-release/git": "^10.0.1",
+		"husky": "^9.1.7",
+		"lint-staged": "^16.4.0",
+		"semantic-release": "^25.0.3",
+		"tsup": "^8.5.1",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.18"
+	},
+	"peerDependencies": {
+		"typescript": ">=5.0.0"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"volta": {
+		"node": "24.14.0"
+	}
 }

package/dist/index.d.mts

@@ -1,319 +0,0 @@
-/**
- * Core type definitions for data-path.
- * @see spec/idea.md
- */
-/** A path segment: string key or numeric index */
-type Segment = string | number;
-/** Relation returned by .match() */
-type MatchRelation = "includes" | "included-by" | "equals" | "parent" | "child" | null;
-/** Result of .match() — bidirectional relationship + optional params */
-interface MatchResult {
-    relation: MatchRelation;
-    params?: Record<string, string>;
-}
-/** Resolved type at the end of a path (leaf value type) */
-type ResolvedType<_T, _P extends string> = unknown;
-/** Deep-reachable types for .deep() leaf parameter (enables IDE autocomplete) */
-type DeepReachable<T> = T;
-/**
- * Extracts the item type from a collection (Array or Record) so that traversal methods
- * (like `.each()`) know what type of item they are iterating over.
- *
- * @template V The collection type (e.g., `string[]` or `Record<string, number>`)
- */
-type CollectionItem<V> = V extends ReadonlyArray<infer U> ? U : V extends Record<PropertyKey, infer U> ? U : unknown;
-/** Primitives that cannot have traversal methods called on them */
-type Primitive = string | number | boolean | symbol | bigint | null | undefined;
-/** Expression type for path construction — receives proxy, returns any (path is inferred from access) */
-type PathExpression<T, R = unknown> = (proxy: T) => R;
-/**
- * Represents the various forms a path can take when provided as an input argument.
- * This enables API flexibility, allowing methods (like `merge`, `match`, `startsWith`)
- * to accept an existing path object, a raw segments object, or a lambda expression.
- *
- * @template T The root data type.
- * @template V The resolved value type at the end of the path.
- */
-type ResolvablePath<T, V = unknown> = BasePath<T, V, string> | {
-    segments: readonly Segment[];
-} | PathExpression<T, V>;
-/**
- * Extracted methods for traversing into collections or deep structures.
- * This is separated from `BasePath` so that these methods can be conditionally
- * excluded from the type system when a path points to a primitive value
- * (since primitives cannot be traversed).
- */
-interface TraversablePathMethods<T, V> {
-    /**
-     * 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<U = CollectionItem<V>>(expr?: (item: CollectionItem<V>) => U): TemplatePath<T, U, string>;
-    /**
-     * 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<U = DeepReachable<V>>(expr?: (leaf: DeepReachable<V>) => U): TemplatePath<T, U, string>;
-}
-/**
- * The foundational structure for all path objects (both standard and template paths).
- * Contains common properties and operations including value extraction/mutation,
- * relational algebra (comparisons), and structural manipulation.
- *
- * @template T Root data type the path operates on.
- * @template V The expected value type that the path resolves to.
- * @template _P The string representation of the path (optional/unused in runtime, but useful for type-level strings).
- */
-interface BasePath<T = unknown, V = unknown, _P extends string = string> {
-    /**
-     * The array of segments (string keys or numeric indices) that make up this path.
-     */
-    readonly segments: readonly Segment[];
-    /**
-     * The number of segments in this path.
-     */
-    readonly length: number;
-    /**
-     * 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"
-     */
-    readonly $: _P;
-    /**
-     * Returns the string representation of the path (e.g. "users.0.name").
-     *
-     * @example
-     * path<Root>().users[0].name.toString(); // "users.0.name"
-     */
-    toString(): string;
-    /**
-     * 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: T): V;
-    /**
-     * 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);
-     */
-    readonly fn: (data: T) => V;
-    /**
-     * 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: T, value: V): T;
-    /**
-     * 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: ResolvablePath<T>): boolean;
-    /**
-     * 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: ResolvablePath<T>): boolean;
-    /**
-     * 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: ResolvablePath<T>): boolean;
-    /**
-     * 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: ResolvablePath<T>): MatchResult | 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<U>(other: ResolvablePath<T, U>): Path<T, U, string>;
-    /**
-     * 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: ResolvablePath<T>): Path<T, V, string> | 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?: number, end?: number): Path<T, unknown, string>;
-    /**
-     * 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<U>(expr: PathExpression<V, U>): Path<T, U, string>;
-}
-/**
- * Represents a strongly-typed object property path.
- *
- * This type uses intersection (`&`) to combine the base operations (`BasePath`)
- * with conditional traversal methods (`TraversablePathMethods`). The conditional
- * check `[V] extends [Primitive]` ensures that IDEs will not suggest `.each()` or
- * `.deep()` when the path has resolved to a primitive value (like a string or number).
- *
- * @template T Root data type
- * @template V Resolved value type at path end
- * @template P Path string (e.g. "a.b.c") — literal when inferrable, string when dynamic
- */
-type Path<T = unknown, V = unknown, P extends string = string> = BasePath<T, V, P> & ([V] extends [Primitive] ? {} : TraversablePathMethods<T, V>);
-/**
- * Represents a path containing wildcards (`*` or `**`), useful for operations on multiple items.
- *
- * It extends the standard `Path` concept but alters the return types of `.each()` and `.deep()`
- * to return another `TemplatePath` (chaining templates). It also adds the `.expand()` method
- * which can resolve this template against actual data to return an array of concrete `Path`s.
- *
- * **Data Access:** Calling `.get()` on a `TemplatePath` will return an array of all matched values.
- * Calling `.set()` will immutably update all matched paths in the object and return the updated object.
- *
- * @template T Root data type
- * @template V Resolved value type at path end
- * @template P Path string (e.g. "a.*.c")
- */
-type TemplatePath<T = unknown, V = unknown, P extends string = string> = (Omit<BasePath<T, V, P>, "get" | "fn"> & {
-    /**
-     * 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[]
-     */
-    get(data: T): V[];
-    /**
-     * 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);
-     */
-    readonly fn: (data: T) => V[];
-}) & ([V] extends [Primitive] ? {} : {
-    /**
-     * 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<U = CollectionItem<V>>(expr?: (item: CollectionItem<V>) => U): TemplatePath<T, U, `${string}.${"*"}.${string}`>;
-    /**
-     * 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<U = DeepReachable<V>>(expr?: (leaf: DeepReachable<V>) => U): TemplatePath<T, U, `${string}.${"**"}.${string}`>;
-}) & {
-    /**
-     * Resolves this template path against actual data to return an array of concrete paths
-     * that exist in the given data.
-     *
-     * Note: Currently, `expand` only supports evaluating a single wildcard (`*` or `**`) per path.
-     *
-     * @example
-     * const template = path<Root>().users.each().name;
-     * const concretePaths = template.expand(data); // [path<Root>().users[0].name, ...]
-     */
-    expand(data: T): Path<T, V, string>[];
-};
-/**
- * Constructor overloads for creating paths.
- *
- * This allows the `path()` function to be called in several ways:
- * 1. Without arguments: returns a root path `path<T>()`.
- * 2. With a lambda: returns a path built from the expression `path<T>((p) => p.a.b)`.
- * 3. With a base path and a lambda: allows extending an existing path `path(base, (p) => p.c)`.
- */
-type PathConstructor = {
-    <T>(): Path<T, T, "">;
-    <T, V = unknown>(expr: PathExpression<T, V>): Path<T, V, string>;
-    <T, U, V = unknown>(base: BasePath<T, U, string>, expr: PathExpression<U, V>): Path<T, V, string>;
-};
-/** Unsafe path from string — no type checking on segments */
-type UnsafePathConstructor = <T>(raw: string) => Path<T, unknown, string>;
-
-/**
- * Create a typed path from a lambda expression or extend an existing base path.
- *
- * This function serves as the primary entry point for constructing paths. By utilizing
- * a Proxy-based builder (the lambda expression), it captures property accesses and
- * records them as path segments without needing to evaluate actual data.
- *
- * @example
- * // Create a root path
- * const root = path<User>();
- *
- * @example
- * // Create a path via lambda
- * const p = path<User>((u) => u.address.city);
- *
- * @example
- * // Extend an existing path
- * const p2 = path(root, (u) => u.profile);
- */
-declare function path<T>(): Path<T, T, "">;
-declare function path<T, V = unknown>(expr: PathExpression<T, V>): Path<T, V, string>;
-declare function path<T, U, V = unknown>(base: BasePath<T, U, string>, expr: PathExpression<U, V>): Path<T, V, string>;
-/**
- * Create a path from a raw string (e.g., "users.0.name").
- *
- * This is useful when paths are dynamic (like from a database or API response).
- * Type checking on individual segments is bypassed, and segments are automatically
- * parsed into numeric indices where appropriate.
- *
- * @param raw The dot-separated path string.
- * @returns A Path object representing the given string.
- */
-declare function unsafePath<T>(raw: string): Path<T, unknown, string>;
-
-export { type DeepReachable, type MatchRelation, type MatchResult, type Path, type PathConstructor, type PathExpression, type ResolvedType, type Segment, type TemplatePath, type UnsafePathConstructor, path, unsafePath };