@acorex-platform/framework-shared 0.0.1

package/core/src/lib/utils/object-util.js

@@ -0,0 +1,679 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractNestedFieldsWildcard = extractNestedFieldsWildcard;
+exports.setSmart = setSmart;
+exports.getSmart = getSmart;
+exports.extractValue = extractValue;
+exports.cleanDeep = cleanDeep;
+exports.getChangedPaths = getChangedPaths;
+exports.getDetailedChanges = getDetailedChanges;
+exports.getEnumValues = getEnumValues;
+exports.shouldRestoreSavedMultiLanguageShape = shouldRestoreSavedMultiLanguageShape;
+exports.isSelectionValueEqual = isSelectionValueEqual;
+exports.isFormValueEqual = isFormValueEqual;
+exports.isFormContextDirty = isFormContextDirty;
+exports.summarizeFormContextDirtyDiff = summarizeFormContextDirtyDiff;
+exports.captureFormContextBaseline = captureFormContextBaseline;
+const lodash_es_1 = require("lodash-es");
+const locale_map_value_util_1 = require("../multi-language-string/locale-map-value.util");
+function extractNestedFieldsWildcard(obj, basePath, fields) {
+    const result = {};
+    if (fields.length === 1 && fields[0] === '*') {
+        const fullObj = (0, lodash_es_1.get)(obj, basePath);
+        return (0, lodash_es_1.isPlainObject)(fullObj) ? fullObj : {};
+    }
+    for (const field of fields) {
+        const fullPath = basePath ? `${basePath}.${field}` : field;
+        const value = (0, lodash_es_1.get)(obj, fullPath);
+        (0, lodash_es_1.set)(result, field, value);
+    }
+    return result;
+}
+function setSmart(obj, smartPath, value) {
+    var _a, _b;
+    const pathParts = smartPath.split('.');
+    const lastPart = pathParts[pathParts.length - 1];
+    const fieldMatch = lastPart.match(/^\{(.+)\}$/);
+    if (!fieldMatch) {
+        // Fix: If value is undefined and we're setting a nested property,
+        // check if the parent object exists and if setting this would result in
+        // all properties being undefined. If so, set the parent to null instead.
+        if ((0, lodash_es_1.isNil)(value) && pathParts.length > 1) {
+            const parentPath = pathParts.slice(0, -1).join('.');
+            const parentObj = (0, lodash_es_1.get)(obj, parentPath);
+            // If parent is already null/undefined, don't recreate the object structure
+            if ((0, lodash_es_1.isNil)(parentObj)) {
+                return obj;
+            }
+            // Check if parent is a plain object (not array, not null)
+            if ((0, lodash_es_1.isPlainObject)(parentObj)) {
+                const existingKeys = Object.keys(parentObj);
+                // Check if all existing properties are null/undefined using lodash
+                const allNil = (0, lodash_es_1.isEmpty)(existingKeys) || existingKeys.every((key) => (0, lodash_es_1.isNil)(parentObj[key]));
+                if (allNil) {
+                    // Set parent to null instead of creating/keeping an object with all undefined properties
+                    (0, lodash_es_1.set)(obj, parentPath, null);
+                    return obj;
+                }
+            }
+        }
+        (0, lodash_es_1.set)(obj, smartPath, value);
+        // After setting, check again if parent should be null using lodash
+        if ((0, lodash_es_1.isNil)(value) && pathParts.length > 1) {
+            const parentPath = pathParts.slice(0, -1).join('.');
+            const parentObj = (0, lodash_es_1.get)(obj, parentPath);
+            if ((0, lodash_es_1.isPlainObject)(parentObj)) {
+                // Use lodash to check if all properties are null/undefined
+                const allNil = Object.keys(parentObj).every((key) => (0, lodash_es_1.isNil)(parentObj[key]));
+                if (allNil) {
+                    (0, lodash_es_1.set)(obj, parentPath, null);
+                }
+            }
+        }
+        return obj;
+    }
+    const fields = fieldMatch[1].split(',').map((f) => f.trim());
+    const basePath = pathParts.slice(0, -1).join('.');
+    const [arrayKey, ...restPath] = basePath.split('.');
+    // Make sure the array exists
+    if (!obj[arrayKey])
+        obj[arrayKey] = [];
+    // 🟡 Case A: value is array (normal set)
+    if ((0, lodash_es_1.isArray)(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            const targetItem = (_a = obj[arrayKey][i]) !== null && _a !== void 0 ? _a : {};
+            const nested = {};
+            if (restPath.length > 0) {
+                const picked = extractNestedFieldsWildcard(item, restPath.join('.'), fields);
+                (0, lodash_es_1.set)(nested, restPath.join('.'), picked);
+            }
+            else {
+                const picked = extractNestedFieldsWildcard(item, '', fields);
+                Object.assign(nested, picked);
+            }
+            obj[arrayKey][i] = (0, lodash_es_1.merge)({}, targetItem, nested);
+        }
+    }
+    // 🟢 Case B: value is a single value → broadcast
+    else {
+        for (let i = 0; i < obj[arrayKey].length; i++) {
+            const targetItem = (_b = obj[arrayKey][i]) !== null && _b !== void 0 ? _b : {};
+            const nested = {};
+            if (restPath.length > 0) {
+                for (const field of fields) {
+                    (0, lodash_es_1.set)(nested, `${restPath.join('.')}.${field}`, value);
+                }
+            }
+            else {
+                for (const field of fields) {
+                    (0, lodash_es_1.set)(nested, field, value);
+                }
+            }
+            obj[arrayKey][i] = (0, lodash_es_1.merge)({}, targetItem, nested);
+        }
+    }
+    return obj;
+}
+function extractFieldsFromPath(obj, basePath, fields) {
+    if (fields.length === 1 && fields[0] === '*') {
+        const fullObj = basePath ? (0, lodash_es_1.get)(obj, basePath) : obj;
+        return (0, lodash_es_1.isPlainObject)(fullObj) ? fullObj : {};
+    }
+    const result = {};
+    for (const field of fields) {
+        const fullPath = basePath ? `${basePath}.${field}` : field;
+        const val = (0, lodash_es_1.get)(obj, fullPath);
+        if (val !== undefined) {
+            result[field] = val;
+        }
+    }
+    return result;
+}
+function getSmart(obj, smartPath) {
+    const pathParts = smartPath.split('.');
+    const lastPart = pathParts[pathParts.length - 1];
+    const fieldMatch = lastPart.match(/^\{(.+)\}$/);
+    // Simple get (no fields)
+    if (!fieldMatch) {
+        return (0, lodash_es_1.get)(obj, smartPath);
+    }
+    const fields = fieldMatch[1].split(',').map((f) => f.trim());
+    const basePath = pathParts.slice(0, -1).join('.');
+    const items = (0, lodash_es_1.get)(obj, basePath);
+    if (!(0, lodash_es_1.isArray)(items))
+        return [];
+    const nestedPath = basePath.includes('.') ? basePath.split('.').slice(1).join('.') : '';
+    return items.map((item) => {
+        return extractFieldsFromPath(item, nestedPath, fields);
+    });
+}
+function extractValue(value, key = 'id') {
+    if ((0, lodash_es_1.isNil)(value)) {
+        return null;
+    }
+    return (0, lodash_es_1.isObjectLike)(value) ? (0, lodash_es_1.get)(value, key) : value;
+}
+function cleanDeep(obj) {
+    return (0, lodash_es_1.transform)(obj, (result, value, key) => {
+        if ((0, lodash_es_1.isObjectLike)(value)) {
+            const cleaned = cleanDeep(value);
+            if (!(0, lodash_es_1.isEmpty)(cleaned)) {
+                result[key] = cleaned;
+            }
+        }
+        else if (!(0, lodash_es_1.isNil)(value) && // not null or undefined
+            !(typeof value === 'string' && value.trim() === '') && // not empty string
+            !(Array.isArray(value) && value.length === 0) // not empty array
+        ) {
+            result[key] = value;
+        }
+    });
+}
+function getDeepChanges(obj1, obj2) {
+    const changes = [];
+    function walk(o1, o2, currentPath = []) {
+        // If both values are deeply equal, skip
+        if ((0, lodash_es_1.isEqual)(o1, o2))
+            return;
+        const isObj1Nil = o1 === null || o1 === undefined;
+        const isObj2Nil = o2 === null || o2 === undefined;
+        // If obj1 is null/undefined and obj2 is not, treat entire obj2 as added
+        if (isObj1Nil && !isObj2Nil) {
+            if ((0, lodash_es_1.isPlainObject)(o2)) {
+                for (const key of Object.keys(o2)) {
+                    walk(undefined, o2[key], [...currentPath, key]);
+                }
+            }
+            else if (Array.isArray(o2)) {
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: undefined,
+                    newValue: o2,
+                    arrayDiff: {
+                        added: o2,
+                        removed: [],
+                    },
+                });
+            }
+            else {
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: undefined,
+                    newValue: o2,
+                });
+            }
+            return;
+        }
+        // If obj2 is null/undefined and obj1 is not, treat entire obj1 as removed
+        if (!isObj1Nil && isObj2Nil) {
+            if ((0, lodash_es_1.isPlainObject)(o1)) {
+                for (const key of Object.keys(o1)) {
+                    walk(o1[key], undefined, [...currentPath, key]);
+                }
+            }
+            else if (Array.isArray(o1)) {
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: o1,
+                    newValue: undefined,
+                    arrayDiff: {
+                        added: [],
+                        removed: o1,
+                    },
+                });
+            }
+            else {
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: o1,
+                    newValue: undefined,
+                });
+            }
+            return;
+        }
+        // If both are arrays, compare items
+        if (Array.isArray(o1) && Array.isArray(o2)) {
+            if (!(0, lodash_es_1.isEqual)(o1, o2)) {
+                const added = (0, lodash_es_1.differenceWith)(o2, o1, lodash_es_1.isEqual);
+                const removed = (0, lodash_es_1.differenceWith)(o1, o2, lodash_es_1.isEqual);
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: o1,
+                    newValue: o2,
+                    arrayDiff: {
+                        added,
+                        removed,
+                    },
+                });
+            }
+            return;
+        }
+        // If both are plain objects, walk each key
+        if ((0, lodash_es_1.isPlainObject)(o1) && (0, lodash_es_1.isPlainObject)(o2)) {
+            const allKeys = (0, lodash_es_1.union)(Object.keys(o1), Object.keys(o2));
+            for (const key of allKeys) {
+                walk(o1[key], o2[key], [...currentPath, key]);
+            }
+            return;
+        }
+        // Primitive values or mismatched types
+        changes.push({
+            path: currentPath.join('.'),
+            oldValue: o1,
+            newValue: o2,
+        });
+    }
+    walk(obj1, obj2);
+    return changes;
+}
+// Method 1: Returns only changed paths
+function getChangedPaths(obj1, obj2) {
+    return getDeepChanges(obj1, obj2).map((change) => change.path);
+}
+// Method 2: Returns full change entries
+function getDetailedChanges(obj1, obj2) {
+    return getDeepChanges(obj1, obj2);
+}
+function getEnumValues(enumType) {
+    return Object.entries(enumType).map(([key, value]) => ({ id: value, title: key }));
+}
+//#region ---- Form value equality (dirty / baseline) ----
+/** Whether a value uses the multi-language text widget shape (string or locale map). */
+function isMultiLanguageFormShape(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return true;
+    }
+    return (0, locale_map_value_util_1.isLocaleStringMap)(value);
+}
+/** Drops empty/whitespace locale entries from a multi-language map. */
+function normalizeLocaleStringMap(value) {
+    const normalized = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry !== 'string') {
+            continue;
+        }
+        const trimmed = entry.trim();
+        if (trimmed !== '') {
+            normalized[key] = trimmed;
+        }
+    }
+    return Object.keys(normalized).length === 0 ? null : normalized;
+}
+function compareMultiLanguageLocaleStrings(a, b) {
+    const htmlEqual = compareHtmlFormValues(a, b);
+    if (htmlEqual !== null) {
+        return htmlEqual;
+    }
+    return a === b;
+}
+/**
+ * Compares multi-language field values (plain string vs locale map) for dirty/baseline checks.
+ * Returns `null` when either side is not a multi-language shape (caller uses generic normalization).
+ */
+function compareMultiLanguageFormValues(a, b) {
+    if (!isMultiLanguageFormShape(a) || !isMultiLanguageFormShape(b)) {
+        return null;
+    }
+    const normalizeScalar = (value) => {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            return trimmed === '' ? null : trimmed;
+        }
+        if ((0, locale_map_value_util_1.isLocaleStringMap)(value)) {
+            return normalizeLocaleStringMap(value);
+        }
+        return null;
+    };
+    const left = normalizeScalar(a);
+    const right = normalizeScalar(b);
+    if (left === null && right === null) {
+        return true;
+    }
+    if (left === null || right === null) {
+        return false;
+    }
+    if (typeof left === 'string' && typeof right === 'string') {
+        return compareMultiLanguageLocaleStrings(left, right);
+    }
+    if (typeof left === 'string' && typeof right === 'object') {
+        return Object.values(right).some((text) => typeof text === 'string' && compareMultiLanguageLocaleStrings(left, text));
+    }
+    if (typeof right === 'string' && typeof left === 'object') {
+        return Object.values(left).some((text) => typeof text === 'string' && compareMultiLanguageLocaleStrings(right, text));
+    }
+    if (typeof left !== 'object' || typeof right !== 'object') {
+        return false;
+    }
+    const leftMap = left;
+    const rightMap = right;
+    const leftKeys = Object.keys(leftMap).sort();
+    const rightKeys = Object.keys(rightMap).sort();
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    return leftKeys.every((key) => compareMultiLanguageLocaleStrings(leftMap[key], rightMap[key]));
+}
+/**
+ * Lookup/select expose may write a resolved MLS string while the baseline keeps the locale map.
+ * Restore baseline shape when the string matches any locale entry.
+ */
+function shouldRestoreSavedMultiLanguageShape(value, savedAtPath) {
+    if (typeof value !== 'string' || !(0, locale_map_value_util_1.isLocaleStringMap)(savedAtPath)) {
+        return false;
+    }
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return false;
+    }
+    return Object.values(savedAtPath).some((entry) => typeof entry === 'string' && entry.trim() === trimmed);
+}
+/** Decode common HTML entities for rich-text baseline compare. */
+function decodeHtmlEntities(value) {
+    return value
+        .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+        .replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(parseInt(dec, 10)))
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"');
+}
+function looksLikeHtmlFormValue(value) {
+    return /<[a-z][\s\S]*>/i.test(value.trim());
+}
+/** Normalizes rich-text HTML for semantic dirty/baseline compare (e.g. Quill `p`/`br` drift). */
+function normalizeRichTextHtmlForCompare(value) {
+    var _a;
+    const html = decodeHtmlEntities(value.trim());
+    if (typeof document === 'undefined') {
+        return html.replace(/\s+/g, ' ').trim();
+    }
+    const doc = new DOMParser().parseFromString(html, 'text/html');
+    return ((_a = doc.body.textContent) !== null && _a !== void 0 ? _a : '').replace(/\s+/g, ' ').trim();
+}
+/**
+ * Compares rich-text HTML strings by visible text (ignores `p` vs `br` structure drift).
+ * Returns `null` when either side is not HTML markup.
+ */
+function compareHtmlFormValues(a, b) {
+    if (typeof a !== 'string' || typeof b !== 'string') {
+        return null;
+    }
+    if (!looksLikeHtmlFormValue(a) || !looksLikeHtmlFormValue(b)) {
+        return null;
+    }
+    return normalizeRichTextHtmlForCompare(a) === normalizeRichTextHtmlForCompare(b);
+}
+/** Lookup/select filter-mode payload: `{ value, displayText?, operation }`. */
+function isFilterFormShape(value) {
+    if (!(0, lodash_es_1.isPlainObject)(value)) {
+        return false;
+    }
+    const record = value;
+    return 'value' in record && 'operation' in record;
+}
+/**
+ * Compares filter-mode widget values by selection identity; ignores derived `displayText`.
+ */
+function compareFilterFormValues(a, b) {
+    if (!isFilterFormShape(a) || !isFilterFormShape(b)) {
+        return null;
+    }
+    const left = a;
+    const right = b;
+    if (!isFormValueEqual(left['value'], right['value'])) {
+        return false;
+    }
+    const opLeft = (0, lodash_es_1.get)(left, 'operation.type');
+    const opRight = (0, lodash_es_1.get)(right, 'operation.type');
+    if (opLeft !== undefined || opRight !== undefined) {
+        return opLeft === opRight;
+    }
+    return true;
+}
+function isReferenceScalar(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+/** Scalar id or `{ id }` identity used by lookup/select widgets. */
+function getReferenceId(value) {
+    if ((0, lodash_es_1.isNil)(value)) {
+        return undefined;
+    }
+    if (isReferenceScalar(value)) {
+        return value;
+    }
+    if ((0, lodash_es_1.isPlainObject)(value)) {
+        const id = (0, lodash_es_1.get)(value, 'id');
+        if (!(0, lodash_es_1.isNil)(id)) {
+            return id;
+        }
+    }
+    return undefined;
+}
+/**
+ * Compares scalar selection ids to full lookup/select items (`5` vs `{ id: 5, ... }`).
+ * Does not apply when both sides are objects — those use structural compare so field edits stay dirty.
+ */
+function compareReferenceFormValues(a, b) {
+    const refA = getReferenceId(a);
+    const refB = getReferenceId(b);
+    if (refA === undefined || refB === undefined) {
+        return null;
+    }
+    const aIsScalar = isReferenceScalar(a);
+    const bIsScalar = isReferenceScalar(b);
+    if (!aIsScalar && !bIsScalar) {
+        return null;
+    }
+    return (0, lodash_es_1.isEqual)(normalizeFormValue(refA), normalizeFormValue(refB));
+}
+/**
+ * Semantic equality for lookup/select values when restoring saved baseline shape.
+ * Compares by selection identity (id), including two full items with the same id.
+ */
+function isSelectionValueEqual(a, b) {
+    const filterEqual = compareFilterFormValues(a, b);
+    if (filterEqual !== null) {
+        return filterEqual;
+    }
+    const refA = getReferenceId(a);
+    const refB = getReferenceId(b);
+    if (refA !== undefined && refB !== undefined) {
+        return (0, lodash_es_1.isEqual)(normalizeFormValue(refA), normalizeFormValue(refB));
+    }
+    return isFormValueEqual(a, b);
+}
+/**
+ * Stable sort key for order-insensitive array comparison (after normalization).
+ */
+function formValueSortKey(value) {
+    if (value === null) {
+        return '\0';
+    }
+    if (typeof value === 'number') {
+        return `n:${value}`;
+    }
+    if (typeof value === 'boolean') {
+        return `b:${value}`;
+    }
+    if (typeof value === 'string') {
+        return `s:${value}`;
+    }
+    try {
+        return `j:${JSON.stringify(value)}`;
+    }
+    catch (_a) {
+        return `u:${String(value)}`;
+    }
+}
+/**
+ * Sorts normalized array items so order does not affect dirty checks.
+ */
+function sortNormalizedArrayItems(items) {
+    return [...items].sort((a, b) => formValueSortKey(a).localeCompare(formValueSortKey(b)));
+}
+/**
+ * Normalizes a form/context value for semantic baseline comparison.
+ *
+ * Rules:
+ * - `null`, `undefined`, whitespace-only strings, and empty arrays → `null` (empty)
+ * - Numeric strings → numbers (`"5"` and `5` match)
+ * - Arrays → elements normalized; empty/all-empty → `null`; otherwise sorted (order ignored)
+ * - Plain objects → keys sorted; `null`/empty nested values omitted
+ * - `Date` → epoch milliseconds
+ */
+function normalizeFormValue(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return null;
+        }
+        if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+            const num = Number(trimmed);
+            if (!Number.isNaN(num)) {
+                return num;
+            }
+        }
+        return trimmed;
+    }
+    if (typeof value === 'number') {
+        return Number.isNaN(value) ? null : value;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if ((0, lodash_es_1.isArray)(value)) {
+        const normalizedItems = value
+            .map((item) => normalizeFormValue(item))
+            .filter((item) => item !== null);
+        if (normalizedItems.length === 0) {
+            return null;
+        }
+        return sortNormalizedArrayItems(normalizedItems);
+    }
+    if ((0, lodash_es_1.isPlainObject)(value)) {
+        const record = value;
+        if ((0, locale_map_value_util_1.isLocaleStringMap)(record)) {
+            return normalizeLocaleStringMap(record);
+        }
+        const normalized = {};
+        for (const key of Object.keys(record).sort()) {
+            const next = normalizeFormValue(record[key]);
+            if (next !== null) {
+                normalized[key] = next;
+            }
+        }
+        return normalized;
+    }
+    return value;
+}
+/**
+ * Semantic equality for dirty-state and baseline checks.
+ * Prefer over lodash `isEqual` when comparing user-edited form/context data to a saved baseline.
+ *
+ * Arrays: `[]`, `null`, and all-empty lists are equivalent; non-empty arrays compare as multisets (order ignored).
+ */
+function isFormValueEqual(a, b) {
+    const multiLanguageEqual = compareMultiLanguageFormValues(a, b);
+    if (multiLanguageEqual !== null) {
+        return multiLanguageEqual;
+    }
+    const filterEqual = compareFilterFormValues(a, b);
+    if (filterEqual !== null) {
+        return filterEqual;
+    }
+    const referenceEqual = compareReferenceFormValues(a, b);
+    if (referenceEqual !== null) {
+        return referenceEqual;
+    }
+    if ((0, lodash_es_1.isArray)(a) && (0, lodash_es_1.isArray)(b)) {
+        // Empty repeater rows normalize away; raw length must differ before multiset compare.
+        if (a.length !== b.length) {
+            return false;
+        }
+        return (0, lodash_es_1.isEqual)(normalizeFormValue(a), normalizeFormValue(b));
+    }
+    if ((0, lodash_es_1.isPlainObject)(a) && (0, lodash_es_1.isPlainObject)(b)) {
+        const left = a;
+        const right = b;
+        const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+        for (const key of keys) {
+            if (!isFormValueEqual(left[key], right[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (typeof a === 'string' && typeof b === 'string') {
+        const htmlEqual = compareHtmlFormValues(a, b);
+        if (htmlEqual !== null) {
+            return htmlEqual;
+        }
+    }
+    return (0, lodash_es_1.isEqual)(normalizeFormValue(a), normalizeFormValue(b));
+}
+/**
+ * Returns whether `current` differs from the saved/clean `baseline` snapshot.
+ */
+function isFormContextDirty(current, baseline) {
+    return !isFormValueEqual(current, baseline);
+}
+/**
+ * Lists paths where live context differs from baseline (for dirty-state trace logs).
+ */
+function summarizeFormContextDirtyDiff(current, baseline, maxEntries = 12) {
+    const diffs = [];
+    const walk = (path, currentValue, baselineValue) => {
+        if (diffs.length >= maxEntries) {
+            return;
+        }
+        if (isFormValueEqual(currentValue, baselineValue)) {
+            return;
+        }
+        const bothPlainObjects = (0, lodash_es_1.isPlainObject)(currentValue) &&
+            (0, lodash_es_1.isPlainObject)(baselineValue) &&
+            !(0, lodash_es_1.isArray)(currentValue) &&
+            !(0, lodash_es_1.isArray)(baselineValue);
+        if (bothPlainObjects) {
+            const left = currentValue;
+            const right = baselineValue;
+            const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+            for (const key of keys) {
+                if (diffs.length >= maxEntries) {
+                    return;
+                }
+                const nextPath = path ? `${path}.${key}` : key;
+                walk(nextPath, left[key], right[key]);
+            }
+            return;
+        }
+        diffs.push({
+            path: path || '(root)',
+            current: currentValue,
+            baseline: baselineValue,
+            selectionEqual: isSelectionValueEqual(currentValue, baselineValue),
+        });
+    };
+    walk('', current, baseline);
+    return diffs;
+}
+/**
+ * Clones a context object for use as a dirty-tracking baseline.
+ */
+function captureFormContextBaseline(context) {
+    return (0, lodash_es_1.cloneDeep)(context);
+}
+//#endregion
+//# sourceMappingURL=object-util.js.map