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

package/dist/utils/logger.d.cts

@@ -0,0 +1,53 @@
+//#region src/utils/logger.d.ts
+type LogLevel = 'info' | 'warn' | 'error';
+type MultiStepFormLoggerOptions = {
+  debug?: boolean;
+  prefix?: string | ((prefix: typeof DEFAULT_LOGGER_PREFIX) => string);
+  includeTimestamp?: boolean;
+  throwOnError?: boolean;
+};
+type WrapWithOptions = '[]' | '{}' | 'none';
+type ReplacePrefixOptions = {
+  action: 'replace';
+  value: string;
+  wrapWith?: WrapWithOptions;
+};
+type AppendOrPrependPrefixOptions = {
+  action: 'append' | 'prepend';
+  value: string;
+  delimiter?: string;
+  wrapWith?: {
+    originalPrefix?: WrapWithOptions;
+    addedPrefix?: WrapWithOptions;
+  };
+};
+type PrefixOptions = ReplacePrefixOptions | AppendOrPrependPrefixOptions;
+type BaseLogOptions = {
+  prefix?: PrefixOptions;
+  logLevelOptions?: {
+    level?: LogLevel;
+    wrapWith?: WrapWithOptions;
+  };
+  includeTimestamp?: boolean;
+};
+type ErrorLogOptions = BaseLogOptions & {
+  throw?: boolean;
+};
+declare const DEFAULT_LOGGER_PREFIX = "MultiStepFormSchema";
+declare class MultiStepFormLogger {
+  private readonly debug;
+  private readonly prefix;
+  private readonly includeTimestamp;
+  private readonly throwOnError;
+  constructor(options?: MultiStepFormLoggerOptions);
+  private wrapValue;
+  private formatPrefix;
+  private formatMessage;
+  info(message: string, options?: BaseLogOptions): void;
+  warn(message: string, options?: BaseLogOptions): void;
+  error(message: string, options?: BaseLogOptions): void;
+  error(message: string, options?: ErrorLogOptions): never;
+}
+//#endregion
+export { DEFAULT_LOGGER_PREFIX, MultiStepFormLogger };
+//# sourceMappingURL=logger.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.cts","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":[],"mappings":";KAAK,QAAA;KACA,0BAAA,GADQ;EACR,KAAA,CAAA,EAAA,OAAA;EAOA,MAAA,CAAA,EAAA,MAAA,GAAe,CAAA,CAAA,MAAA,EAAA,OALiB,qBAKjB,EAAA,GAAA,MAAA,CAAA;EACf,gBAAA,CAAA,EAAA,OAAoB;EAKpB,YAAA,CAAA,EAAA,OAAA;AAM4B,CAAA;AAGuC,KAfnE,eAAA,GAgBc,IAAA,GAAA,IAAA,GAAA,MAAA;KAfd,oBAAA,GAgBM;EAEC,MAAA,EAAA,SAAA;EACG,KAAA,EAAA,MAAA;EAAe,QAAA,CAAA,EAhBjB,eAgBiB;AAAA,CAAA;AAQ9B,KAtBK,4BAAA,GAsB6B;EACrB,MAAA,EAAA,QAAA,GAAA,SAAmB;EAMR,KAAA,EAAA,MAAA;EAgGU,SAAA,CAAA,EAAA,MAAA;EAQA,QAAA,CAAA,EAAA;IAQC,cAAA,CAAA,EAxId,eAwIc;IACA,WAAA,CAAA,EAxIjB,eAwIiB;EAAe,CAAA;;KArI7C,aAAA,GAAgB,uBAAuB;KACvC,cAAA;WACM;;YAEC;eACG;;;;KAIV,eAAA,GAAkB;;;cAIV,qBAAA;cACA,mBAAA;;;;;wBAMW;;;;kCAgGU;kCAQA;mCAQC;mCACA"}

package/dist/utils/logger.d.mts

@@ -0,0 +1,53 @@
+//#region src/utils/logger.d.ts
+type LogLevel = 'info' | 'warn' | 'error';
+type MultiStepFormLoggerOptions = {
+  debug?: boolean;
+  prefix?: string | ((prefix: typeof DEFAULT_LOGGER_PREFIX) => string);
+  includeTimestamp?: boolean;
+  throwOnError?: boolean;
+};
+type WrapWithOptions = '[]' | '{}' | 'none';
+type ReplacePrefixOptions = {
+  action: 'replace';
+  value: string;
+  wrapWith?: WrapWithOptions;
+};
+type AppendOrPrependPrefixOptions = {
+  action: 'append' | 'prepend';
+  value: string;
+  delimiter?: string;
+  wrapWith?: {
+    originalPrefix?: WrapWithOptions;
+    addedPrefix?: WrapWithOptions;
+  };
+};
+type PrefixOptions = ReplacePrefixOptions | AppendOrPrependPrefixOptions;
+type BaseLogOptions = {
+  prefix?: PrefixOptions;
+  logLevelOptions?: {
+    level?: LogLevel;
+    wrapWith?: WrapWithOptions;
+  };
+  includeTimestamp?: boolean;
+};
+type ErrorLogOptions = BaseLogOptions & {
+  throw?: boolean;
+};
+declare const DEFAULT_LOGGER_PREFIX = "MultiStepFormSchema";
+declare class MultiStepFormLogger {
+  private readonly debug;
+  private readonly prefix;
+  private readonly includeTimestamp;
+  private readonly throwOnError;
+  constructor(options?: MultiStepFormLoggerOptions);
+  private wrapValue;
+  private formatPrefix;
+  private formatMessage;
+  info(message: string, options?: BaseLogOptions): void;
+  warn(message: string, options?: BaseLogOptions): void;
+  error(message: string, options?: BaseLogOptions): void;
+  error(message: string, options?: ErrorLogOptions): never;
+}
+//#endregion
+export { DEFAULT_LOGGER_PREFIX, MultiStepFormLogger };
+//# sourceMappingURL=logger.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.mts","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":[],"mappings":";KAAK,QAAA;KACA,0BAAA,GADQ;EACR,KAAA,CAAA,EAAA,OAAA;EAOA,MAAA,CAAA,EAAA,MAAA,GAAe,CAAA,CAAA,MAAA,EAAA,OALiB,qBAKjB,EAAA,GAAA,MAAA,CAAA;EACf,gBAAA,CAAA,EAAA,OAAoB;EAKpB,YAAA,CAAA,EAAA,OAAA;AAM4B,CAAA;AAGuC,KAfnE,eAAA,GAgBc,IAAA,GAAA,IAAA,GAAA,MAAA;KAfd,oBAAA,GAgBM;EAEC,MAAA,EAAA,SAAA;EACG,KAAA,EAAA,MAAA;EAAe,QAAA,CAAA,EAhBjB,eAgBiB;AAAA,CAAA;AAQ9B,KAtBK,4BAAA,GAsB6B;EACrB,MAAA,EAAA,QAAA,GAAA,SAAmB;EAMR,KAAA,EAAA,MAAA;EAgGU,SAAA,CAAA,EAAA,MAAA;EAQA,QAAA,CAAA,EAAA;IAQC,cAAA,CAAA,EAxId,eAwIc;IACA,WAAA,CAAA,EAxIjB,eAwIiB;EAAe,CAAA;;KArI7C,aAAA,GAAgB,uBAAuB;KACvC,cAAA;WACM;;YAEC;eACG;;;;KAIV,eAAA,GAAkB;;;cAIV,qBAAA;cACA,mBAAA;;;;;wBAMW;;;;kCAgGU;kCAQA;mCAQC;mCACA"}

package/dist/utils/logger.mjs

@@ -0,0 +1,56 @@
+//#region src/utils/logger.ts
+const DEFAULT_LOGGER_PREFIX = "MultiStepFormSchema";
+var MultiStepFormLogger = class {
+	debug;
+	prefix = DEFAULT_LOGGER_PREFIX;
+	includeTimestamp = false;
+	throwOnError = false;
+	constructor(options) {
+		this.debug = options?.debug ?? false;
+		if (this.debug && options?.debug) {
+			const { includeTimestamp = false, prefix = DEFAULT_LOGGER_PREFIX, throwOnError = false } = options;
+			this.includeTimestamp = includeTimestamp;
+			this.prefix = typeof prefix === "string" ? prefix : prefix(DEFAULT_LOGGER_PREFIX);
+			this.throwOnError = throwOnError;
+		}
+	}
+	wrapValue(wrapWith, value) {
+		if (wrapWith === "[]") return `[${value}]`;
+		if (wrapWith === "{}") return `{${value}}`;
+		if (wrapWith === "none") return value;
+		throw new Error(`The first argument ${wrapWith} is not valid. Valid options include: "[]", "{}", and "none"`);
+	}
+	formatPrefix(options) {
+		if (!options) return this.prefix;
+		const { action, value, wrapWith } = options;
+		if (action === "replace") return this.wrapValue(wrapWith ?? "[]", value);
+		const { delimiter } = options;
+		if (action === "append") return `${this.wrapValue(wrapWith?.originalPrefix ?? "[]", this.prefix)}${delimiter}${this.wrapValue(wrapWith?.addedPrefix ?? "[]", value)}`.trim();
+		if (action === "prepend") return `${this.wrapValue(wrapWith?.addedPrefix ?? "[]", value)}${delimiter}${this.wrapValue(wrapWith?.originalPrefix ?? "[]", this.prefix)}`.trim();
+		return this.prefix;
+	}
+	formatMessage(level, message, options) {
+		const { includeTimestamp = this.includeTimestamp, prefix, logLevelOptions } = options ?? {};
+		const formattedMessage = `${this.formatPrefix(prefix)} ${this.wrapValue(logLevelOptions?.wrapWith ?? "[]", (logLevelOptions?.level ?? level).toUpperCase())} ${message}`;
+		if (includeTimestamp) return `[${(/* @__PURE__ */ new Date()).toISOString()}] ${formattedMessage}`;
+		return formattedMessage;
+	}
+	info(message, options) {
+		if (!this.debug) return;
+		console.info(this.formatMessage("info", message, options));
+	}
+	warn(message, options) {
+		if (!this.debug) return;
+		console.warn(this.formatMessage("warn", message, options));
+	}
+	error(message, options) {
+		if (!this.debug) return;
+		const formatted = this.formatMessage("error", message, options);
+		console.error(formatted);
+		if (options?.throw ?? this.throwOnError) throw new Error(formatted);
+	}
+};
+
+//#endregion
+export { DEFAULT_LOGGER_PREFIX, MultiStepFormLogger };
+//# sourceMappingURL=logger.mjs.map

package/dist/utils/logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.mjs","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":["type LogLevel = 'info' | 'warn' | 'error';\ntype MultiStepFormLoggerOptions = {\n  debug?: boolean;\n  prefix?: string | ((prefix: typeof DEFAULT_LOGGER_PREFIX) => string);\n  includeTimestamp?: boolean;\n  throwOnError?: boolean;\n};\n\ntype WrapWithOptions = '[]' | '{}' | 'none';\ntype ReplacePrefixOptions = {\n  action: 'replace';\n  value: string;\n  wrapWith?: WrapWithOptions;\n};\ntype AppendOrPrependPrefixOptions = {\n  action: 'append' | 'prepend';\n  value: string;\n  delimiter?: string;\n  wrapWith?: {\n    originalPrefix?: WrapWithOptions;\n    addedPrefix?: WrapWithOptions;\n  };\n};\ntype PrefixOptions = ReplacePrefixOptions | AppendOrPrependPrefixOptions;\ntype BaseLogOptions = {\n  prefix?: PrefixOptions;\n  logLevelOptions?: {\n    level?: LogLevel;\n    wrapWith?: WrapWithOptions;\n  };\n  includeTimestamp?: boolean;\n};\ntype ErrorLogOptions = BaseLogOptions & {\n  throw?: boolean;\n};\n\nexport const DEFAULT_LOGGER_PREFIX = 'MultiStepFormSchema';\nexport class MultiStepFormLogger {\n  private readonly debug: boolean;\n  private readonly prefix: string = DEFAULT_LOGGER_PREFIX;\n  private readonly includeTimestamp: boolean = false;\n  private readonly throwOnError: boolean = false;\n\n  constructor(options?: MultiStepFormLoggerOptions) {\n    this.debug = options?.debug ?? false;\n    if (this.debug && options?.debug) {\n      const {\n        includeTimestamp = false,\n        prefix = DEFAULT_LOGGER_PREFIX,\n        throwOnError = false,\n      } = options;\n\n      this.includeTimestamp = includeTimestamp;\n      this.prefix =\n        typeof prefix === 'string' ? prefix : prefix(DEFAULT_LOGGER_PREFIX);\n      this.throwOnError = throwOnError;\n    }\n  }\n\n  private wrapValue(wrapWith: WrapWithOptions, value: string) {\n    if (wrapWith === '[]') {\n      return `[${value}]`;\n    }\n\n    if (wrapWith === '{}') {\n      return `{${value}}`;\n    }\n\n    if (wrapWith === 'none') {\n      return value;\n    }\n\n    throw new Error(\n      `The first argument ${wrapWith} is not valid. Valid options include: \"[]\", \"{}\", and \"none\"`\n    );\n  }\n\n  private formatPrefix(options: PrefixOptions | undefined) {\n    if (!options) {\n      return this.prefix;\n    }\n\n    const { action, value, wrapWith } = options;\n\n    if (action === 'replace') {\n      return this.wrapValue(wrapWith ?? '[]', value);\n    }\n\n    const { delimiter } = options;\n\n    if (action === 'append') {\n      return `${this.wrapValue(\n        wrapWith?.originalPrefix ?? '[]',\n        this.prefix\n      )}${delimiter}${this.wrapValue(\n        wrapWith?.addedPrefix ?? '[]',\n        value\n      )}`.trim();\n    }\n\n    if (action === 'prepend') {\n      return `${this.wrapValue(\n        wrapWith?.addedPrefix ?? '[]',\n        value\n      )}${delimiter}${this.wrapValue(\n        wrapWith?.originalPrefix ?? '[]',\n        this.prefix\n      )}`.trim();\n    }\n\n    return this.prefix;\n  }\n\n  private formatMessage(\n    level: LogLevel,\n    message: string,\n    options?: BaseLogOptions\n  ) {\n    const {\n      includeTimestamp = this.includeTimestamp,\n      prefix,\n      logLevelOptions,\n    } = options ?? {};\n    const formattedPrefix = this.formatPrefix(prefix);\n    const formattedLogLevel = this.wrapValue(\n      logLevelOptions?.wrapWith ?? '[]',\n      (logLevelOptions?.level ?? level).toUpperCase()\n    );\n    const formattedMessage = `${formattedPrefix} ${formattedLogLevel} ${message}`;\n\n    if (includeTimestamp) {\n      const timestamp = new Date().toISOString();\n\n      return `[${timestamp}] ${formattedMessage}`;\n    }\n\n    return formattedMessage;\n  }\n\n  info(message: string, options?: BaseLogOptions) {\n    if (!this.debug) {\n      return;\n    }\n\n    console.info(this.formatMessage('info', message, options));\n  }\n\n  warn(message: string, options?: BaseLogOptions) {\n    if (!this.debug) {\n      return;\n    }\n\n    console.warn(this.formatMessage('warn', message, options));\n  }\n\n  error(message: string, options?: BaseLogOptions): void;\n  error(message: string, options?: ErrorLogOptions): never;\n  error(message: string, options?: ErrorLogOptions) {\n    if (!this.debug) {\n      return;\n    }\n\n    const formatted = this.formatMessage('error', message, options);\n\n    console.error(formatted);\n\n    const throwOnError = options?.throw ?? this.throwOnError;\n\n    if (throwOnError) {\n      throw new Error(formatted);\n    }\n  }\n}\n"],"mappings":";AAoCA,MAAa,wBAAwB;AACrC,IAAa,sBAAb,MAAiC;CAC/B,AAAiB;CACjB,AAAiB,SAAiB;CAClC,AAAiB,mBAA4B;CAC7C,AAAiB,eAAwB;CAEzC,YAAY,SAAsC;AAChD,OAAK,QAAQ,SAAS,SAAS;AAC/B,MAAI,KAAK,SAAS,SAAS,OAAO;GAChC,MAAM,EACJ,mBAAmB,OACnB,SAAS,uBACT,eAAe,UACb;AAEJ,QAAK,mBAAmB;AACxB,QAAK,SACH,OAAO,WAAW,WAAW,SAAS,OAAO,sBAAsB;AACrE,QAAK,eAAe;;;CAIxB,AAAQ,UAAU,UAA2B,OAAe;AAC1D,MAAI,aAAa,KACf,QAAO,IAAI,MAAM;AAGnB,MAAI,aAAa,KACf,QAAO,IAAI,MAAM;AAGnB,MAAI,aAAa,OACf,QAAO;AAGT,QAAM,IAAI,MACR,sBAAsB,SAAS,8DAChC;;CAGH,AAAQ,aAAa,SAAoC;AACvD,MAAI,CAAC,QACH,QAAO,KAAK;EAGd,MAAM,EAAE,QAAQ,OAAO,aAAa;AAEpC,MAAI,WAAW,UACb,QAAO,KAAK,UAAU,YAAY,MAAM,MAAM;EAGhD,MAAM,EAAE,cAAc;AAEtB,MAAI,WAAW,SACb,QAAO,GAAG,KAAK,UACb,UAAU,kBAAkB,MAC5B,KAAK,OACN,GAAG,YAAY,KAAK,UACnB,UAAU,eAAe,MACzB,MACD,GAAG,MAAM;AAGZ,MAAI,WAAW,UACb,QAAO,GAAG,KAAK,UACb,UAAU,eAAe,MACzB,MACD,GAAG,YAAY,KAAK,UACnB,UAAU,kBAAkB,MAC5B,KAAK,OACN,GAAG,MAAM;AAGZ,SAAO,KAAK;;CAGd,AAAQ,cACN,OACA,SACA,SACA;EACA,MAAM,EACJ,mBAAmB,KAAK,kBACxB,QACA,oBACE,WAAW,EAAE;EAMjB,MAAM,mBAAmB,GALD,KAAK,aAAa,OAAO,CAKL,GAJlB,KAAK,UAC7B,iBAAiB,YAAY,OAC5B,iBAAiB,SAAS,OAAO,aAAa,CAChD,CACgE,GAAG;AAEpE,MAAI,iBAGF,QAAO,qBAFW,IAAI,MAAM,EAAC,aAAa,CAErB,IAAI;AAG3B,SAAO;;CAGT,KAAK,SAAiB,SAA0B;AAC9C,MAAI,CAAC,KAAK,MACR;AAGF,UAAQ,KAAK,KAAK,cAAc,QAAQ,SAAS,QAAQ,CAAC;;CAG5D,KAAK,SAAiB,SAA0B;AAC9C,MAAI,CAAC,KAAK,MACR;AAGF,UAAQ,KAAK,KAAK,cAAc,QAAQ,SAAS,QAAQ,CAAC;;CAK5D,MAAM,SAAiB,SAA2B;AAChD,MAAI,CAAC,KAAK,MACR;EAGF,MAAM,YAAY,KAAK,cAAc,SAAS,SAAS,QAAQ;AAE/D,UAAQ,MAAM,UAAU;AAIxB,MAFqB,SAAS,SAAS,KAAK,aAG1C,OAAM,IAAI,MAAM,UAAU"}

package/dist/utils/path.cjs

@@ -0,0 +1,331 @@
+
+//#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
+Object.defineProperty(exports, 'path', {
+  enumerable: true,
+  get: function () {
+    return path;
+  }
+});
+//# sourceMappingURL=path.cjs.map

package/dist/utils/path.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.cjs","names":["path","finalPaths: string[]","result: Record<string, unknown>","paths: string[]","parts: string[]","m: RegExpExecArray | null","node: any","lastFn: ExpectedTransformFn | undefined","mismatches: Mismatch[]","lines: string[]","clone","keys: string[]"],"sources":["../../src/utils/path.ts"],"sourcesContent":["import type { DeepKeys, unionHelpers } from './types';\n\nexport namespace path {\n  type getBy<T, TPath extends string> = TPath extends `${infer K}.${infer Rest}`\n    ? K extends keyof T\n      ? getBy<T[K], Rest>\n      : never\n    : TPath extends keyof T\n    ? T[TPath]\n    : never;\n\n  type buildFromPath<T, P extends string> = P extends `${infer K}.${infer Rest}`\n    ? { [Key in K]: buildFromPath<getBy<T, K>, Rest> }\n    : P extends keyof T\n    ? { [Key in P]: T[P] }\n    : never;\n\n  /**\n   * Does P have any ancestor path in All? (i.e. some Q in All such that Q is a\n   * strict prefix of P)\n   */\n  type hasAncestor<P extends string, All extends string> = true extends (\n    All extends string\n      ? All extends P\n        ? false // same path, not an ancestor\n        : P extends `${All}.${string}`\n        ? true\n        : false\n      : never\n  )\n    ? true\n    : false;\n\n  /**\n   * Normalize a union of paths by removing those that have an ancestor path\n   * also in the union.\n   *\n   * Example:\n   *   NormalizePaths<'foo.bar.baz' | 'foo.bar'> -> 'foo.bar'\n   *   NormalizePaths<'foo.bar' | 'other'>       -> 'foo.bar' | 'other'\n   */\n  type normalize<\n    Paths extends string,\n    All extends string = Paths\n  > = Paths extends string\n    ? hasAncestor<Paths, All> extends true\n      ? never\n      : Paths\n    : never;\n\n  // helper to distribute BuildFromPath over union\n  type distributeAndBuild<T, Paths extends string> = Paths extends unknown\n    ? buildFromPath<T, Paths>\n    : never;\n\n  export type generateObjectConfig<T> = {\n    [K in keyof T]: T[K] extends object\n      ? // K's value is an object: allow stopping at K, or going deeper\n        { [P in K]: true } | { [P in K]: generateObjectConfig<T[K]> }\n      : // K's value is not object: can only stop at K\n        { [P in K]: true };\n  }[keyof T];\n  export type objectToPath<O> = {\n    [K in keyof O]: O[K] extends true\n      ? K & string\n      : O[K] extends object\n      ? `${K & string}.${objectToPath<O[K]>}`\n      : never;\n  }[keyof O];\n\n  /**\n   * Pick by paths:\n   *   - Normalize the paths (remove descendants when parent also present)\n   *   - If only one normalized path:\n   *       return GetByPath<T, P> (relative type)\n   *   - If multiple:\n   *       intersect root-built shapes for each normalized path\n   *\n   * @example\n   * ```ts\n   * type User = {\n   *   foo: {\n   *     bar: {\n   *       baz: number;\n   *       qux: string;\n   *     };\n   *   };\n   *   other: string;\n   * };\n   *\n   * type Test1 = PickByPaths<User, 'foo.bar'>;\n   * // { baz: number; qux: string }          ✅ relative object at foo.bar\n   *\n   * type Test2 = PickByPaths<User, 'foo.bar.baz'>;\n   * // number                               ✅ leaf type\n   *\n   * type Test3 = PickByPaths<User, 'foo.bar' | 'other'>;\n   * // { foo: { bar: { baz: number; qux: string } } } & { other: string } ✅\n   *\n   * type Test4 = PickByPaths<User, 'foo.bar.baz' | 'foo.bar' | 'other'>;\n   * // { baz: number; qux: string }          ✅ parent 'foo.bar' wins, relative\n   * ```\n   */\n  export type pickBy<\n    T,\n    Paths extends DeepKeys<T>\n  > = normalize<Paths> extends infer normalized extends string\n    ? unionHelpers.is<normalized> extends true\n      ? unionHelpers.toIntersection<distributeAndBuild<T, normalized>>\n      : getBy<T, normalized>\n    : never;\n\n  function getBy(obj: any, path: string): any {\n    return path\n      .split('.')\n      .reduce((acc, key) => (acc == null ? undefined : acc[key]), obj);\n  }\n  export function setBy<\n    def extends Record<string, unknown>,\n    path extends DeepKeys<def>\n  >(target: def, path: path, value: unknown) {\n    const keys = path.split('.');\n    let current = target;\n\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i];\n      if (i === keys.length - 1) {\n        // last key -> assign/merge\n        if (\n          current[k] !== undefined &&\n          typeof current[k] === 'object' &&\n          typeof value === 'object' &&\n          value !== null\n        ) {\n          Object.assign(current[k] as Record<string, unknown>, value);\n        } else {\n          (current[k] as any) = value;\n        }\n      } else {\n        if (typeof current[k] !== 'object' || current[k] === null) {\n          (current[k] as any) = {};\n        }\n        (current as any) = current[k];\n      }\n    }\n\n    return current;\n  }\n\n  // Runtime: normalize paths (drop descendants when ancestor exists)\n  export function normalizePaths(...paths: string[]) {\n    // Sort by depth (deepest first), so longer paths come before their parents.\n    const sorted = [...paths].sort(\n      (a, b) => b.split('.').length - a.split('.').length\n    );\n\n    const finalPaths: string[] = [];\n\n    for (const path of sorted) {\n      // If the path is contained inside another selected deeper path, skip it\n      const isCovered = finalPaths.some((p) => p.startsWith(path + '.'));\n\n      if (!isCovered) {\n        finalPaths.push(path);\n      }\n    }\n\n    // The order may not matter, but returning in shallow-to-deep order feels natural.\n    return finalPaths.reverse();\n  }\n\n  /**\n   * pickByPaths:\n   *  - paths can be a union of string literals\n   *  - return type is PickByPaths<T, Paths>\n   */\n  export function pickBy<def, paths extends DeepKeys<def>>(\n    obj: def,\n    ...paths: paths[]\n  ): pickBy<def, paths> {\n    const norm = normalizePaths(...paths);\n\n    // Single normalized path -> return relative value at that path\n    if (norm.length === 1) {\n      return getBy(obj, norm[0]) as pickBy<def, paths>;\n    }\n\n    // Multiple normalized paths -> build root-based object and intersect\n    const result: Record<string, unknown> = {};\n\n    for (const p of norm) {\n      const value = getBy(obj, p);\n\n      setBy(result, p, value);\n    }\n\n    return result as pickBy<def, paths>;\n  }\n\n  /**\n   * Creates an array of all deep paths in an object.\n   * Recursively traverses the object and returns all possible dot-separated paths.\n   *\n   * @example\n   * ```ts\n   * const obj = {\n   *   foo: {\n   *     bar: {\n   *       baz: 1,\n   *       qux: 2\n   *     }\n   *   },\n   *   other: 'value'\n   * };\n   *\n   * createPaths(obj);\n   * // ['foo', 'foo.bar', 'foo.bar.baz', 'foo.bar.qux', 'other']\n   * ```\n   */\n  export function createDeep<T>(obj: T): DeepKeys<T>[] {\n    const paths: string[] = [];\n\n    function traverse(current: any, prefix: string = ''): void {\n      if (current === null || current === undefined) {\n        return;\n      }\n\n      if (typeof current !== 'object' || Array.isArray(current)) {\n        return;\n      }\n\n      const keys = Object.keys(current);\n      for (const key of keys) {\n        const path = prefix ? `${prefix}.${key}` : key;\n        paths.push(path);\n\n        const value = current[key];\n        if (\n          value !== null &&\n          value !== undefined &&\n          typeof value === 'object' &&\n          !Array.isArray(value)\n        ) {\n          traverse(value, path);\n        }\n      }\n    }\n\n    traverse(obj);\n    return paths as DeepKeys<T>[];\n  }\n\n  export type MismatchReason =\n    | 'value-mismatch'\n    | 'type-mismatch'\n    | 'missing-key'\n    | 'extra-key';\n  export interface Mismatch {\n    path: string;\n    expected: unknown;\n    actual: unknown;\n    reason: MismatchReason;\n  }\n\n  export interface CompareResult {\n    ok: boolean;\n    mismatches: Mismatch[];\n  }\n  type ExpectedTransformFn<TValue = unknown> = (\n    value: TValue,\n    path: string\n  ) => unknown;\n  /**\n   * Transform config:\n   * - a single function: applies to the whole T\n   * - or an object shaped like T, where values are either:\n   *    - functions (apply at/under that node)\n   *    - nested objects continuing the shape\n   */\n  export type ExpectedTransformConfig<T, V = unknown> =\n    | ExpectedTransformFn<V>\n    | { [K in keyof T]?: ExpectedTransformConfig<T[K], T[K]> };\n  export interface EqualsOptions<T> {\n    /**\n     * How to transform the \"expected\" field in mismatches.\n     * If omitted, a default type-ish formatting is used.\n     */\n    transformExpected?: ExpectedTransformConfig<T>;\n  }\n  interface DeepCompareOptions<T> {\n    includeValueMismatch?: boolean;\n\n    transformExpected?: ExpectedTransformConfig<T>;\n  }\n\n  function defaultExpectedFormat(value: unknown): string {\n    if (value === null) return 'null';\n    if (Array.isArray(value)) return 'Array';\n    const t = typeof value;\n    if (t !== 'object') return t; // 'string', 'number', etc.\n    const ctor = (value as any)?.constructor?.name;\n    return ctor && ctor !== 'Object' ? ctor : 'object';\n  }\n\n  function splitPath(path: string): string[] {\n    if (!path) return [];\n    const parts: string[] = [];\n    const regex = /[^.[\\]]+|\\[(\\d+)\\]/g;\n    let m: RegExpExecArray | null;\n    while ((m = regex.exec(path))) {\n      parts.push(m[1] ?? m[0]);\n    }\n    return parts;\n  }\n\n  function getTransformFunction<T>(\n    root: ExpectedTransformConfig<T> | undefined,\n    path: string\n  ): ExpectedTransformFn | undefined {\n    if (!root) return undefined;\n\n    if (typeof root === 'function') {\n      // TS now knows this is ExpectedTransformFn, but we can be explicit:\n      return root as ExpectedTransformFn;\n    }\n\n    const segments = splitPath(path);\n    let node: any = root;\n    let lastFn: ExpectedTransformFn | undefined;\n\n    for (const seg of segments) {\n      if (!node) break;\n\n      if (typeof node === 'function') {\n        lastFn = node as ExpectedTransformFn;\n        break;\n      }\n\n      node = node[seg];\n\n      if (typeof node === 'function') {\n        lastFn = node as ExpectedTransformFn;\n        break;\n      }\n    }\n\n    return lastFn;\n  }\n\n  function formatExpected<T>(\n    rawExpected: unknown,\n    path: string,\n    cfg: ExpectedTransformConfig<T> | undefined\n  ): unknown {\n    const fn = getTransformFunction(cfg, path);\n    if (fn) return fn(rawExpected, path);\n    return defaultExpectedFormat(rawExpected);\n  }\n\n  function isObjectLike(v: unknown): v is Record<string, unknown> {\n    return typeof v === 'object' && v !== null;\n  }\n\n  function deepCompare<T>(\n    expected: unknown,\n    actual: unknown,\n    basePath: string,\n    mismatches: Mismatch[],\n    options: DeepCompareOptions<T>\n  ): Mismatch[] {\n    // identical (covers primitives + same-ref objects)\n    if (expected === actual) {\n      return mismatches;\n    }\n\n    // one is null/undefined OR types not object-like -> primitive / scalar mismatch\n    if (\n      expected === null ||\n      actual === null ||\n      typeof expected !== 'object' ||\n      typeof actual !== 'object'\n    ) {\n      const path = basePath || '(root)';\n\n      if (typeof expected !== typeof actual) {\n        mismatches.push({\n          path,\n          expected: formatExpected(expected, path, options.transformExpected),\n          actual,\n          reason: 'type-mismatch',\n        });\n        return mismatches;\n      }\n\n      if (options.includeValueMismatch) {\n        mismatches.push({\n          path,\n          expected: formatExpected(expected, path, options.transformExpected),\n          actual,\n          reason: 'value-mismatch',\n        });\n      }\n\n      return mismatches;\n    }\n\n    // arrays\n    if (Array.isArray(expected) || Array.isArray(actual)) {\n      if (!Array.isArray(expected) || !Array.isArray(actual)) {\n        const path = basePath || '(root)';\n        mismatches.push({\n          path,\n          expected: formatExpected(expected, path, options.transformExpected),\n          actual,\n          reason: 'type-mismatch',\n        });\n        return mismatches;\n      }\n\n      // Both values are arrays.\n      // We *do* compare element structure/types where both have an index, but we\n      // intentionally ignore length differences (no missing/extra index errors).\n      const maxLen = expected.length;\n\n      for (let i = 0; i < maxLen; i++) {\n        const expVal = expected[i];\n        const actVal = actual[i];\n        const path = basePath === '' ? `[${i}]` : `${basePath}[${i}]`;\n\n        deepCompare(expVal, actVal, path, mismatches, options);\n      }\n\n      return mismatches;\n    }\n\n    // plain objects\n    if (isObjectLike(expected) && isObjectLike(actual)) {\n      const expKeys = Object.keys(expected);\n      const actKeys = Object.keys(actual);\n\n      for (const key of expKeys) {\n        const expVal = (expected as any)[key];\n        const actVal = (actual as any)[key];\n        const path = basePath ? `${basePath}.${key}` : key;\n\n        if (!(key in actual)) {\n          mismatches.push({\n            path,\n            expected: formatExpected(expVal, path, options.transformExpected),\n            actual: undefined,\n            reason: 'missing-key',\n          });\n          continue;\n        }\n\n        deepCompare(expVal, actVal, path, mismatches, options);\n      }\n\n      for (const key of actKeys) {\n        if (!(key in expected)) {\n          const path = basePath ? `${basePath}.${key}` : key;\n          mismatches.push({\n            path,\n            expected: undefined,\n            actual: (actual as any)[key],\n            reason: 'extra-key',\n          });\n        }\n      }\n\n      return mismatches;\n    }\n\n    const path = basePath || '(root)';\n    if (typeof expected !== typeof actual) {\n      mismatches.push({\n        path,\n        expected: formatExpected(expected, path, options.transformExpected),\n        actual,\n        reason: 'type-mismatch',\n      });\n    } else if (options.includeValueMismatch) {\n      mismatches.push({\n        path,\n        expected: formatExpected(expected, path, options.transformExpected),\n        actual,\n        reason: 'value-mismatch',\n      });\n    }\n\n    return mismatches;\n  }\n\n  export function equalsAtPaths<def, paths extends DeepKeys<def>>(\n    obj: def,\n    paths: paths[],\n    actual: pickBy<def, paths>,\n    options?: EqualsOptions<def>\n  ): CompareResult {\n    // expected comes from obj at the given paths\n    const expected = pickBy<def, paths>(obj, ...paths);\n\n    const mismatches: Mismatch[] = [];\n\n    const basePath = paths.length === 1 ? (paths[0] as string) : '';\n\n    deepCompare<def>(expected, actual, basePath, mismatches, {\n      transformExpected: options?.transformExpected,\n    });\n\n    return {\n      ok: mismatches.length === 0,\n      mismatches,\n    };\n  }\n\n  function formatValue(v: unknown): string {\n    if (v === undefined) return 'undefined';\n    if (typeof v === 'string') return JSON.stringify(v); // add quotes\n    try {\n      return JSON.stringify(v, null, 2);\n    } catch {\n      return String(v);\n    }\n  }\n\n  function formatReason(m: Mismatch): string {\n    switch (m.reason) {\n      case 'missing-key':\n        return 'Missing key';\n      case 'extra-key':\n        return 'Extra key';\n      case 'type-mismatch':\n        return 'Type mismatch';\n      case 'value-mismatch':\n        return 'Value mismatch';\n      default:\n        return m.reason;\n    }\n  }\n\n  /**\n   * Turn a CompareResult into a pretty error string.\n   */\n  export function formatMismatches(result: CompareResult) {\n    if (result.ok || result.mismatches.length === 0) {\n      return 'No mismatches.';\n    }\n\n    const lines: string[] = [];\n\n    for (const m of result.mismatches) {\n      lines.push(\n        `\\n● ${formatReason(m)} at \"${m.path}\":`,\n        `    expected: ${formatValue(m.expected)}`,\n        `    actual:   ${formatValue(m.actual)}`,\n        '' // blank line between entries\n      );\n    }\n\n    // trim trailing blank line\n    if (lines.at(-1) === '') {\n      lines.pop();\n    }\n\n    return lines.join('\\n');\n  }\n\n  /**\n   * Convenience: log to console.error.\n   */\n  export function printMismatches(result: CompareResult): void {\n    const msg = formatMismatches(result);\n    if (msg !== 'No mismatches.') {\n      console.error(msg);\n    }\n  }\n\n  function setAtImmutable<\n    T extends Record<string, unknown>,\n    path extends DeepKeys<T>\n  >(root: T, path: path, value: pickBy<T, path>) {\n    const keys = path.split('.');\n\n    function helper(current: T, idx: number): any {\n      const key = keys[idx];\n      const resolvedCurrent = Array.isArray(current)\n        ? [...current]\n        : { ...current };\n\n      if (idx === keys.length - 1) {\n        let clone =\n          current && typeof current === 'object' ? resolvedCurrent : {};\n\n        clone = {\n          ...clone,\n          [key]: value,\n        };\n\n        return clone;\n      }\n\n      const next =\n        current && typeof current === 'object' ? current[key] : undefined;\n\n      const updatedChild = helper((next as T) ?? ({} as T), idx + 1);\n\n      let clone = current && typeof current === 'object' ? resolvedCurrent : {};\n\n      clone = {\n        ...clone,\n        [key]: updatedChild,\n      };\n\n      return clone;\n    }\n\n    return helper(root, 0);\n  }\n\n  export function findMissingPaths<\n    obj extends Record<string, unknown>,\n    path extends DeepKeys<obj>\n  >(obj: obj, paths: Array<path>, actual: pickBy<obj, path>) {\n    const keys: string[] = [];\n\n    for (const path of paths) {\n      const value = pickBy(obj, path);\n      const expectedKeys = createDeep(value);\n      const actualKeys = createDeep(actual);\n      const missingKeys = expectedKeys\n        .filter((key) => !actualKeys.includes(key))\n        .map((key) => `${path}.${key}`);\n\n      keys.push(...missingKeys);\n    }\n\n    return keys as Array<DeepKeys<obj>>;\n  }\n\n  export type updateAtOptions<\n    T extends Record<string, unknown>,\n    path extends DeepKeys<T>\n  > = {\n    obj: T;\n    paths: Array<path>;\n    value: pickBy<T, path>;\n    partial?: boolean;\n  };\n\n  function getPathThatMatter(path: string) {\n    // Only works when updating a `defaultValue`\n    // TODO make this work with the entire object - will need to figure out some way to normalize\n    const [, ...rest] = path.split('.defaultValue.');\n\n    return rest.join('.');\n  }\n\n  export function joinAtPath<\n    obj extends Record<string, unknown>,\n    path extends DeepKeys<obj>\n  >(paths: Array<path>, obj: obj, value: pickBy<obj, path>) {\n    if (paths.length === 1) {\n      const [path] = paths;\n      const missingData = pickBy(obj, ...paths);\n      const setPath = getPathThatMatter(path);\n\n      // if (last) {\n      //   const data = setBy(\n      //     value as Record<string, unknown>,\n      //     last,\n      //     missingData\n      //   ) as pickBy<obj, path>;\n\n      //   return data;\n      // }\n\n      const data = setBy(\n        value as Record<string, unknown>,\n        setPath,\n        missingData\n      ) as pickBy<obj, path>;\n\n      return data;\n    }\n\n    if (paths.length > 1) {\n      let resolvedValue = {} as Record<string, unknown>;\n\n      for (const path of paths) {\n        const pathThatMatters = getPathThatMatter(path);\n        const missing = joinAtPath([path], obj, value);\n        const valueAtPathThatMatters = getBy(obj, path);\n\n        // This check is here to ensure `resolvedValue` will only have\n        // nested properties where they belong.\n        if (\n          Object.keys(resolvedValue).length > 0 &&\n          valueAtPathThatMatters !== 'undefined'\n        ) {\n          const dataAtPath = pickBy(obj, path);\n          const [key] = pathThatMatters.split('.');\n\n          if (typeof dataAtPath === 'object') {\n            if (missing) {\n              resolvedValue = {\n                ...resolvedValue,\n                [key]: {\n                  ...(resolvedValue[key] as Record<string, unknown>),\n                  ...missing,\n                },\n              };\n            }\n          }\n\n          continue;\n        }\n\n        if (missing) {\n          resolvedValue = {\n            ...resolvedValue,\n            ...missing,\n          };\n        }\n      }\n\n      return resolvedValue as pickBy<obj, path>;\n    }\n  }\n\n  export function updateAt<\n    obj extends Record<string, unknown>,\n    path extends DeepKeys<obj>\n  >(options: updateAtOptions<obj, path>) {\n    const { obj, partial, paths, value } = options;\n    const norm = normalizePaths(...paths);\n    if (norm.length === 0) return obj;\n\n    let result = obj;\n    let resolvedValue = value;\n\n    if (partial) {\n      const missingPaths = findMissingPaths(obj, paths, value);\n\n      const missingData = joinAtPath(\n        missingPaths as Array<path>,\n        obj,\n        resolvedValue\n      );\n\n      resolvedValue = {\n        ...(resolvedValue as Record<string, unknown>),\n        ...(missingData as Record<string, unknown>),\n      } as pickBy<obj, path>;\n    }\n\n    if (norm.length === 1) {\n      // single path: value is relative at that path\n      const path = norm[0] as DeepKeys<obj>;\n\n      result = setAtImmutable(result, path, resolvedValue as never);\n\n      return result;\n    }\n\n    // multiple paths:\n    // value is the root-shaped object that contains all those paths\n    for (const path of norm) {\n      const sub = getBy(value, path);\n\n      result = setAtImmutable(result, path as DeepKeys<obj>, sub);\n    }\n\n    return result;\n  }\n}\n"],"mappings":"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"}