@researchdatabox/sails-ng-common 5.0.3 → 5.0.4-beta.12498

package/dist/src/record-concurrency.model.js

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * Data-only optimistic-concurrency contracts shared by the server and browser.
+ * Runtime policy enforcement remains a backend responsibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecordConcurrencyRequestId = exports.RECORD_CONCURRENCY_REQUEST_ID_MAX_LENGTH = exports.RECORD_FORM_FINGERPRINT_PATTERN = exports.RECORD_FORM_FINGERPRINT_MAX_LENGTH = exports.RECORD_ENTITY_TAG_PATTERN = exports.RECORD_ENTITY_TAG_RECORD_ID_MAX_LENGTH = exports.RECORD_ENTITY_TAG_MAX_LENGTH = exports.RECORD_ENTITY_TAG_VERSION = exports.RECORD_REVISION_MAX = exports.RECORD_CONCURRENCY_PROBLEM_CODES = exports.RECORD_CONCURRENCY_RESOLUTIONS = exports.DEFAULT_RECORD_CONCURRENT_MODIFICATION_CONFIG = exports.DEFAULT_RECORD_CONCURRENT_MODIFICATION_MODE = exports.RECORD_CONCURRENT_MODIFICATION_MODES = void 0;
+exports.isRecordConcurrentModificationMode = isRecordConcurrentModificationMode;
+exports.validateRecordConcurrentModificationConfig = validateRecordConcurrentModificationConfig;
+exports.isRecordConcurrentModificationConfig = isRecordConcurrentModificationConfig;
+exports.resolveRecordConcurrentModificationConfig = resolveRecordConcurrentModificationConfig;
+exports.resolveRecordConcurrentModificationMode = resolveRecordConcurrentModificationMode;
+exports.coerceRecordConcurrentModificationConfig = coerceRecordConcurrentModificationConfig;
+exports.isRecordConcurrencyResolution = isRecordConcurrencyResolution;
+exports.isRecordConcurrencyProblemCode = isRecordConcurrencyProblemCode;
+exports.isRecordRevision = isRecordRevision;
+exports.recordEntityTagRevision = recordEntityTagRevision;
+exports.isRecordEntityTag = isRecordEntityTag;
+exports.isRecordFormFingerprint = isRecordFormFingerprint;
+exports.isRecordConcurrencyMetadata = isRecordConcurrencyMetadata;
+exports.sanitizeRecordConcurrencyMetadata = sanitizeRecordConcurrencyMetadata;
+const plain_record_1 = require("./internal/plain-record");
+const record_save_model_1 = require("./record-save.model");
+exports.RECORD_CONCURRENT_MODIFICATION_MODES = ['last-write-wins', 'observe', 'strict'];
+exports.DEFAULT_RECORD_CONCURRENT_MODIFICATION_MODE = 'last-write-wins';
+exports.DEFAULT_RECORD_CONCURRENT_MODIFICATION_CONFIG = Object.freeze({
+    mode: exports.DEFAULT_RECORD_CONCURRENT_MODIFICATION_MODE,
+});
+exports.RECORD_CONCURRENCY_RESOLUTIONS = [
+    'direct',
+    'already-current',
+    'client-auto-merged',
+    'client-manually-resolved',
+    'internal',
+];
+exports.RECORD_CONCURRENCY_PROBLEM_CODES = [
+    'record-precondition-required',
+    'record-revision-stale',
+    'record-deleted',
+    'record-concurrency-capability-unavailable',
+    'form-definition-changed',
+    'record-lifecycle-operation-conflict',
+];
+/** Revisions are exact non-negative integers, not timestamps or floating-point counters. */
+exports.RECORD_REVISION_MAX = Number.MAX_SAFE_INTEGER;
+/**
+ * Entity tags are quoted, bounded, opaque values produced by one backend
+ * helper. Clients retain and return the complete value; they never construct a
+ * tag from the numeric revision.
+ */
+exports.RECORD_ENTITY_TAG_VERSION = 'rb-record-v1';
+exports.RECORD_ENTITY_TAG_MAX_LENGTH = 128;
+exports.RECORD_ENTITY_TAG_RECORD_ID_MAX_LENGTH = 1_024;
+/** Base64url SHA-256 digest length, without padding. */
+const RECORD_ENTITY_TAG_DIGEST_LENGTH = 43;
+/**
+ * `"<version>.<revision>.<digest>"`. Built from the version constant so a
+ * future format bump cannot leave the guard matching the previous shape.
+ */
+exports.RECORD_ENTITY_TAG_PATTERN = new RegExp(`^"${exports.RECORD_ENTITY_TAG_VERSION}\\.(0|[1-9][0-9]{0,15})\\.[A-Za-z0-9_-]{${RECORD_ENTITY_TAG_DIGEST_LENGTH}}"$`);
+/**
+ * Form fingerprints are deliberately independent of record revisions and
+ * entity tags: an administrator editing a form must not invalidate API
+ * operations that never rendered it.
+ */
+exports.RECORD_FORM_FINGERPRINT_MAX_LENGTH = 128;
+exports.RECORD_FORM_FINGERPRINT_PATTERN = record_save_model_1.RECORD_SAVE_PUBLIC_IDENTIFIER_PATTERN;
+function isRecordConcurrentModificationMode(value) {
+    return typeof value === 'string' && exports.RECORD_CONCURRENT_MODIFICATION_MODES.includes(value);
+}
+/**
+ * Validate absent, valid, and malformed record-type policy. Absent policy is
+ * the compatibility default; an explicit but malformed policy is reported so
+ * enforcement boundaries can fail closed rather than silently defaulting.
+ * No raw input is retained in the result.
+ */
+function validateRecordConcurrentModificationConfig(value) {
+    if (value === undefined || value === null) {
+        return {
+            valid: true,
+            config: { ...exports.DEFAULT_RECORD_CONCURRENT_MODIFICATION_CONFIG },
+            defaulted: true,
+        };
+    }
+    if (!(0, plain_record_1.isPlainRecord)(value)) {
+        return { valid: false, reason: 'malformed-config' };
+    }
+    if (!isRecordConcurrentModificationMode(value.mode)) {
+        return { valid: false, reason: 'malformed-mode' };
+    }
+    return { valid: true, config: { mode: value.mode }, defaulted: false };
+}
+/** True only for an explicit, well-formed policy object. */
+function isRecordConcurrentModificationConfig(value) {
+    const validation = validateRecordConcurrentModificationConfig(value);
+    return validation.valid && !validation.defaulted;
+}
+/**
+ * Resolve the compatibility default while failing closed for explicit
+ * malformed policy. Use this at enforcement boundaries, where guessing a mode
+ * would risk permitting an unguarded write.
+ */
+function resolveRecordConcurrentModificationConfig(value) {
+    const validation = validateRecordConcurrentModificationConfig(value);
+    if (!validation.valid) {
+        throw new TypeError(`Record concurrent-modification configuration is ${validation.reason}.`);
+    }
+    return validation.config;
+}
+function resolveRecordConcurrentModificationMode(value) {
+    return resolveRecordConcurrentModificationConfig(value).mode;
+}
+/**
+ * Non-throwing counterpart for presentation boundaries such as record-type
+ * discovery, where one corrupted stored policy must not break an unrelated
+ * listing. Reporting the default is safe because it cannot loosen enforcement:
+ * a malformed policy still fails closed when a mutation resolves it.
+ */
+function coerceRecordConcurrentModificationConfig(value) {
+    const validation = validateRecordConcurrentModificationConfig(value);
+    return validation.valid ? validation.config : { ...exports.DEFAULT_RECORD_CONCURRENT_MODIFICATION_CONFIG };
+}
+function isRecordConcurrencyResolution(value) {
+    return typeof value === 'string' && exports.RECORD_CONCURRENCY_RESOLUTIONS.includes(value);
+}
+function isRecordConcurrencyProblemCode(value) {
+    return typeof value === 'string' && exports.RECORD_CONCURRENCY_PROBLEM_CODES.includes(value);
+}
+function isRecordRevision(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= exports.RECORD_REVISION_MAX;
+}
+function recordEntityTagRevision(value) {
+    if (typeof value !== 'string' || value.length > exports.RECORD_ENTITY_TAG_MAX_LENGTH)
+        return undefined;
+    const match = exports.RECORD_ENTITY_TAG_PATTERN.exec(value);
+    const revision = match ? Number(match[1]) : undefined;
+    return isRecordRevision(revision) ? revision : undefined;
+}
+/**
+ * Structural entity-tag guard. Record identity is certified by the backend
+ * parser, which recomputes the digest for a known OID; this guard only proves
+ * the value has the bounded opaque shape worth carrying in client state.
+ */
+function isRecordEntityTag(value) {
+    return recordEntityTagRevision(value) !== undefined;
+}
+function isRecordFormFingerprint(value) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= exports.RECORD_FORM_FINGERPRINT_MAX_LENGTH &&
+        exports.RECORD_FORM_FINGERPRINT_PATTERN.test(value));
+}
+exports.RECORD_CONCURRENCY_REQUEST_ID_MAX_LENGTH = record_save_model_1.RECORD_SAVE_REQUEST_ID_MAX_LENGTH;
+/** Diagnostic request linkage uses the same canonical save request-id format. */
+exports.isRecordConcurrencyRequestId = record_save_model_1.isRecordSaveRequestId;
+/** Runtime guard used at transport boundaries for bounded concurrency metadata. */
+function isRecordConcurrencyMetadata(value) {
+    if (!(0, plain_record_1.isPlainRecord)(value)) {
+        return false;
+    }
+    return ((value.mode === undefined || isRecordConcurrentModificationMode(value.mode)) &&
+        (value.revision === undefined || isRecordRevision(value.revision)) &&
+        (value.expectedRevision === undefined || isRecordRevision(value.expectedRevision)) &&
+        (value.currentRevision === undefined || isRecordRevision(value.currentRevision)) &&
+        (value.entityTag === undefined || isRecordEntityTag(value.entityTag)) &&
+        (value.formFingerprint === undefined || isRecordFormFingerprint(value.formFingerprint)) &&
+        (value.resolution === undefined || isRecordConcurrencyResolution(value.resolution)) &&
+        (value.resolutionOfRequestId === undefined || (0, exports.isRecordConcurrencyRequestId)(value.resolutionOfRequestId)));
+}
+/**
+ * Copy only valid bounded fields from untrusted or cross-runtime metadata.
+ * Unknown keys are dropped rather than carried, so a payload cannot widen the
+ * diagnostic contract. Returns `undefined` when nothing survives.
+ */
+function sanitizeRecordConcurrencyMetadata(value) {
+    if (!(0, plain_record_1.isPlainRecord)(value)) {
+        return undefined;
+    }
+    const result = {};
+    if (isRecordConcurrentModificationMode(value.mode))
+        result.mode = value.mode;
+    if (isRecordRevision(value.revision))
+        result.revision = value.revision;
+    if (isRecordRevision(value.expectedRevision))
+        result.expectedRevision = value.expectedRevision;
+    if (isRecordRevision(value.currentRevision))
+        result.currentRevision = value.currentRevision;
+    if (isRecordEntityTag(value.entityTag))
+        result.entityTag = value.entityTag;
+    if (isRecordFormFingerprint(value.formFingerprint))
+        result.formFingerprint = value.formFingerprint;
+    if (isRecordConcurrencyResolution(value.resolution))
+        result.resolution = value.resolution;
+    if ((0, exports.isRecordConcurrencyRequestId)(value.resolutionOfRequestId)) {
+        result.resolutionOfRequestId = value.resolutionOfRequestId;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/record-diff.d.ts

@@ -0,0 +1,69 @@
+/** A property or array-index path through a JSON-like record value. */
+export type RecordValuePath = Array<string | number>;
+export type RecordValueChangeKind = 'add' | 'delete' | 'change';
+/**
+ * One structural change between two JSON-like values.
+ *
+ * Object additions/deletions and array-index additions/deletions retain their
+ * historical backend semantics. Concurrency callers should use
+ * `diffRecordValuesForConcurrency`, which treats an array as one atomic value.
+ */
+export interface RecordValueChange {
+    readonly kind: RecordValueChangeKind;
+    readonly path: RecordValuePath;
+    readonly original: unknown;
+    readonly changed: unknown;
+}
+export interface RecordValueOverlap {
+    readonly path: RecordValuePath;
+    readonly local: RecordValueChange;
+    readonly remote: RecordValueChange;
+    readonly resolved: boolean;
+}
+export interface ThreeWayRecordDiff {
+    readonly localChanges: readonly RecordValueChange[];
+    readonly remoteChanges: readonly RecordValueChange[];
+    readonly applicableLocalChanges: readonly RecordValueChange[];
+    readonly resolvedOverlaps: readonly RecordValueOverlap[];
+    readonly unresolvedOverlaps: readonly RecordValueOverlap[];
+    /** True when latest already contains every base-to-local final value. */
+    readonly localChangesAlreadyPresent: boolean;
+}
+export interface ThreeWayRecordRebase<T> extends ThreeWayRecordDiff {
+    /** Latest plus only base-to-local changes that do not diverge from remote. */
+    readonly candidate: T;
+}
+/**
+ * Pure recursive diff retaining the established FormRecordConsistencyService
+ * add/delete/change and path ordering contract.
+ */
+export declare function diffRecordValues(original: unknown, changed: unknown, path?: readonly (string | number)[]): RecordValueChange[];
+/**
+ * Collapse a descendant of an array to the containing array path. Numeric path
+ * segments are emitted only by array traversal; numeric-looking object keys
+ * remain strings and therefore remain ordinary object properties.
+ */
+export declare function normalizeConcurrencyPath(path: readonly (string | number)[]): RecordValuePath;
+/** Prefix-aware path overlap: equality, local parent, or remote parent. */
+export declare function recordValuePathsOverlap(first: readonly (string | number)[], second: readonly (string | number)[]): boolean;
+/** Deterministic deep equality for JSON-like values; object key order is ignored. */
+export declare function canonicallyEqualRecordValues(first: unknown, second: unknown): boolean;
+/**
+ * Concurrency diff with arrays/repeatables represented by one whole-value
+ * change at their root. The ordinary diff remains index-based for audit users.
+ */
+export declare function diffRecordValuesForConcurrency(original: unknown, changed: unknown, path?: readonly (string | number)[]): RecordValueChange[];
+/**
+ * Compare base/local/latest and classify overlaps using final projected state,
+ * not merely the leaf values stored on individual diff entries.
+ */
+export declare function compareThreeWayRecordValues(base: unknown, local: unknown, latest: unknown): ThreeWayRecordDiff;
+/**
+ * Clone latest and apply the supplied structural changes without mutating any
+ * snapshot. Numeric deletes against the same array are applied from the
+ * highest index down, so a compatible `diffRecordValues()` result cannot
+ * shift a later delete onto the wrong item.
+ */
+export declare function applyRecordValueChanges<T>(latest: T, changes: readonly RecordValueChange[]): T;
+/** Build latest-plus-local while retaining divergent overlaps for later review. */
+export declare function rebaseRecordValues<T>(base: unknown, local: unknown, latest: T): ThreeWayRecordRebase<T>;

package/dist/src/record-diff.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffRecordValues = diffRecordValues;
+exports.normalizeConcurrencyPath = normalizeConcurrencyPath;
+exports.recordValuePathsOverlap = recordValuePathsOverlap;
+exports.canonicallyEqualRecordValues = canonicallyEqualRecordValues;
+exports.diffRecordValuesForConcurrency = diffRecordValuesForConcurrency;
+exports.compareThreeWayRecordValues = compareThreeWayRecordValues;
+exports.applyRecordValueChanges = applyRecordValueChanges;
+exports.rebaseRecordValues = rebaseRecordValues;
+const lodash_1 = require("lodash");
+const plain_record_1 = require("./internal/plain-record");
+/**
+ * Pure recursive diff retaining the established FormRecordConsistencyService
+ * add/delete/change and path ordering contract.
+ */
+function diffRecordValues(original, changed, path = []) {
+    if (original === changed)
+        return [];
+    const originalArray = Array.isArray(original);
+    const changedArray = Array.isArray(changed);
+    const originalRecord = (0, plain_record_1.isPlainRecord)(original);
+    const changedRecord = (0, plain_record_1.isPlainRecord)(changed);
+    if ((originalArray && changedArray) || (originalRecord && changedRecord)) {
+        const originalKeys = valueKeys(original);
+        const changedKeys = valueKeys(changed);
+        const originalKeySet = new Set(originalKeys);
+        const changedKeySet = new Set(changedKeys);
+        const result = [];
+        for (const key of originalKeys) {
+            const nextPath = [...path, key];
+            const originalValue = valueAtKey(original, key);
+            if (!changedKeySet.has(key)) {
+                result.push({ kind: 'delete', path: nextPath, original: originalValue, changed: undefined });
+                continue;
+            }
+            result.push(...diffRecordValues(originalValue, valueAtKey(changed, key), nextPath));
+        }
+        for (const key of changedKeys) {
+            if (originalKeySet.has(key))
+                continue;
+            result.push({
+                kind: 'add',
+                path: [...path, key],
+                original: undefined,
+                changed: valueAtKey(changed, key),
+            });
+        }
+        return result;
+    }
+    return [{ kind: 'change', path: [...path], original, changed }];
+}
+/**
+ * Collapse a descendant of an array to the containing array path. Numeric path
+ * segments are emitted only by array traversal; numeric-looking object keys
+ * remain strings and therefore remain ordinary object properties.
+ */
+function normalizeConcurrencyPath(path) {
+    const firstArrayIndex = path.findIndex(segment => typeof segment === 'number');
+    return firstArrayIndex < 0 ? [...path] : path.slice(0, firstArrayIndex);
+}
+/** Prefix-aware path overlap: equality, local parent, or remote parent. */
+function recordValuePathsOverlap(first, second) {
+    const commonLength = Math.min(first.length, second.length);
+    for (let index = 0; index < commonLength; index += 1) {
+        if (first[index] !== second[index])
+            return false;
+    }
+    return true;
+}
+/** Deterministic deep equality for JSON-like values; object key order is ignored. */
+function canonicallyEqualRecordValues(first, second) {
+    return (0, lodash_1.isEqual)(first, second);
+}
+/**
+ * Concurrency diff with arrays/repeatables represented by one whole-value
+ * change at their root. The ordinary diff remains index-based for audit users.
+ */
+function diffRecordValuesForConcurrency(original, changed, path = []) {
+    if (canonicallyEqualRecordValues(original, changed))
+        return [];
+    if (Array.isArray(original) || Array.isArray(changed)) {
+        return [{ kind: 'change', path: [...path], original, changed }];
+    }
+    const originalRecord = (0, plain_record_1.isPlainRecord)(original);
+    const changedRecord = (0, plain_record_1.isPlainRecord)(changed);
+    if (originalRecord && changedRecord) {
+        const result = [];
+        const changedKeys = new Set(Object.keys(changed));
+        const originalKeys = Object.keys(original);
+        const originalKeySet = new Set(originalKeys);
+        for (const key of originalKeys) {
+            const nextPath = [...path, key];
+            if (!changedKeys.has(key)) {
+                result.push({ kind: 'delete', path: nextPath, original: original[key], changed: undefined });
+                continue;
+            }
+            result.push(...diffRecordValuesForConcurrency(original[key], changed[key], nextPath));
+        }
+        for (const key of Object.keys(changed)) {
+            if (originalKeySet.has(key))
+                continue;
+            result.push({ kind: 'add', path: [...path, key], original: undefined, changed: changed[key] });
+        }
+        return result;
+    }
+    return [{ kind: 'change', path: [...path], original, changed }];
+}
+/**
+ * Compare base/local/latest and classify overlaps using final projected state,
+ * not merely the leaf values stored on individual diff entries.
+ */
+function compareThreeWayRecordValues(base, local, latest) {
+    const localChanges = diffRecordValuesForConcurrency(base, local);
+    const remoteChanges = diffRecordValuesForConcurrency(base, latest);
+    const resolvedOverlaps = [];
+    const unresolvedOverlaps = [];
+    const localWithDivergentOverlap = new Set();
+    for (const localChange of localChanges) {
+        for (const remoteChange of remoteChanges) {
+            if (!recordValuePathsOverlap(localChange.path, remoteChange.path))
+                continue;
+            const overlapPath = localChange.path.length <= remoteChange.path.length ? localChange.path : remoteChange.path;
+            const resolved = locatedValuesEqual(valueAtPath(local, overlapPath), valueAtPath(latest, overlapPath));
+            const overlap = {
+                path: [...overlapPath],
+                local: localChange,
+                remote: remoteChange,
+                resolved,
+            };
+            if (resolved) {
+                resolvedOverlaps.push(overlap);
+            }
+            else {
+                unresolvedOverlaps.push(overlap);
+                localWithDivergentOverlap.add(localChange);
+            }
+        }
+    }
+    const applicableLocalChanges = localChanges.filter(change => {
+        if (localWithDivergentOverlap.has(change))
+            return false;
+        return !remoteChanges.some(remote => recordValuePathsOverlap(change.path, remote.path));
+    });
+    const localChangesAlreadyPresent = localChanges.every(change => locatedValuesEqual(valueAtPath(local, change.path), valueAtPath(latest, change.path)));
+    return {
+        localChanges,
+        remoteChanges,
+        applicableLocalChanges,
+        resolvedOverlaps,
+        unresolvedOverlaps,
+        localChangesAlreadyPresent,
+    };
+}
+/**
+ * Clone latest and apply the supplied structural changes without mutating any
+ * snapshot. Numeric deletes against the same array are applied from the
+ * highest index down, so a compatible `diffRecordValues()` result cannot
+ * shift a later delete onto the wrong item.
+ */
+function applyRecordValueChanges(latest, changes) {
+    let result = (0, lodash_1.cloneDeep)(latest);
+    for (const change of changesInApplicationOrder(changes)) {
+        if (change.path.length === 0) {
+            result = change.kind === 'delete' ? undefined : (0, lodash_1.cloneDeep)(change.changed);
+            continue;
+        }
+        result = applyChangeAtPath(result, change);
+    }
+    return result;
+}
+function changesInApplicationOrder(changes) {
+    const arrayDeleteGroups = new Map();
+    for (const change of changes) {
+        const key = arrayDeleteParentKey(change);
+        if (key === undefined)
+            continue;
+        const group = arrayDeleteGroups.get(key) ?? [];
+        group.push(change);
+        arrayDeleteGroups.set(key, group);
+    }
+    for (const group of arrayDeleteGroups.values()) {
+        group.sort((first, second) => {
+            const firstIndex = first.path[first.path.length - 1];
+            const secondIndex = second.path[second.path.length - 1];
+            return secondIndex - firstIndex;
+        });
+        for (let index = 1; index < group.length; index += 1) {
+            const previousIndex = group[index - 1].path[group[index - 1].path.length - 1];
+            const currentIndex = group[index].path[group[index].path.length - 1];
+            if (previousIndex === currentIndex) {
+                throw new TypeError('A record change set cannot delete the same array index more than once.');
+            }
+        }
+    }
+    const emittedGroups = new Set();
+    const ordered = [];
+    for (const change of changes) {
+        const key = arrayDeleteParentKey(change);
+        if (key === undefined) {
+            ordered.push(change);
+            continue;
+        }
+        if (emittedGroups.has(key))
+            continue;
+        emittedGroups.add(key);
+        ordered.push(...(arrayDeleteGroups.get(key) ?? []));
+    }
+    return ordered;
+}
+function arrayDeleteParentKey(change) {
+    if (change.kind !== 'delete' || change.path.length === 0)
+        return undefined;
+    const finalSegment = change.path[change.path.length - 1];
+    if (typeof finalSegment !== 'number')
+        return undefined;
+    if (!Number.isSafeInteger(finalSegment) || finalSegment < 0) {
+        throw new TypeError('A record change array index must be a non-negative safe integer.');
+    }
+    return JSON.stringify(change.path.slice(0, -1));
+}
+/** Build latest-plus-local while retaining divergent overlaps for later review. */
+function rebaseRecordValues(base, local, latest) {
+    const comparison = compareThreeWayRecordValues(base, local, latest);
+    return {
+        ...comparison,
+        candidate: applyRecordValueChanges(latest, comparison.applicableLocalChanges),
+    };
+}
+function valueKeys(value) {
+    if (Array.isArray(value))
+        return Array.from({ length: value.length }, (_, index) => index);
+    return (0, plain_record_1.isPlainRecord)(value) ? Object.keys(value) : [];
+}
+function valueAtKey(value, key) {
+    return value[key];
+}
+function valueAtPath(value, path) {
+    let current = value;
+    if (path.length === 0)
+        return { exists: true, value: current };
+    for (const segment of path) {
+        if ((!Array.isArray(current) && !(0, plain_record_1.isPlainRecord)(current)) || !hasOwn(current, segment)) {
+            return { exists: false, value: undefined };
+        }
+        current = current[segment];
+    }
+    return { exists: true, value: current };
+}
+function locatedValuesEqual(first, second) {
+    return first.exists === second.exists && (!first.exists || canonicallyEqualRecordValues(first.value, second.value));
+}
+function applyChangeAtPath(root, change) {
+    const clonedRoot = isContainer(root) ? root : containerFor(change.path[0]);
+    let parent = clonedRoot;
+    for (let index = 0; index < change.path.length - 1; index += 1) {
+        const segment = change.path[index];
+        const nextSegment = change.path[index + 1];
+        // Never traverse an inherited container. In particular, `__proto__` on a
+        // normal object resolves to Object.prototype; reusing it would let an
+        // otherwise ordinary record change mutate the global prototype.
+        const existing = hasOwn(parent, segment) ? parent[segment] : undefined;
+        const next = isContainer(existing) ? existing : containerFor(nextSegment);
+        defineValue(parent, segment, next);
+        parent = next;
+    }
+    const finalSegment = change.path[change.path.length - 1];
+    if (change.kind === 'delete') {
+        if (Array.isArray(parent) && typeof finalSegment === 'number') {
+            parent.splice(finalSegment, 1);
+        }
+        else {
+            delete parent[finalSegment];
+        }
+    }
+    else {
+        defineValue(parent, finalSegment, (0, lodash_1.cloneDeep)(change.changed));
+    }
+    return clonedRoot;
+}
+function defineValue(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value,
+    });
+}
+function containerFor(segment) {
+    return typeof segment === 'number' ? [] : {};
+}
+function isContainer(value) {
+    return Array.isArray(value) || (0, plain_record_1.isPlainRecord)(value);
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-diff.js","sourceRoot":"","sources":["../../src/record-diff.ts"],"names":[],"mappings":"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"}