@jfdevelops/multi-step-form-core 1.0.0-alpha.17 → 1.0.0-alpha.18

package/dist/utils/path.d.cts

@@ -0,0 +1,139 @@
+import { DeepKeys, unionHelpers } from "./types.cjs";
+
+//#region src/utils/path.d.ts
+declare namespace path {
+  type getBy<T, TPath extends string> = TPath extends `${infer K}.${infer Rest}` ? K extends keyof T ? getBy<T[K], Rest> : never : TPath extends keyof T ? T[TPath] : never;
+  type buildFromPath<T, P extends string> = P extends `${infer K}.${infer Rest}` ? { [Key in K]: buildFromPath<getBy<T, K>, Rest> } : P extends keyof T ? { [Key in P]: T[P] } : never;
+  /**
+   * Does P have any ancestor path in All? (i.e. some Q in All such that Q is a
+   * strict prefix of P)
+   */
+  type hasAncestor<P extends string, All extends string> = true extends (All extends string ? All extends P ? false : P extends `${All}.${string}` ? true : false : never) ? true : false;
+  /**
+   * Normalize a union of paths by removing those that have an ancestor path
+   * also in the union.
+   *
+   * Example:
+   *   NormalizePaths<'foo.bar.baz' | 'foo.bar'> -> 'foo.bar'
+   *   NormalizePaths<'foo.bar' | 'other'>       -> 'foo.bar' | 'other'
+   */
+  type normalize<Paths extends string, All extends string = Paths> = Paths extends string ? hasAncestor<Paths, All> extends true ? never : Paths : never;
+  type distributeAndBuild<T, Paths extends string> = Paths extends unknown ? buildFromPath<T, Paths> : never;
+  export type generateObjectConfig<T> = { [K in keyof T]: T[K] extends object ?
+  // K's value is an object: allow stopping at K, or going deeper
+  { [P in K]: true } | { [P in K]: generateObjectConfig<T[K]> } : { [P in K]: true } }[keyof T];
+  export type objectToPath<O> = { [K in keyof O]: O[K] extends true ? K & string : O[K] extends object ? `${K & string}.${objectToPath<O[K]>}` : never }[keyof O];
+  /**
+   * Pick by paths:
+   *   - Normalize the paths (remove descendants when parent also present)
+   *   - If only one normalized path:
+   *       return GetByPath<T, P> (relative type)
+   *   - If multiple:
+   *       intersect root-built shapes for each normalized path
+   *
+   * @example
+   * ```ts
+   * type User = {
+   *   foo: {
+   *     bar: {
+   *       baz: number;
+   *       qux: string;
+   *     };
+   *   };
+   *   other: string;
+   * };
+   *
+   * type Test1 = PickByPaths<User, 'foo.bar'>;
+   * // { baz: number; qux: string }          ✅ relative object at foo.bar
+   *
+   * type Test2 = PickByPaths<User, 'foo.bar.baz'>;
+   * // number                               ✅ leaf type
+   *
+   * type Test3 = PickByPaths<User, 'foo.bar' | 'other'>;
+   * // { foo: { bar: { baz: number; qux: string } } } & { other: string } ✅
+   *
+   * type Test4 = PickByPaths<User, 'foo.bar.baz' | 'foo.bar' | 'other'>;
+   * // { baz: number; qux: string }          ✅ parent 'foo.bar' wins, relative
+   * ```
+   */
+  export type pickBy<T, Paths extends DeepKeys<T>> = normalize<Paths> extends infer normalized extends string ? unionHelpers.is<normalized> extends true ? unionHelpers.toIntersection<distributeAndBuild<T, normalized>> : getBy<T, normalized> : never;
+  function getBy(obj: any, path: string): any;
+  export function setBy<def extends Record<string, unknown>, path$1 extends DeepKeys<def>>(target: def, path: path$1, value: unknown): def;
+  export function normalizePaths(...paths: string[]): string[];
+  /**
+   * pickByPaths:
+   *  - paths can be a union of string literals
+   *  - return type is PickByPaths<T, Paths>
+   */
+  export function pickBy<def, paths extends DeepKeys<def>>(obj: def, ...paths: paths[]): pickBy<def, paths>;
+  /**
+   * Creates an array of all deep paths in an object.
+   * Recursively traverses the object and returns all possible dot-separated paths.
+   *
+   * @example
+   * ```ts
+   * const obj = {
+   *   foo: {
+   *     bar: {
+   *       baz: 1,
+   *       qux: 2
+   *     }
+   *   },
+   *   other: 'value'
+   * };
+   *
+   * createPaths(obj);
+   * // ['foo', 'foo.bar', 'foo.bar.baz', 'foo.bar.qux', 'other']
+   * ```
+   */
+  export function createDeep<T>(obj: T): DeepKeys<T>[];
+  export type MismatchReason = 'value-mismatch' | 'type-mismatch' | 'missing-key' | 'extra-key';
+  export interface Mismatch {
+    path: string;
+    expected: unknown;
+    actual: unknown;
+    reason: MismatchReason;
+  }
+  export interface CompareResult {
+    ok: boolean;
+    mismatches: Mismatch[];
+  }
+  type ExpectedTransformFn<TValue = unknown> = (value: TValue, path: string) => unknown;
+  /**
+   * Transform config:
+   * - a single function: applies to the whole T
+   * - or an object shaped like T, where values are either:
+   *    - functions (apply at/under that node)
+   *    - nested objects continuing the shape
+   */
+  export type ExpectedTransformConfig<T, V = unknown> = ExpectedTransformFn<V> | { [K in keyof T]?: ExpectedTransformConfig<T[K], T[K]> };
+  export interface EqualsOptions<T> {
+    /**
+     * How to transform the "expected" field in mismatches.
+     * If omitted, a default type-ish formatting is used.
+     */
+    transformExpected?: ExpectedTransformConfig<T>;
+  }
+  export function equalsAtPaths<def, paths extends DeepKeys<def>>(obj: def, paths: paths[], actual: pickBy<def, paths>, options?: EqualsOptions<def>): CompareResult;
+  /**
+   * Turn a CompareResult into a pretty error string.
+   */
+  export function formatMismatches(result: CompareResult): string;
+  /**
+   * Convenience: log to console.error.
+   */
+  export function printMismatches(result: CompareResult): void;
+  export function findMissingPaths<obj extends Record<string, unknown>, path$1 extends DeepKeys<obj>>(obj: obj, paths: Array<path$1>, actual: pickBy<obj, path$1>): Array<DeepKeys<obj>>;
+  export type updateAtOptions<T extends Record<string, unknown>, path$1 extends DeepKeys<T>> = {
+    obj: T;
+    paths: Array<path$1>;
+    value: pickBy<T, path$1>;
+    partial?: boolean;
+  };
+  export function joinAtPath<obj extends Record<string, unknown>, path$1 extends DeepKeys<obj>>(paths: Array<path$1>, obj: obj, value: pickBy<obj, path$1>): pickBy<obj, path$1> | undefined;
+  export function updateAt<obj extends Record<string, unknown>, path$1 extends DeepKeys<obj>>(options: updateAtOptions<obj, path$1>): obj;
+  export {};
+}
+//#endregion
+export { path };
+//# sourceMappingURL=path.d.cts.map

package/dist/utils/path.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.cts","names":[],"sources":["../../src/utils/path.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/utils/path.d.mts

@@ -0,0 +1,139 @@
+import { DeepKeys, unionHelpers } from "./types.mjs";
+
+//#region src/utils/path.d.ts
+declare namespace path {
+  type getBy<T, TPath extends string> = TPath extends `${infer K}.${infer Rest}` ? K extends keyof T ? getBy<T[K], Rest> : never : TPath extends keyof T ? T[TPath] : never;
+  type buildFromPath<T, P extends string> = P extends `${infer K}.${infer Rest}` ? { [Key in K]: buildFromPath<getBy<T, K>, Rest> } : P extends keyof T ? { [Key in P]: T[P] } : never;
+  /**
+   * Does P have any ancestor path in All? (i.e. some Q in All such that Q is a
+   * strict prefix of P)
+   */
+  type hasAncestor<P extends string, All extends string> = true extends (All extends string ? All extends P ? false : P extends `${All}.${string}` ? true : false : never) ? true : false;
+  /**
+   * Normalize a union of paths by removing those that have an ancestor path
+   * also in the union.
+   *
+   * Example:
+   *   NormalizePaths<'foo.bar.baz' | 'foo.bar'> -> 'foo.bar'
+   *   NormalizePaths<'foo.bar' | 'other'>       -> 'foo.bar' | 'other'
+   */
+  type normalize<Paths extends string, All extends string = Paths> = Paths extends string ? hasAncestor<Paths, All> extends true ? never : Paths : never;
+  type distributeAndBuild<T, Paths extends string> = Paths extends unknown ? buildFromPath<T, Paths> : never;
+  export type generateObjectConfig<T> = { [K in keyof T]: T[K] extends object ?
+  // K's value is an object: allow stopping at K, or going deeper
+  { [P in K]: true } | { [P in K]: generateObjectConfig<T[K]> } : { [P in K]: true } }[keyof T];
+  export type objectToPath<O> = { [K in keyof O]: O[K] extends true ? K & string : O[K] extends object ? `${K & string}.${objectToPath<O[K]>}` : never }[keyof O];
+  /**
+   * Pick by paths:
+   *   - Normalize the paths (remove descendants when parent also present)
+   *   - If only one normalized path:
+   *       return GetByPath<T, P> (relative type)
+   *   - If multiple:
+   *       intersect root-built shapes for each normalized path
+   *
+   * @example
+   * ```ts
+   * type User = {
+   *   foo: {
+   *     bar: {
+   *       baz: number;
+   *       qux: string;
+   *     };
+   *   };
+   *   other: string;
+   * };
+   *
+   * type Test1 = PickByPaths<User, 'foo.bar'>;
+   * // { baz: number; qux: string }          ✅ relative object at foo.bar
+   *
+   * type Test2 = PickByPaths<User, 'foo.bar.baz'>;
+   * // number                               ✅ leaf type
+   *
+   * type Test3 = PickByPaths<User, 'foo.bar' | 'other'>;
+   * // { foo: { bar: { baz: number; qux: string } } } & { other: string } ✅
+   *
+   * type Test4 = PickByPaths<User, 'foo.bar.baz' | 'foo.bar' | 'other'>;
+   * // { baz: number; qux: string }          ✅ parent 'foo.bar' wins, relative
+   * ```
+   */
+  export type pickBy<T, Paths extends DeepKeys<T>> = normalize<Paths> extends infer normalized extends string ? unionHelpers.is<normalized> extends true ? unionHelpers.toIntersection<distributeAndBuild<T, normalized>> : getBy<T, normalized> : never;
+  function getBy(obj: any, path: string): any;
+  export function setBy<def extends Record<string, unknown>, path$1 extends DeepKeys<def>>(target: def, path: path$1, value: unknown): def;
+  export function normalizePaths(...paths: string[]): string[];
+  /**
+   * pickByPaths:
+   *  - paths can be a union of string literals
+   *  - return type is PickByPaths<T, Paths>
+   */
+  export function pickBy<def, paths extends DeepKeys<def>>(obj: def, ...paths: paths[]): pickBy<def, paths>;
+  /**
+   * Creates an array of all deep paths in an object.
+   * Recursively traverses the object and returns all possible dot-separated paths.
+   *
+   * @example
+   * ```ts
+   * const obj = {
+   *   foo: {
+   *     bar: {
+   *       baz: 1,
+   *       qux: 2
+   *     }
+   *   },
+   *   other: 'value'
+   * };
+   *
+   * createPaths(obj);
+   * // ['foo', 'foo.bar', 'foo.bar.baz', 'foo.bar.qux', 'other']
+   * ```
+   */
+  export function createDeep<T>(obj: T): DeepKeys<T>[];
+  export type MismatchReason = 'value-mismatch' | 'type-mismatch' | 'missing-key' | 'extra-key';
+  export interface Mismatch {
+    path: string;
+    expected: unknown;
+    actual: unknown;
+    reason: MismatchReason;
+  }
+  export interface CompareResult {
+    ok: boolean;
+    mismatches: Mismatch[];
+  }
+  type ExpectedTransformFn<TValue = unknown> = (value: TValue, path: string) => unknown;
+  /**
+   * Transform config:
+   * - a single function: applies to the whole T
+   * - or an object shaped like T, where values are either:
+   *    - functions (apply at/under that node)
+   *    - nested objects continuing the shape
+   */
+  export type ExpectedTransformConfig<T, V = unknown> = ExpectedTransformFn<V> | { [K in keyof T]?: ExpectedTransformConfig<T[K], T[K]> };
+  export interface EqualsOptions<T> {
+    /**
+     * How to transform the "expected" field in mismatches.
+     * If omitted, a default type-ish formatting is used.
+     */
+    transformExpected?: ExpectedTransformConfig<T>;
+  }
+  export function equalsAtPaths<def, paths extends DeepKeys<def>>(obj: def, paths: paths[], actual: pickBy<def, paths>, options?: EqualsOptions<def>): CompareResult;
+  /**
+   * Turn a CompareResult into a pretty error string.
+   */
+  export function formatMismatches(result: CompareResult): string;
+  /**
+   * Convenience: log to console.error.
+   */
+  export function printMismatches(result: CompareResult): void;
+  export function findMissingPaths<obj extends Record<string, unknown>, path$1 extends DeepKeys<obj>>(obj: obj, paths: Array<path$1>, actual: pickBy<obj, path$1>): Array<DeepKeys<obj>>;
+  export type updateAtOptions<T extends Record<string, unknown>, path$1 extends DeepKeys<T>> = {
+    obj: T;
+    paths: Array<path$1>;
+    value: pickBy<T, path$1>;
+    partial?: boolean;
+  };
+  export function joinAtPath<obj extends Record<string, unknown>, path$1 extends DeepKeys<obj>>(paths: Array<path$1>, obj: obj, value: pickBy<obj, path$1>): pickBy<obj, path$1> | undefined;
+  export function updateAt<obj extends Record<string, unknown>, path$1 extends DeepKeys<obj>>(options: updateAtOptions<obj, path$1>): obj;
+  export {};
+}
+//#endregion
+export { path };
+//# sourceMappingURL=path.d.mts.map

package/dist/utils/path.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.mts","names":[],"sources":["../../src/utils/path.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/utils/path.mjs

@@ -0,0 +1,325 @@
+//#region src/utils/path.ts
+let path;
+(function(_path) {
+	function getBy(obj, path$1) {
+		return path$1.split(".").reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
+	}
+	function setBy(target, path$1, value) {
+		const keys = path$1.split(".");
+		let current = target;
+		for (let i = 0; i < keys.length; i++) {
+			const k = keys[i];
+			if (i === keys.length - 1) if (current[k] !== void 0 && typeof current[k] === "object" && typeof value === "object" && value !== null) Object.assign(current[k], value);
+			else current[k] = value;
+			else {
+				if (typeof current[k] !== "object" || current[k] === null) current[k] = {};
+				current = current[k];
+			}
+		}
+		return current;
+	}
+	_path.setBy = setBy;
+	function normalizePaths(...paths) {
+		const sorted = [...paths].sort((a, b) => b.split(".").length - a.split(".").length);
+		const finalPaths = [];
+		for (const path$1 of sorted) if (!finalPaths.some((p) => p.startsWith(path$1 + "."))) finalPaths.push(path$1);
+		return finalPaths.reverse();
+	}
+	_path.normalizePaths = normalizePaths;
+	function pickBy(obj, ...paths) {
+		const norm = normalizePaths(...paths);
+		if (norm.length === 1) return getBy(obj, norm[0]);
+		const result = {};
+		for (const p of norm) setBy(result, p, getBy(obj, p));
+		return result;
+	}
+	_path.pickBy = pickBy;
+	function createDeep(obj) {
+		const paths = [];
+		function traverse(current, prefix = "") {
+			if (current === null || current === void 0) return;
+			if (typeof current !== "object" || Array.isArray(current)) return;
+			const keys = Object.keys(current);
+			for (const key of keys) {
+				const path$1 = prefix ? `${prefix}.${key}` : key;
+				paths.push(path$1);
+				const value = current[key];
+				if (value !== null && value !== void 0 && typeof value === "object" && !Array.isArray(value)) traverse(value, path$1);
+			}
+		}
+		traverse(obj);
+		return paths;
+	}
+	_path.createDeep = createDeep;
+	function defaultExpectedFormat(value) {
+		if (value === null) return "null";
+		if (Array.isArray(value)) return "Array";
+		const t = typeof value;
+		if (t !== "object") return t;
+		const ctor = value?.constructor?.name;
+		return ctor && ctor !== "Object" ? ctor : "object";
+	}
+	function splitPath(path$1) {
+		if (!path$1) return [];
+		const parts = [];
+		const regex = /[^.[\]]+|\[(\d+)\]/g;
+		let m;
+		while (m = regex.exec(path$1)) parts.push(m[1] ?? m[0]);
+		return parts;
+	}
+	function getTransformFunction(root, path$1) {
+		if (!root) return void 0;
+		if (typeof root === "function") return root;
+		const segments = splitPath(path$1);
+		let node = root;
+		let lastFn;
+		for (const seg of segments) {
+			if (!node) break;
+			if (typeof node === "function") {
+				lastFn = node;
+				break;
+			}
+			node = node[seg];
+			if (typeof node === "function") {
+				lastFn = node;
+				break;
+			}
+		}
+		return lastFn;
+	}
+	function formatExpected(rawExpected, path$1, cfg) {
+		const fn = getTransformFunction(cfg, path$1);
+		if (fn) return fn(rawExpected, path$1);
+		return defaultExpectedFormat(rawExpected);
+	}
+	function isObjectLike(v) {
+		return typeof v === "object" && v !== null;
+	}
+	function deepCompare(expected, actual, basePath, mismatches, options) {
+		if (expected === actual) return mismatches;
+		if (expected === null || actual === null || typeof expected !== "object" || typeof actual !== "object") {
+			const path$2 = basePath || "(root)";
+			if (typeof expected !== typeof actual) {
+				mismatches.push({
+					path: path$2,
+					expected: formatExpected(expected, path$2, options.transformExpected),
+					actual,
+					reason: "type-mismatch"
+				});
+				return mismatches;
+			}
+			if (options.includeValueMismatch) mismatches.push({
+				path: path$2,
+				expected: formatExpected(expected, path$2, options.transformExpected),
+				actual,
+				reason: "value-mismatch"
+			});
+			return mismatches;
+		}
+		if (Array.isArray(expected) || Array.isArray(actual)) {
+			if (!Array.isArray(expected) || !Array.isArray(actual)) {
+				const path$2 = basePath || "(root)";
+				mismatches.push({
+					path: path$2,
+					expected: formatExpected(expected, path$2, options.transformExpected),
+					actual,
+					reason: "type-mismatch"
+				});
+				return mismatches;
+			}
+			const maxLen = expected.length;
+			for (let i = 0; i < maxLen; i++) {
+				const expVal = expected[i];
+				const actVal = actual[i];
+				deepCompare(expVal, actVal, basePath === "" ? `[${i}]` : `${basePath}[${i}]`, mismatches, options);
+			}
+			return mismatches;
+		}
+		if (isObjectLike(expected) && isObjectLike(actual)) {
+			const expKeys = Object.keys(expected);
+			const actKeys = Object.keys(actual);
+			for (const key of expKeys) {
+				const expVal = expected[key];
+				const actVal = actual[key];
+				const path$2 = basePath ? `${basePath}.${key}` : key;
+				if (!(key in actual)) {
+					mismatches.push({
+						path: path$2,
+						expected: formatExpected(expVal, path$2, options.transformExpected),
+						actual: void 0,
+						reason: "missing-key"
+					});
+					continue;
+				}
+				deepCompare(expVal, actVal, path$2, mismatches, options);
+			}
+			for (const key of actKeys) if (!(key in expected)) {
+				const path$2 = basePath ? `${basePath}.${key}` : key;
+				mismatches.push({
+					path: path$2,
+					expected: void 0,
+					actual: actual[key],
+					reason: "extra-key"
+				});
+			}
+			return mismatches;
+		}
+		const path$1 = basePath || "(root)";
+		if (typeof expected !== typeof actual) mismatches.push({
+			path: path$1,
+			expected: formatExpected(expected, path$1, options.transformExpected),
+			actual,
+			reason: "type-mismatch"
+		});
+		else if (options.includeValueMismatch) mismatches.push({
+			path: path$1,
+			expected: formatExpected(expected, path$1, options.transformExpected),
+			actual,
+			reason: "value-mismatch"
+		});
+		return mismatches;
+	}
+	function equalsAtPaths(obj, paths, actual, options) {
+		const expected = pickBy(obj, ...paths);
+		const mismatches = [];
+		deepCompare(expected, actual, paths.length === 1 ? paths[0] : "", mismatches, { transformExpected: options?.transformExpected });
+		return {
+			ok: mismatches.length === 0,
+			mismatches
+		};
+	}
+	_path.equalsAtPaths = equalsAtPaths;
+	function formatValue(v) {
+		if (v === void 0) return "undefined";
+		if (typeof v === "string") return JSON.stringify(v);
+		try {
+			return JSON.stringify(v, null, 2);
+		} catch {
+			return String(v);
+		}
+	}
+	function formatReason(m) {
+		switch (m.reason) {
+			case "missing-key": return "Missing key";
+			case "extra-key": return "Extra key";
+			case "type-mismatch": return "Type mismatch";
+			case "value-mismatch": return "Value mismatch";
+			default: return m.reason;
+		}
+	}
+	function formatMismatches(result) {
+		if (result.ok || result.mismatches.length === 0) return "No mismatches.";
+		const lines = [];
+		for (const m of result.mismatches) lines.push(`\n● ${formatReason(m)} at "${m.path}":`, `    expected: ${formatValue(m.expected)}`, `    actual:   ${formatValue(m.actual)}`, "");
+		if (lines.at(-1) === "") lines.pop();
+		return lines.join("\n");
+	}
+	_path.formatMismatches = formatMismatches;
+	function printMismatches(result) {
+		const msg = formatMismatches(result);
+		if (msg !== "No mismatches.") console.error(msg);
+	}
+	_path.printMismatches = printMismatches;
+	function setAtImmutable(root, path$1, value) {
+		const keys = path$1.split(".");
+		function helper(current, idx) {
+			const key = keys[idx];
+			const resolvedCurrent = Array.isArray(current) ? [...current] : { ...current };
+			if (idx === keys.length - 1) {
+				let clone$1 = current && typeof current === "object" ? resolvedCurrent : {};
+				clone$1 = {
+					...clone$1,
+					[key]: value
+				};
+				return clone$1;
+			}
+			const updatedChild = helper((current && typeof current === "object" ? current[key] : void 0) ?? {}, idx + 1);
+			let clone = current && typeof current === "object" ? resolvedCurrent : {};
+			clone = {
+				...clone,
+				[key]: updatedChild
+			};
+			return clone;
+		}
+		return helper(root, 0);
+	}
+	function findMissingPaths(obj, paths, actual) {
+		const keys = [];
+		for (const path$1 of paths) {
+			const expectedKeys = createDeep(pickBy(obj, path$1));
+			const actualKeys = createDeep(actual);
+			const missingKeys = expectedKeys.filter((key) => !actualKeys.includes(key)).map((key) => `${path$1}.${key}`);
+			keys.push(...missingKeys);
+		}
+		return keys;
+	}
+	_path.findMissingPaths = findMissingPaths;
+	function getPathThatMatter(path$1) {
+		const [, ...rest] = path$1.split(".defaultValue.");
+		return rest.join(".");
+	}
+	function joinAtPath(paths, obj, value) {
+		if (paths.length === 1) {
+			const [path$1] = paths;
+			const missingData = pickBy(obj, ...paths);
+			return setBy(value, getPathThatMatter(path$1), missingData);
+		}
+		if (paths.length > 1) {
+			let resolvedValue = {};
+			for (const path$1 of paths) {
+				const pathThatMatters = getPathThatMatter(path$1);
+				const missing = joinAtPath([path$1], obj, value);
+				const valueAtPathThatMatters = getBy(obj, path$1);
+				if (Object.keys(resolvedValue).length > 0 && valueAtPathThatMatters !== "undefined") {
+					const dataAtPath = pickBy(obj, path$1);
+					const [key] = pathThatMatters.split(".");
+					if (typeof dataAtPath === "object") {
+						if (missing) resolvedValue = {
+							...resolvedValue,
+							[key]: {
+								...resolvedValue[key],
+								...missing
+							}
+						};
+					}
+					continue;
+				}
+				if (missing) resolvedValue = {
+					...resolvedValue,
+					...missing
+				};
+			}
+			return resolvedValue;
+		}
+	}
+	_path.joinAtPath = joinAtPath;
+	function updateAt(options) {
+		const { obj, partial, paths, value } = options;
+		const norm = normalizePaths(...paths);
+		if (norm.length === 0) return obj;
+		let result = obj;
+		let resolvedValue = value;
+		if (partial) {
+			const missingData = joinAtPath(findMissingPaths(obj, paths, value), obj, resolvedValue);
+			resolvedValue = {
+				...resolvedValue,
+				...missingData
+			};
+		}
+		if (norm.length === 1) {
+			const path$1 = norm[0];
+			result = setAtImmutable(result, path$1, resolvedValue);
+			return result;
+		}
+		for (const path$1 of norm) {
+			const sub = getBy(value, path$1);
+			result = setAtImmutable(result, path$1, sub);
+		}
+		return result;
+	}
+	_path.updateAt = updateAt;
+})(path || (path = {}));
+
+//#endregion
+export { path };
+//# sourceMappingURL=path.mjs.map