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

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,407 @@
+
+//#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);
+			const setPath = getPathThatMatter(path$1);
+			if (setPath === "") {
+				if (missingData !== null && missingData !== void 0 && typeof missingData === "object") return missingData;
+				return;
+			}
+			return setBy(value, setPath, 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;
+	/**
+	* Check if an array contains objects (not primitives)
+	*/
+	function isArrayOfObjects(arr) {
+		return arr.length > 0 && arr.every((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+	}
+	/**
+	* Merge two array elements, handling objects recursively
+	* sourceItem is the new value, targetItem is the original (missing data)
+	* We want to preserve targetItem properties and let sourceItem override
+	*/
+	function mergeArrayElement(sourceItem, targetItem) {
+		if (targetItem === void 0) return sourceItem;
+		if (sourceItem !== null && typeof sourceItem === "object" && !Array.isArray(sourceItem) && targetItem !== null && typeof targetItem === "object" && !Array.isArray(targetItem)) return mergeObjects(sourceItem, targetItem);
+		return sourceItem;
+	}
+	/**
+	* Deep merge two objects recursively
+	* Target (original/missing data) is the base, source (new value) overrides
+	*/
+	function mergeObjects(source, target) {
+		const result = { ...target };
+		for (const key in source) if (key in result) result[key] = deepMergePreserveType(source[key], result[key]);
+		else result[key] = source[key];
+		return result;
+	}
+	/**
+	* Deep merge two values while preserving their structure.
+	* - Arrays:
+	*   - If both are arrays of objects: merge element-wise
+	*   - If both are arrays of primitives: use source (replacement)
+	*   - Otherwise: use source
+	* - Objects: deep merge nested properties
+	* - Primitives: use source value
+	*/
+	function deepMergePreserveType(source, target) {
+		if (target === void 0 || target === null) return source;
+		if (Array.isArray(source)) {
+			if (Array.isArray(target)) {
+				const sourceArr = source;
+				const targetArr = target;
+				if (isArrayOfObjects(sourceArr) && isArrayOfObjects(targetArr)) return sourceArr.map((item, index) => {
+					const targetItem = targetArr[index];
+					if (targetItem !== void 0) return mergeArrayElement(item, targetItem);
+					return item;
+				});
+				if (sourceArr.length === 0) return source;
+				return [...targetArr, ...sourceArr];
+			}
+			return source;
+		}
+		if (source !== null && typeof source === "object") {
+			if (target !== null && typeof target === "object" && !Array.isArray(target)) return mergeObjects(source, target);
+			return source;
+		}
+		return source;
+	}
+	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) {
+			let missingData = joinAtPath(findMissingPaths(obj, paths, value), obj, resolvedValue);
+			if (missingData === void 0 || typeof missingData === "object" && missingData !== null && Object.keys(missingData).length === 0) {
+				if (norm.length === 1) {
+					const originalValue = getBy(obj, norm[0]);
+					if (originalValue !== void 0) {
+						if (Array.isArray(originalValue) && Array.isArray(resolvedValue)) {
+							if (resolvedValue.length > 0) missingData = originalValue;
+						} else if (originalValue !== null && typeof originalValue === "object" && !Array.isArray(originalValue) && resolvedValue !== null && typeof resolvedValue === "object" && !Array.isArray(resolvedValue)) missingData = originalValue;
+					}
+				} else if (norm.length > 1) {
+					const originalData = {};
+					for (const p of norm) {
+						const originalValue = getBy(obj, p);
+						if (originalValue !== void 0) setBy(originalData, p, originalValue);
+					}
+					if (Object.keys(originalData).length > 0) missingData = originalData;
+				}
+			}
+			resolvedValue = deepMergePreserveType(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(resolvedValue, 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