@jumoo/usync 0.0.0-stage → 17.5.1

package/dist/tree/manifest.js

@@ -0,0 +1,92 @@
+import { uSyncConstants, uSyncMenuElement } from '@jumoo/uSync';
+import { USYNC_CONDITION_NEW_SECTION } from '../conditions/constants';
+import { USYNC_SECTION_ALIAS } from './constants';
+const sectionAlias = 'Umb.Section.Settings';
+/*
+ * config slight of hand: This manifest is added in c#
+ * via a manaifestreader, that only adds it if a setting
+ * is true in the appsettings.json file.
+ *
+ * we can then use conditional code that will only allow
+ * the tree to show in settings when this section doesn't
+ * exist globally.
+ */
+/*
+const uSyncSection: UmbExtensionManifest = {
+    type: 'section',
+    alias: USYNC_SECTION_ALIAS,
+    name: 'uSync',
+    weight: 350,
+    meta: {
+        label: '#uSync_section',
+        pathname: 'sync',
+    },
+};
+*/
+const menuConstants = {
+    alias: 'usync.menu',
+    name: 'uSync',
+    icon: 'icon-infinity',
+    rootElement: uSyncConstants.workspace.rootElement,
+};
+const menu = {
+    type: 'menu',
+    alias: menuConstants.alias,
+    name: menuConstants.name,
+    meta: {
+        label: menuConstants.name,
+        icon: menuConstants.icon,
+        entityType: menuConstants.rootElement,
+    },
+};
+const menuItem = {
+    type: 'menuItem',
+    alias: 'usync.menu.item',
+    name: 'uSync menu item',
+    element: uSyncMenuElement,
+    meta: {
+        label: 'uSync',
+        icon: 'usync-logo',
+        entityType: uSyncConstants.workspace.rootElement,
+        menus: [menuConstants.alias],
+    },
+};
+const menuSidebarApp = {
+    type: 'sectionSidebarApp',
+    kind: 'menu',
+    alias: 'usync.sidebarapp',
+    name: 'uSync section sidebar menu',
+    weight: 150,
+    meta: {
+        label: '#uSync_section',
+        menu: menu.alias,
+    },
+    conditions: [
+        {
+            alias: 'Umb.Condition.SectionAlias',
+            oneOf: [sectionAlias, USYNC_SECTION_ALIAS],
+        },
+        {
+            alias: USYNC_CONDITION_NEW_SECTION,
+        },
+    ],
+};
+/// example of how to extend uSync menus.
+// const subMenuItem : ManifestuSyncMenuItem = {
+//     type: 'usync-menuItem',
+//     alias: 'usync.menu.sub.item',
+//     name: 'uSync core menu item',
+//     meta: {
+//         label: 'uSync Extension',
+//         icon: 'icon-brick',
+//         entityType: 'usync-root',
+//         menus: [uSyncConstants.menuAlias],
+//     }
+// }
+export const manifests = [
+    // uSyncSection,
+    menu,
+    menuSidebarApp,
+    menuItem,
+    // subMenuItem
+];

package/dist/tree/types.d.ts

@@ -0,0 +1,14 @@
+import { ManifestElement } from '@umbraco-cms/backoffice/extension-api';
+import { MetaMenuItem, UmbMenuItemElement } from '@umbraco-cms/backoffice/menu';
+/**
+ * Defines a sub menu item extension for the uSync menu
+ */
+export interface ManifestuSyncMenuItem extends ManifestElement<UmbMenuItemElement> {
+    type: 'usync-menuItem';
+    meta: MetaMenuItem;
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        ManifestuSyncMenuItem: ManifestuSyncMenuItem;
+    }
+}

package/dist/tree/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tree/usync.menu-element.d.ts

@@ -0,0 +1,13 @@
+import { LitElement } from '@umbraco-cms/backoffice/external/lit';
+import { ManifestMenuItem } from '@umbraco-cms/backoffice/menu';
+declare const uSyncMenuElement_base: import("@umbraco-cms/backoffice/extension-api").HTMLElementConstructor<import("@umbraco-cms/backoffice/element-api").UmbElement> & typeof LitElement;
+export declare class uSyncMenuElement extends uSyncMenuElement_base {
+    #private;
+    manifest: ManifestMenuItem;
+    hasChildren: boolean;
+    itemPath?: string;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+    renderChildren(): import("lit-html").TemplateResult<1>;
+}
+export default uSyncMenuElement;

package/dist/tree/usync.menu-element.js

@@ -0,0 +1,74 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _uSyncMenuElement_instances, _uSyncMenuElement_pathName, _uSyncMenuElement_constructHref;
+import { UmbElementMixin } from '@umbraco-cms/backoffice/element-api';
+import { umbExtensionsRegistry } from '@umbraco-cms/backoffice/extension-registry';
+import { LitElement, customElement, html, property, state, } from '@umbraco-cms/backoffice/external/lit';
+import { UMB_SECTION_CONTEXT } from '@umbraco-cms/backoffice/section';
+let uSyncMenuElement = class uSyncMenuElement extends UmbElementMixin(LitElement) {
+    constructor() {
+        super();
+        _uSyncMenuElement_instances.add(this);
+        _uSyncMenuElement_pathName.set(this, void 0);
+        this.hasChildren = false;
+        umbExtensionsRegistry.byType('usync-menuItem').subscribe((_items) => {
+            this.hasChildren = _items.length > 0;
+        });
+        this.consumeContext(UMB_SECTION_CONTEXT, (sectionContext) => {
+            this.observe(sectionContext?.pathname, (pathName) => {
+                __classPrivateFieldSet(this, _uSyncMenuElement_pathName, pathName, "f");
+                __classPrivateFieldGet(this, _uSyncMenuElement_instances, "m", _uSyncMenuElement_constructHref).call(this);
+            }, 'observePathname');
+        });
+    }
+    render() {
+        return html `<umb-menu-item-layout
+			label=${this.manifest.meta.label ?? this.manifest.name}
+			icon-name=${this.manifest.meta.icon ?? 'icon-bug'}
+			.href=${this.itemPath}
+			?has-Children=${this.hasChildren}
+			>${this.renderChildren()}
+		</umb-menu-item-layout>`;
+    }
+    renderChildren() {
+        return html `<umb-extension-slot
+			type="usync-menuItem"
+			default-element="umb-menu-item-default"></umb-extension-slot>`;
+    }
+};
+_uSyncMenuElement_pathName = new WeakMap();
+_uSyncMenuElement_instances = new WeakSet();
+_uSyncMenuElement_constructHref = function _uSyncMenuElement_constructHref() {
+    if (!__classPrivateFieldGet(this, _uSyncMenuElement_pathName, "f"))
+        return;
+    this.itemPath = `section/${__classPrivateFieldGet(this, _uSyncMenuElement_pathName, "f")}/workspace/${this.manifest.meta.entityType}`;
+};
+__decorate([
+    property({ type: Object, attribute: false })
+], uSyncMenuElement.prototype, "manifest", void 0);
+__decorate([
+    state()
+], uSyncMenuElement.prototype, "hasChildren", void 0);
+__decorate([
+    state()
+], uSyncMenuElement.prototype, "itemPath", void 0);
+uSyncMenuElement = __decorate([
+    customElement('usync-menu')
+], uSyncMenuElement);
+export { uSyncMenuElement };
+export default uSyncMenuElement;

package/dist/utils/diff/change-name.d.ts

@@ -0,0 +1,13 @@
+export interface USyncChangeLabel {
+    label: string;
+    prefix?: string;
+    culture?: string;
+    raw: string;
+}
+/**
+ * Splits a `USyncChange.name` into a display label, an optional `Property -`
+ * prefix, and an optional trailing culture. When nothing matches, the name is
+ * left completely alone - other trackers produce arbitrary names and we must
+ * not mangle them.
+ */
+export declare function parseChangeName(name: string): USyncChangeLabel;

package/dist/utils/diff/change-name.js

@@ -0,0 +1,30 @@
+// Tight language-tag pattern so a plain "(2)" (e.g. "Sort Order (2)") is never
+// mistaken for a culture - a culture must start with 2-3 letters.
+const CULTURE_SUFFIX = /^(.*?)\s*\(([A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*)\)\s*$/;
+const PROPERTY_PREFIX = /^Property\s*-\s*/;
+/**
+ * Splits a `USyncChange.name` into a display label, an optional `Property -`
+ * prefix, and an optional trailing culture. When nothing matches, the name is
+ * left completely alone - other trackers produce arbitrary names and we must
+ * not mangle them.
+ */
+export function parseChangeName(name) {
+    const cultureMatch = CULTURE_SUFFIX.exec(name);
+    let remaining = name;
+    let culture;
+    if (cultureMatch) {
+        remaining = cultureMatch[1];
+        culture = cultureMatch[2];
+    }
+    const prefixMatch = PROPERTY_PREFIX.exec(remaining);
+    let prefix;
+    let label = remaining;
+    if (prefixMatch) {
+        prefix = 'Property';
+        label = remaining.slice(prefixMatch[0].length);
+    }
+    if (!cultureMatch && !prefixMatch) {
+        return { label: name, raw: name };
+    }
+    return { label, prefix, culture, raw: name };
+}

package/dist/utils/diff/classify-change.d.ts

@@ -0,0 +1,21 @@
+import type { USyncChange } from '../../api/types.gen.js';
+import { type USyncClassifiedChange } from './types.js';
+export declare const USYNC_MASKED_VALUE = "*****";
+export type USyncJsonContainerResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+};
+/**
+ * Parses `text` as a JSON *container* (object or array) only. Bare scalars
+ * such as `123` or `"hi"` parse successfully with `JSON.parse` but are never
+ * what we mean by "this is a JSON value to structurally diff" - a
+ * `textstring` of `123` must not be treated as JSON.
+ */
+export declare function tryParseJsonContainer(text: string): USyncJsonContainerResult;
+/**
+ * Classifies a `USyncChange` detail into a diff strategy, in priority order.
+ * See the plan for the full rationale behind the ordering.
+ */
+export declare function classifyChange(detail: USyncChange): USyncClassifiedChange;

package/dist/utils/diff/classify-change.js

@@ -0,0 +1,111 @@
+import { USYNC_DIFF_LIMITS } from './types.js';
+// `ChangeDetailType` is an enum, and importing it as a value is not permitted
+// here (only type-only imports from the generated API types are allowed) -
+// so its members are matched against their known string values instead.
+const CHANGE_NO_CHANGE = 'NoChange';
+const CHANGE_ERROR = 'Error';
+const CHANGE_WARNING = 'Warning';
+export const USYNC_MASKED_VALUE = '*****';
+const RAW_XML_DETAIL_NAME = 'Raw XML';
+/**
+ * Parses `text` as a JSON *container* (object or array) only. Bare scalars
+ * such as `123` or `"hi"` parse successfully with `JSON.parse` but are never
+ * what we mean by "this is a JSON value to structurally diff" - a
+ * `textstring` of `123` must not be treated as JSON.
+ */
+export function tryParseJsonContainer(text) {
+    const trimmed = text.trim();
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
+        return { ok: false };
+    try {
+        const value = JSON.parse(trimmed);
+        if (value === null || typeof value !== 'object')
+            return { ok: false };
+        return { ok: true, value };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function byteLength(text) {
+    return new TextEncoder().encode(text).length;
+}
+const XML_START = /^\s*</;
+/**
+ * Classifies a `USyncChange` detail into a diff strategy, in priority order.
+ * See the plan for the full rationale behind the ordering.
+ */
+export function classifyChange(detail) {
+    const { oldValue, newValue, name } = detail;
+    const change = detail.change;
+    if (change === CHANGE_NO_CHANGE) {
+        return skip(oldValue, newValue);
+    }
+    if (change === CHANGE_ERROR) {
+        return notice(oldValue);
+    }
+    if (change === CHANGE_WARNING) {
+        return notice(newValue);
+    }
+    if (oldValue === USYNC_MASKED_VALUE || newValue === USYNC_MASKED_VALUE) {
+        return build('masked', oldValue, newValue, 'text');
+    }
+    const bytes = Math.max(byteLength(oldValue), byteLength(newValue));
+    const forceXml = name === RAW_XML_DETAIL_NAME;
+    if (bytes > USYNC_DIFF_LIMITS.maxDiffBytes) {
+        return build('oversized', oldValue, newValue, forceXml ? 'xml' : 'text', bytes);
+    }
+    if (oldValue === newValue) {
+        return skip(oldValue, newValue);
+    }
+    if (oldValue === '' || newValue === '') {
+        return build('single', oldValue, newValue, forceXml ? 'xml' : 'text', bytes);
+    }
+    const oldJson = tryParseJsonContainer(oldValue);
+    const newJson = tryParseJsonContainer(newValue);
+    if (oldJson.ok && newJson.ok) {
+        return {
+            strategy: 'json',
+            oldText: oldValue,
+            newText: newValue,
+            oldJson: oldJson.value,
+            newJson: newJson.value,
+            language: 'json',
+            bytes,
+        };
+    }
+    if (forceXml || XML_START.test(oldValue) || XML_START.test(newValue)) {
+        return build('lines', oldValue, newValue, 'xml', bytes);
+    }
+    if (oldValue.includes('\n') || newValue.includes('\n')) {
+        return build('lines', oldValue, newValue, 'text', bytes);
+    }
+    if (bytes <= USYNC_DIFF_LIMITS.inlineScalarChars) {
+        return build('scalar', oldValue, newValue, 'text', bytes);
+    }
+    if (bytes <= USYNC_DIFF_LIMITS.maxWordDiffBytes) {
+        return build('words', oldValue, newValue, 'text', bytes);
+    }
+    return build('lines', oldValue, newValue, 'text', bytes);
+}
+function skip(oldValue, newValue) {
+    return build('skip', oldValue, newValue, 'text');
+}
+function notice(message) {
+    return {
+        strategy: 'notice',
+        oldText: message,
+        newText: message,
+        language: 'text',
+        bytes: byteLength(message),
+    };
+}
+function build(strategy, oldValue, newValue, language, bytes) {
+    return {
+        strategy,
+        oldText: oldValue,
+        newText: newValue,
+        language,
+        bytes: bytes ?? Math.max(byteLength(oldValue), byteLength(newValue)),
+    };
+}

package/dist/utils/diff/deep-equal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A short tag describing the "shape" of a value, used to decide whether two
+ * values are even comparable as the same kind of thing (object vs array vs
+ * primitive) before doing a structural walk.
+ */
+export declare function typeTag(value: unknown): string;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Structural equality for JSON-shaped values (objects, arrays, strings,
+ * numbers, booleans, null). Array order is significant. Object key order is
+ * not.
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;

package/dist/utils/diff/deep-equal.js

@@ -0,0 +1,57 @@
+/**
+ * A short tag describing the "shape" of a value, used to decide whether two
+ * values are even comparable as the same kind of thing (object vs array vs
+ * primitive) before doing a structural walk.
+ */
+export function typeTag(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    const t = typeof value;
+    if (t === 'object')
+        return 'object';
+    return t;
+}
+export function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Structural equality for JSON-shaped values (objects, arrays, strings,
+ * numbers, booleans, null). Array order is significant. Object key order is
+ * not.
+ */
+export function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (const key of aKeys) {
+            if (!Object.prototype.hasOwnProperty.call(b, key))
+                return false;
+            if (!deepEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    // Different shapes (one array one object, one object one primitive, etc.)
+    // or unequal primitives - already excluded by the `a === b` check above.
+    return false;
+}

package/dist/utils/diff/format-value.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Joins a path segment onto a base path, using `.key` for identifier-safe
+ * keys and `["odd key"]` otherwise.
+ */
+export declare function joinKey(base: string, key: string): string;
+export interface USyncElementPathOptions {
+    /** Positional index, used when no identity label is available. */
+    index?: number;
+    /**
+     * A pre-built identity label (e.g. `headline (en-US)` for the
+     * alias+culture composite identity) - when set this *is* the element's
+     * identity, so no index/derived-label lookup happens.
+     */
+    identityLabel?: string;
+}
+/**
+ * Builds a readable path segment for an array element, e.g. `[0: Hero]` for
+ * an index-matched element, or `[headline (en-US)]` for an element matched by
+ * a composite alias+culture identity.
+ */
+export declare function elementPath(base: string, element: unknown, options?: USyncElementPathOptions): string;
+/**
+ * Truncates a long path in the middle, keeping the trailing leaf segment
+ * (the part the reader actually cares about) fully intact.
+ */
+export declare function formatDiffPath(path: string, maxLen?: number): string;
+/**
+ * Short, display-agnostic stringification of a leaf value for inline
+ * rendering (e.g. `old → new`). Callers decide layout/markup; this only
+ * turns a value into text.
+ */
+export declare function formatLeafValue(value: unknown): string;
+/** Pretty-prints a parsed JSON value the same way the server does. */
+export declare function prettyJson(value: unknown): string;
+/** Truncates a string in the middle to roughly `maxLen` characters. */
+export declare function truncateMiddle(text: string, maxLen: number): string;

package/dist/utils/diff/format-value.js

@@ -0,0 +1,88 @@
+import { isPlainObject } from './deep-equal.js';
+const IDENTIFIER_KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+ * Joins a path segment onto a base path, using `.key` for identifier-safe
+ * keys and `["odd key"]` otherwise.
+ */
+export function joinKey(base, key) {
+    if (IDENTIFIER_KEY.test(key)) {
+        return base.length > 0 ? `${base}.${key}` : key;
+    }
+    return `${base}[${JSON.stringify(key)}]`;
+}
+const ELEMENT_LABEL_FIELDS = [
+    'name',
+    'alias',
+    'editorAlias',
+    'propertyAlias',
+    'contentTypeAlias',
+    '$type',
+    'culture',
+];
+function deriveElementLabel(element) {
+    if (!isPlainObject(element))
+        return undefined;
+    for (const field of ELEMENT_LABEL_FIELDS) {
+        const value = element[field];
+        if (typeof value === 'string' && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * Builds a readable path segment for an array element, e.g. `[0: Hero]` for
+ * an index-matched element, or `[headline (en-US)]` for an element matched by
+ * a composite alias+culture identity.
+ */
+export function elementPath(base, element, options = {}) {
+    if (options.identityLabel !== undefined) {
+        return `${base}[${options.identityLabel}]`;
+    }
+    const index = options.index ?? 0;
+    const label = deriveElementLabel(element);
+    return label !== undefined ? `${base}[${index}: ${label}]` : `${base}[${index}]`;
+}
+const LEAF_SEGMENT = /(\.[^.[\]]+|\[[^\]]*\])$/;
+/**
+ * Truncates a long path in the middle, keeping the trailing leaf segment
+ * (the part the reader actually cares about) fully intact.
+ */
+export function formatDiffPath(path, maxLen = 120) {
+    if (path.length <= maxLen)
+        return path;
+    const leafMatch = LEAF_SEGMENT.exec(path);
+    const leaf = leafMatch ? leafMatch[0] : '';
+    const headLen = Math.max(maxLen - leaf.length - 1, 0);
+    const head = path.slice(0, headLen);
+    return `${head}…${leaf}`;
+}
+/**
+ * Short, display-agnostic stringification of a leaf value for inline
+ * rendering (e.g. `old → new`). Callers decide layout/markup; this only
+ * turns a value into text.
+ */
+export function formatLeafValue(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return JSON.stringify(value);
+}
+/** Pretty-prints a parsed JSON value the same way the server does. */
+export function prettyJson(value) {
+    return JSON.stringify(value, null, 1);
+}
+/** Truncates a string in the middle to roughly `maxLen` characters. */
+export function truncateMiddle(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    const ellipsis = '…';
+    const keep = Math.max(maxLen - ellipsis.length, 0);
+    const headLen = Math.ceil(keep / 2);
+    const tailLen = Math.floor(keep / 2);
+    return `${text.slice(0, headLen)}${ellipsis}${text.slice(text.length - tailLen)}`;
+}

package/dist/utils/diff/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './deep-equal.js';
+export * from './format-value.js';
+export * from './change-name.js';
+export * from './classify-change.js';
+export * from './json-diff.js';
+export * from './line-diff.js';

package/dist/utils/diff/index.js

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './deep-equal.js';
+export * from './format-value.js';
+export * from './change-name.js';
+export * from './classify-change.js';
+export * from './json-diff.js';
+export * from './line-diff.js';

package/dist/utils/diff/json-diff.d.ts

@@ -0,0 +1,34 @@
+import { type USyncJsonDiffResult } from './types.js';
+/**
+ * Composite identities are tried before single fields, and in the order
+ * listed - a block's `values` entries and property values key on
+ * alias(+culture/segment) almost always, and that composite survives
+ * serialisation round-trips even when raw GUIDs don't.
+ */
+export declare const USYNC_COMPOSITE_IDENTITIES: string[][];
+export declare const USYNC_IDENTITY_FIELDS: string[];
+interface IdentityStrategy {
+    isComposite: boolean;
+    keyOf(element: Record<string, unknown>): string;
+    labelOf(element: Record<string, unknown>): string;
+}
+/**
+ * Picks an identity strategy for matching elements of two arrays by identity
+ * rather than position, or `null` when neither array offers one (the caller
+ * should fall back to index matching).
+ */
+export declare function pickIdentity(a: unknown[], b: unknown[]): IdentityStrategy | null;
+export interface USyncJsonDiffOptions {
+    maxChanges?: number;
+    maxDepth?: number;
+    expandJsonStrings?: boolean;
+    maxStringExpansions?: number;
+}
+/**
+ * Structurally diffs two parsed JSON values, producing a flat list of leaf
+ * changes with readable paths instead of a wholesale before/after dump.
+ * Arrays are matched by identity where possible (see `pickIdentity`) so that
+ * inserting one block does not make every other block look changed.
+ */
+export declare function diffJsonValues(oldValue: unknown, newValue: unknown, options?: USyncJsonDiffOptions): USyncJsonDiffResult;
+export {};