@anzusystems/common-admin 1.49.0 → 2.0.0-rc.1

package/dist/domains/listEditor/composables/useListEditorStateScope.js

@@ -0,0 +1,105 @@
+import { useListEditorController as e } from "./useListEditorController.js";
+import { useNestedListEditorController as t } from "./useNestedListEditorController.js";
+import { effectScope as n, getCurrentInstance as r, getCurrentScope as i, inject as a, onBeforeUnmount as o, onScopeDispose as s, provide as c, shallowRef as l, toValue as u } from "vue";
+//#region src/domains/listEditor/composables/useListEditorStateScope.ts
+var d = Symbol("le.stateScope"), f = 0;
+function p() {
+	let e = `les${++f}`, t = /* @__PURE__ */ new Map(), r = n(), a = (e, n) => {
+		n.children?.dispose(), n.scope.stop(), t.delete(e);
+	}, o = {
+		id: e,
+		resolve(e, i, a, o = null) {
+			let s = t.get(e);
+			if (s) return s.boundUid !== null && o !== null && s.boundUid !== o && console.warn(`[list-editor] two editors are mounted under the same state-key "${e}". They would share one state controller — give each editor a unique state-key (e.g. suffix the row prefix with the list name).`), s.boundUid = o, s.live.value = i, s.handle;
+			let c = r.active ? r.run(() => n()) : n(), u = l(i), d = c.run(() => a(u));
+			return t.set(e, {
+				scope: c,
+				live: u,
+				handle: d,
+				children: null,
+				boundUid: o
+			}), d;
+		},
+		release(e, n, r) {
+			let i = t.get(e);
+			i && i.boundUid === n && (i.boundUid = null, i.live.value = r(i.live.value));
+		},
+		childScope(e) {
+			let n = t.get(e);
+			return n ? (n.children ||= n.scope.run(() => p()) ?? null, n.children) : null;
+		},
+		prefixFor(t) {
+			return `${e}:${String(t)}`;
+		},
+		retainOwners(n) {
+			if (t.size === 0) return;
+			let r = [];
+			for (let t of n) r.push(`${e}:${String(t)}`);
+			let i = `${e}:`;
+			for (let [e, n] of t) e.startsWith(i) && (r.some((t) => e === t || e.startsWith(`${t}:`)) || a(e, n));
+		},
+		has(e) {
+			return t.has(e);
+		},
+		size() {
+			return t.size;
+		},
+		dispose() {
+			for (let [e, n] of t) a(e, n);
+			t.clear(), r.stop();
+		}
+	};
+	return i() && s(() => o.dispose()), o;
+}
+function m(e) {
+	let t = e ?? p();
+	return c(d, t), t;
+}
+var h = (e) => {
+	let t = e.get();
+	return {
+		...e,
+		get: () => t,
+		set: () => void 0
+	};
+};
+function g(t, n) {
+	let i = a(d, null);
+	if (!t || !i) return null;
+	let s = r()?.uid ?? null, c = i.resolve(t, n, (t) => e({
+		get: () => t.value.get(),
+		set: (e) => t.value.set(e),
+		factory: (() => t.value.factory?.()),
+		getKey: t.value.getKey,
+		position: t.value.position,
+		dirtyExclude: () => u(t.value.dirtyExclude) ?? [],
+		validate: (e) => t.value.validate?.(e) ?? !0
+	}), s);
+	return r() && o(() => i.release(t, s, h)), {
+		handle: c,
+		childScope: i.childScope(t)
+	};
+}
+function _(e, n) {
+	let i = a(d, null);
+	if (!e || !i) return null;
+	let s = r()?.uid ?? null, c = i.resolve(e, n, (e) => t({
+		get: () => e.value.get(),
+		set: (t) => e.value.set(t),
+		factory: (() => e.value.factory?.()),
+		getKey: e.value.getKey,
+		position: e.value.position,
+		parentField: e.value.parentField,
+		maxDepth: e.value.maxDepth,
+		dirtyExclude: () => u(e.value.dirtyExclude) ?? [],
+		validate: (t) => e.value.validate?.(t) ?? !0
+	}), s);
+	return r() && o(() => i.release(e, s, h)), {
+		handle: c,
+		childScope: i.childScope(e)
+	};
+}
+//#endregion
+export { d as ListEditorStateScopeKey, p as createListEditorStateScope, m as provideListEditorStateScope, g as useListEditorStateEntry, _ as useNestedListEditorStateEntry };
+
+//# sourceMappingURL=useListEditorStateScope.js.map

package/dist/domains/listEditor/composables/useListEditorStateScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListEditorStateScope.js","names":["ListEditorStateScopeKey","scopeSeq","createListEditorStateScope","id","entries","root","effectScope","disposeEntry","entry","key","scope","existing","uid","bindings","entryScope","live","shallowRef","handle","create","park","rowKey","livePrefixes","liveRowKeys","ownPrefix","p","getCurrentScope","onScopeDispose","provideListEditorStateScope","inherited","provide","parkBindings","parked","useListEditorStateEntry","inject","stateKey","getCurrentInstance","useListEditorController","items","toValue","item","onBeforeUnmount","useNestedListEditorStateEntry","useNestedListEditorController","tree"],"sources":["../../../../src/domains/listEditor/composables/useListEditorStateScope.ts"],"sourcesContent":["import {\n  effectScope,\n  getCurrentInstance,\n  getCurrentScope,\n  inject,\n  onBeforeUnmount,\n  onScopeDispose,\n  provide,\n  shallowRef,\n  toValue,\n  type EffectScope,\n  type InjectionKey,\n  type ShallowRef,\n} from 'vue'\nimport type { ListEditorKey } from '@/domains/listEditor/types/listEditorTypes'\nimport {\n  useListEditorController,\n  type ListEditorHandle,\n  type UseListEditorControllerOptions,\n} from '@/domains/listEditor/composables/useListEditorController'\nimport {\n  useNestedListEditorController,\n  type NestedListEditorHandle,\n  type UseNestedListEditorControllerOptions,\n} from '@/domains/listEditor/composables/useNestedListEditorController'\n\n/**\n * The instance-bound controller options an editor re-supplies on EVERY (re)mount. `get`/`set` close\n * over the editor instance's `modelValue`/`emit`, and `factory`/`validate`/`dirtyExclude` over its\n * props — a remounted editor is a NEW instance, so a persisted controller must read all of them\n * through the live binding (see `useListEditorStateEntry`), never through the closures of the dead\n * instance that happened to create it.\n */\nexport type ListEditorStateBindings<TItem extends Record<string, any>> = Pick<\n  UseListEditorControllerOptions<TItem>,\n  'get' | 'set' | 'factory' | 'getKey' | 'position' | 'dirtyExclude' | 'validate'\n>\n\nexport type NestedListEditorStateBindings<TItem extends Record<string, any>> = Pick<\n  UseNestedListEditorControllerOptions<TItem>,\n  'get' | 'set' | 'factory' | 'getKey' | 'position' | 'parentField' | 'maxDepth' | 'dirtyExclude' | 'validate'\n>\n\n/** What a `state-key`'d editor gets back: its persisted handle + the scope to hand to ITS own rows. */\nexport interface ListEditorStateEntry<THandle> {\n  handle: THandle\n  /** Scope for this editor's `#item` slot subtree — persisted alongside the entry, so a\n   *  grand-nested `state-key`'d editor survives this editor's unmount too. */\n  childScope: ListEditorStateScope | null\n}\n\ninterface StateEntry {\n  scope: EffectScope\n  live: ShallowRef<any>\n  handle: unknown\n  children: ListEditorStateScope | null\n  /** uid of the editor instance currently bound to this entry (`null` = parked, no live editor). */\n  boundUid: number | null\n}\n\n/**\n * A keyed registry of list-editor state controllers, owned by an ANCESTOR (the editor that provides\n * it for its `#item` slot subtree) and living in that ancestor's `effectScope` — NOT in the scope of\n * the transient editor component that resolves it. That is the whole point: a nested editor's `#item`\n * slot is behind a `v-if`, so collapsing a row UNMOUNTS the nested editor; a component-owned\n * controller dies with it and a brand-new one re-baselines the already-edited data on re-expand,\n * losing amber / movedKeys / editedKeys / tombstones / the submitted (red-rail) flag.\n */\nexport interface ListEditorStateScope {\n  /** Unique per scope instance; namespaces the row prefixes this scope mints (and can prune). */\n  readonly id: string\n  /**\n   * First call for `key` CREATES the controller inside this scope (via `create`, from the calling\n   * editor's own bindings) and registers it. Every later call REBINDS the registered controller to\n   * the (new) calling instance's bindings and returns it — state intact.\n   */\n  resolve<TBindings extends object, THandle>(\n    key: string,\n    bindings: TBindings,\n    create: (live: ShallowRef<TBindings>) => THandle,\n    uid?: number | null\n  ): THandle\n  /**\n   * The editor bound to `key` is unmounting: park the entry — its model accessors are swapped for a\n   * frozen read + a no-op write so the orphaned controller can never read or write through the dead\n   * instance's `modelValue`/`emit`. No-op when another instance has already rebound (mount-before-\n   * unmount ordering), which is why the caller passes its uid.\n   */\n  release<TBindings extends object>(key: string, uid: number | null, park: (bindings: TBindings) => TBindings): void\n  /** Child scope of a registered entry (created lazily inside the entry's effect scope). */\n  childScope(key: string): ListEditorStateScope | null\n  /** The state-key prefix for a row — hosts thread it down and suffix it per nested list. */\n  prefixFor(rowKey: ListEditorKey): string\n  /** Dispose the entries of rows that no longer exist (keys minted from `prefixFor` only). */\n  retainOwners(liveRowKeys: Iterable<ListEditorKey>): void\n  has(key: string): boolean\n  size(): number\n  dispose(): void\n}\n\nexport const ListEditorStateScopeKey: InjectionKey<ListEditorStateScope> = Symbol(\n  'le.stateScope'\n) as InjectionKey<ListEditorStateScope>\n\nlet scopeSeq = 0\n\n/**\n * Create a scope. The internal `effectScope` is NOT detached: it attaches to whatever scope creates\n * it — the providing editor's component scope (so everything stops on its unmount) or a persisted\n * ENTRY's scope (so a nested editor's own row scope outlives the editor exactly as its controller\n * does).\n */\nexport function createListEditorStateScope(): ListEditorStateScope {\n  const id = `les${++scopeSeq}`\n  const entries = new Map<string, StateEntry>()\n  const root = effectScope()\n\n  const disposeEntry = (key: string, entry: StateEntry): void => {\n    entry.children?.dispose()\n    entry.scope.stop()\n    entries.delete(key)\n  }\n\n  const scope: ListEditorStateScope = {\n    id,\n    resolve<TBindings extends object, THandle>(\n      key: string,\n      bindings: TBindings,\n      create: (live: ShallowRef<TBindings>) => THandle,\n      uid: number | null = null\n    ): THandle {\n      const existing = entries.get(key)\n      if (existing) {\n        if (existing.boundUid !== null && uid !== null && existing.boundUid !== uid) {\n          console.warn(\n            `[list-editor] two editors are mounted under the same state-key \"${key}\". ` +\n              'They would share one state controller — give each editor a unique state-key ' +\n              '(e.g. suffix the row prefix with the list name).'\n          )\n        }\n        existing.boundUid = uid\n        // THE REBIND. `live` is a shallowRef, so this assignment invalidates every controller\n        // computed that read it (`items` first) — the persisted controller now reads and writes\n        // the LIVE editor instance's model instead of the dead one it was created from.\n        existing.live.value = bindings\n        return existing.handle as THandle\n      }\n      const entryScope = root.active ? (root.run(() => effectScope()) as EffectScope) : effectScope()\n      const live = shallowRef(bindings) as ShallowRef<TBindings>\n      const handle = entryScope.run(() => create(live)) as THandle\n      entries.set(key, { scope: entryScope, live, handle, children: null, boundUid: uid })\n      return handle\n    },\n    release<TBindings extends object>(key: string, uid: number | null, park: (bindings: TBindings) => TBindings): void {\n      const entry = entries.get(key)\n      if (!entry || entry.boundUid !== uid) return\n      entry.boundUid = null\n      entry.live.value = park(entry.live.value as TBindings)\n    },\n    childScope(key: string): ListEditorStateScope | null {\n      const entry = entries.get(key)\n      if (!entry) return null\n      if (!entry.children) {\n        entry.children = entry.scope.run(() => createListEditorStateScope()) ?? null\n      }\n      return entry.children\n    },\n    prefixFor(rowKey: ListEditorKey): string {\n      return `${id}:${String(rowKey)}`\n    },\n    retainOwners(liveRowKeys: Iterable<ListEditorKey>): void {\n      if (entries.size === 0) return\n      const livePrefixes: string[] = []\n      for (const rowKey of liveRowKeys) livePrefixes.push(`${id}:${String(rowKey)}`)\n      const ownPrefix = `${id}:`\n      for (const [key, entry] of entries) {\n        // Keys the host invented itself (not derived from `prefixFor`) carry no row ownership —\n        // they are only disposed with the scope.\n        if (!key.startsWith(ownPrefix)) continue\n        const alive = livePrefixes.some((p) => key === p || key.startsWith(`${p}:`))\n        if (!alive) disposeEntry(key, entry)\n      }\n    },\n    has(key: string): boolean {\n      return entries.has(key)\n    },\n    size(): number {\n      return entries.size\n    },\n    dispose(): void {\n      for (const [key, entry] of entries) disposeEntry(key, entry)\n      entries.clear()\n      root.stop()\n    },\n  }\n\n  if (getCurrentScope()) onScopeDispose(() => scope.dispose())\n\n  return scope\n}\n\n/**\n * Provide the row-state scope for an editor's `#item` slot subtree. A `state-key`'d editor passes\n * the `childScope` of its own persisted entry (so the chain survives at any depth); a plain editor\n * creates a component-owned scope that dies with it.\n */\nexport function provideListEditorStateScope(inherited: ListEditorStateScope | null): ListEditorStateScope {\n  const scope = inherited ?? createListEditorStateScope()\n  provide(ListEditorStateScopeKey, scope)\n  return scope\n}\n\nconst parkBindings = <TBindings extends { get: () => any; set: (value: any) => void }>(\n  bindings: TBindings\n): TBindings => {\n  const parked = bindings.get()\n  return { ...bindings, get: () => parked, set: () => undefined }\n}\n\n/**\n * Resolve this editor's controller from the nearest ancestor scope under `stateKey` (or `null` when\n * the editor has no `state-key`, or no ancestor provides a scope → today's component-owned\n * controller, unchanged).\n *\n * The controller is built from the FIRST mounting instance's own props, but every instance-bound\n * option is read through `live` — the shallowRef the scope swaps on each (re)mount. `getKey` and\n * `position` are static per tag, so the controller reads them once (it derives its key field at\n * construction); everything else is indirected.\n */\nexport function useListEditorStateEntry<TItem extends Record<string, any>>(\n  stateKey: string | undefined,\n  bindings: ListEditorStateBindings<TItem>\n): ListEditorStateEntry<ListEditorHandle<TItem>> | null {\n  const scope = inject(ListEditorStateScopeKey, null)\n  if (!stateKey || !scope) return null\n  const uid = getCurrentInstance()?.uid ?? null\n  const handle = scope.resolve<ListEditorStateBindings<TItem>, ListEditorHandle<TItem>>(\n    stateKey,\n    bindings,\n    (live) =>\n      useListEditorController<TItem>({\n        get: () => live.value.get(),\n        set: (items) => live.value.set(items),\n        // `factory?.()` → undefined reproduces the \"no factory\" no-op of `addItem` exactly.\n        factory: (() => live.value.factory?.()) as () => TItem,\n        getKey: live.value.getKey,\n        position: live.value.position,\n        dirtyExclude: () => toValue(live.value.dirtyExclude) ?? [],\n        // `?? true` reproduces the \"no validate\" always-valid branch.\n        validate: (item) => live.value.validate?.(item) ?? true,\n      }),\n    uid\n  )\n  if (getCurrentInstance()) {\n    onBeforeUnmount(() => scope.release<ListEditorStateBindings<TItem>>(stateKey, uid, parkBindings))\n  }\n  return { handle, childScope: scope.childScope(stateKey) }\n}\n\n/** Tree-shaped twin of `useListEditorStateEntry` for ANestedSortableListEditor. */\nexport function useNestedListEditorStateEntry<TItem extends Record<string, any>>(\n  stateKey: string | undefined,\n  bindings: NestedListEditorStateBindings<TItem>\n): ListEditorStateEntry<NestedListEditorHandle<TItem>> | null {\n  const scope = inject(ListEditorStateScopeKey, null)\n  if (!stateKey || !scope) return null\n  const uid = getCurrentInstance()?.uid ?? null\n  const handle = scope.resolve<NestedListEditorStateBindings<TItem>, NestedListEditorHandle<TItem>>(\n    stateKey,\n    bindings,\n    (live) =>\n      useNestedListEditorController<TItem>({\n        get: () => live.value.get(),\n        set: (tree) => live.value.set(tree),\n        factory: (() => live.value.factory?.()) as () => TItem,\n        getKey: live.value.getKey,\n        position: live.value.position,\n        parentField: live.value.parentField,\n        maxDepth: live.value.maxDepth,\n        dirtyExclude: () => toValue(live.value.dirtyExclude) ?? [],\n        validate: (item) => live.value.validate?.(item) ?? true,\n      }),\n    uid\n  )\n  if (getCurrentInstance()) {\n    onBeforeUnmount(() => scope.release<NestedListEditorStateBindings<TItem>>(stateKey, uid, parkBindings))\n  }\n  return { handle, childScope: scope.childScope(stateKey) }\n}\n"],"mappings":"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"}

package/dist/domains/listEditor/composables/useNestedListEditor.d.ts

@@ -0,0 +1,67 @@
+import { ComputedRef, Ref } from 'vue';
+import { ListEditorKey, ListViewItem, NestedTree, NestedTreeNode, PositionHint } from '../types/listEditorTypes';
+export interface NestedViewItem<TItem> extends ListViewItem<TItem> {
+    node: NestedTreeNode<TItem>;
+    depth: number;
+    parent: TItem | null;
+    parentKey: ListEditorKey | null;
+    childrenCount: number;
+    hasChildren: boolean;
+    childrenAllowed: boolean;
+    siblingIndex: number;
+    siblingCount: number;
+    firstInParent: boolean;
+    lastInParent: boolean;
+    canAddChild: boolean;
+    canIndent: boolean;
+    canOutdent: boolean;
+}
+export interface UseNestedListEditorOptions {
+    keyField?: string;
+    /**
+     * Resolve a row's key; takes precedence over `keyField`. Pass the controller's
+     * `keyOf` so tree ops key rows the same way as dirty/validity tracking — incl.
+     * a FUNCTION get-key, which `keyField` lookup would miss.
+     */
+    getKey?: (data: any) => ListEditorKey;
+    positionField?: string;
+    parentField?: string;
+    positionMultiplier?: number;
+    /** `false` = the position field is not managed: tree ops never write it. */
+    managedPosition?: boolean;
+    /** Per-action policy (mirrors the flat controller); default 'renumber'. */
+    positionStrategyFor?: (action: 'add' | 'remove' | 'move') => 'renumber' | 'preserve-values';
+    maxDepth: number;
+    expandedKeys?: Ref<Set<ListEditorKey>>;
+}
+export interface NestedListEditorApi<TItem extends Record<string, any>> {
+    viewItems: ComputedRef<NestedViewItem<TItem>[]>;
+    findNode: (id: ListEditorKey) => {
+        node: NestedTreeNode<TItem> | null;
+        parent: NestedTreeNode<TItem> | null;
+    };
+    addItem: (data: TItem, hint?: PositionHint & {
+        parentId?: ListEditorKey | null;
+        asFirstChild?: boolean;
+        childrenAllowed?: boolean;
+    }) => NestedTree<TItem>;
+    deleteItem: (id: ListEditorKey, opts?: {
+        renumber?: boolean;
+    }) => NestedTree<TItem>;
+    updateItem: (id: ListEditorKey, data: TItem, markDirty?: boolean) => NestedTree<TItem>;
+    moveUp: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveDown: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveTop: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveBottom: (id: ListEditorKey) => NestedTree<TItem> | null;
+    indent: (id: ListEditorKey) => NestedTree<TItem> | null;
+    outdent: (id: ListEditorKey) => NestedTree<TItem> | null;
+    moveTo: (id: ListEditorKey, targetParentId: ListEditorKey | null, targetIndex: number) => NestedTree<TItem> | null;
+    recalculatePositions: (model: NestedTree<TItem>) => NestedTree<TItem>;
+    calculateSubtreeDepth: (node: NestedTreeNode<TItem>) => number;
+}
+/**
+ * Nested list editor core. Pure data behavior shared by ANestedSortableListEditor.
+ * Works on a tree of `{ data, children, meta }` nodes. Mutators return a cloned tree and also
+ * assign it to `model.value`.
+ */
+export declare function useNestedListEditor<TItem extends Record<string, any>>(model: Ref<NestedTree<TItem>>, options: UseNestedListEditorOptions): NestedListEditorApi<TItem>;

package/dist/domains/listEditor/composables/useNestedListEditor.js

@@ -0,0 +1,212 @@
+import { cloneDeep as e, isUndefined as t } from "../../../shared/utils/common.js";
+import { computed as n } from "vue";
+//#region src/domains/listEditor/composables/useNestedListEditor.ts
+var r = "id", i = "position", a = "parent";
+function o(o, s) {
+	let c = s.keyField ?? r, l = s.getKey, u = s.positionField ?? i, d = s.parentField ?? a, f = s.positionMultiplier ?? 1, p = s.maxDepth, m = (e) => l ? l(e) : e[c], h = (e) => {
+		if (!e.children || e.children.length === 0) return 1;
+		let t = 0;
+		for (let n of e.children) {
+			let e = h(n);
+			e > t && (t = e);
+		}
+		return t + 1;
+	}, g = (e, t = o.value.children, n = null) => {
+		for (let r of t) {
+			if (m(r.data) === e) return {
+				node: r,
+				parent: n
+			};
+			if (r.children && r.children.length > 0) {
+				let t = g(e, r.children, r);
+				if (t.node) return t;
+			}
+		}
+		return {
+			node: null,
+			parent: null
+		};
+	}, _ = (e, t = "move") => {
+		if (s.managedPosition === !1) return;
+		if ((s.positionStrategyFor?.(t) ?? "renumber") === "preserve-values") {
+			if (t !== "move") return;
+			let n = e.map((e) => e.data[u]);
+			if (!n.every((e) => typeof e == "number" && Number.isFinite(e))) {
+				console.warn(`[listEditor] position strategy "preserve-values" needs a finite numeric \`${u}\` on every row; found ` + JSON.stringify(n) + " — leaving positions untouched.");
+				return;
+			}
+			let r = n.slice().sort((e, t) => e - t);
+			e.forEach((e, t) => {
+				e.data[u] !== r[t] && (e.data[u] = r[t], e.meta.dirty = !0);
+			});
+			return;
+		}
+		let n = 1 * f;
+		for (let t of e) t.data[u] !== n && (t.data[u] = n, t.meta.dirty = !0), n += f;
+	}, v = (e) => {
+		let t = (e) => {
+			_(e);
+			for (let n of e) n.children && n.children.length && t(n.children);
+		};
+		t(e.children);
+	}, y = (t) => {
+		let n = e(t);
+		return v(n), n;
+	}, b = (e) => {
+		let n = [], r = s.expandedKeys?.value, i = 0, a = (e, o, s) => {
+			for (let c = 0; c < e.length; c++) {
+				let l = e[c], d = m(l.data), f = !t(l.children), h = f && (l.children?.length ?? 0) > 0, g = l.children?.length ?? 0, _ = !r || r.has(d), v = p - (o + 1), y = f && v > 0, b = o > 0, x = c > 0;
+				n.push({
+					key: d,
+					index: i++,
+					raw: l.data,
+					position: l.data[u],
+					node: l,
+					depth: o,
+					parent: s?.data ?? null,
+					parentKey: s ? m(s.data) : null,
+					childrenCount: g,
+					hasChildren: h,
+					childrenAllowed: f,
+					siblingIndex: c,
+					siblingCount: e.length,
+					firstInParent: c === 0,
+					lastInParent: c === e.length - 1,
+					canAddChild: y,
+					canIndent: x,
+					canOutdent: b
+				}), h && _ && a(l.children, o + 1, l);
+			}
+		};
+		return a(e.children, 0, null), n;
+	}, x = n(() => b(o.value)), S = (e, t, n) => {
+		e.splice(t + 1, 0, n);
+	}, C = (e, t) => {
+		if (!t) return e.length;
+		if (t.afterId !== void 0) {
+			let n = e.findIndex((e) => m(e.data) === t.afterId);
+			return n === -1 ? e.length : n + 1;
+		}
+		return t.afterIndex === void 0 ? t.index === void 0 ? e.length : Math.max(0, Math.min(t.index, e.length)) : t.afterIndex < 0 ? e.length : Math.min(t.afterIndex + 1, e.length);
+	}, w = (t, n) => {
+		let r = e(o.value), i = n?.childrenAllowed ?? !0, a = {
+			data: e(t),
+			children: i ? [] : void 0,
+			meta: { dirty: !1 }
+		}, s = r.children, c = null;
+		if (n?.parentId !== void 0 && n.parentId !== null) {
+			let { node: e } = g(n.parentId, r.children);
+			e && e.children && (s = e.children, c = e);
+		}
+		if (n?.afterId !== void 0) {
+			let { node: e, parent: t } = g(n.afterId, r.children);
+			if (e) {
+				let n = t ? t.children : r.children, i = n.indexOf(e);
+				if (i !== -1) return S(n, i, a), a.data[d] = t ? m(t.data) : null, _(n, "add"), o.value = r, r;
+			}
+		}
+		let l = n?.asFirstChild ? 0 : C(s, n);
+		return s.splice(l, 0, a), a.data[d] = c ? m(c.data) : null, _(s, "add"), o.value = r, r;
+	}, T = (t, n) => {
+		let r = e(o.value), { node: i, parent: a } = g(t, r.children);
+		if (!i) return r;
+		let s = a ? a.children : r.children, c = s.indexOf(i);
+		return c === -1 || (s.splice(c, 1), n?.renumber !== !1 && _(s, "remove"), o.value = r), r;
+	}, E = (t, n, r = !0) => {
+		let i = e(o.value), { node: a } = g(t, i.children);
+		return a && (a.data = e(n), r && (a.meta.dirty = !0), o.value = i), i;
+	}, D = (e, t, n) => {
+		let { node: r, parent: i } = g(t, e.children);
+		if (!r) return null;
+		let a = i ? i.children : e.children, o = a.indexOf(r);
+		if (o === -1) return null;
+		let c = n(a, o);
+		if (c === null || c === o) return null;
+		let l = a.splice(o, 1)[0];
+		return a.splice(c, 0, l), s.managedPosition === !1 && (l.meta.dirty = !0), _(a), e;
+	}, O = (t) => {
+		let n = e(o.value), r = D(n, t, (e, t) => t > 0 ? t - 1 : null);
+		return r && (o.value = r), r;
+	}, k = (t) => {
+		let n = e(o.value), r = D(n, t, (e, t) => t < e.length - 1 ? t + 1 : null);
+		return r && (o.value = r), r;
+	}, A = (t) => {
+		let n = e(o.value), r = D(n, t, (e, t) => t > 0 ? 0 : null);
+		return r && (o.value = r), r;
+	}, j = (t) => {
+		let n = e(o.value), r = D(n, t, (e, t) => t < e.length - 1 ? e.length - 1 : null);
+		return r && (o.value = r), r;
+	}, M = (n) => {
+		let r = e(o.value), { node: i, parent: a } = g(n, r.children);
+		if (!i) return null;
+		let s = a ? a.children : r.children, c = s.indexOf(i);
+		if (c <= 0) return null;
+		let l = s[c - 1];
+		if (t(l.children)) return null;
+		let u = h(i);
+		return P(r, m(l.data)) + 1 + u > p ? null : (s.splice(c, 1), l.children.push(i), i.data[d] = m(l.data), i.meta.dirty = !0, _(s), _(l.children), o.value = r, r);
+	}, N = (t) => {
+		let n = e(o.value), { node: r, parent: i } = g(t, n.children);
+		if (!r || !i) return null;
+		let { parent: a } = g(m(i.data), n.children), s = a ? a.children : n.children, c = s.indexOf(i);
+		if (c === -1) return null;
+		let l = i.children, u = l.indexOf(r);
+		return u === -1 ? null : (l.splice(u, 1), s.splice(c + 1, 0, r), r.data[d] = a ? m(a.data) : null, r.meta.dirty = !0, _(l), _(s), o.value = n, n);
+	}, P = (e, t) => {
+		let n = (e, r) => {
+			for (let i of e) {
+				if (m(i.data) === t) return r;
+				if (i.children && i.children.length) {
+					let e = n(i.children, r + 1);
+					if (e !== null) return e;
+				}
+			}
+			return null;
+		};
+		return n(e.children, 0) ?? 0;
+	};
+	return {
+		viewItems: x,
+		findNode: g,
+		addItem: w,
+		deleteItem: T,
+		updateItem: E,
+		moveUp: O,
+		moveDown: k,
+		moveTop: A,
+		moveBottom: j,
+		indent: M,
+		outdent: N,
+		moveTo: (n, r, i) => {
+			let a = e(o.value), { node: s, parent: c } = g(n, a.children);
+			if (!s) return null;
+			if (r !== null) {
+				let e = (t) => {
+					if (!t.children) return !1;
+					for (let n of t.children) if (m(n.data) === r || e(n)) return !0;
+					return !1;
+				};
+				if (m(s.data) === r || e(s)) return null;
+			}
+			let l, u = null, f = 0;
+			if (r === null) l = a.children, f = 0;
+			else {
+				let { node: e } = g(r, a.children);
+				if (!e || t(e.children)) return null;
+				l = e.children, u = e, f = P(a, r) + 1;
+			}
+			let v = h(s);
+			if (f + v > p) return null;
+			let y = c ? c.children : a.children, b = y.indexOf(s);
+			if (b === -1) return null;
+			let x = y === l, S = y.splice(b, 1)[0], C = i;
+			return x && b < i && (C = i - 1), C = Math.max(0, Math.min(C, l.length)), l.splice(C, 0, S), S.data[d] = u ? m(u.data) : null, S.meta.dirty = !0, x || _(y), _(l), o.value = a, a;
+		},
+		recalculatePositions: y,
+		calculateSubtreeDepth: h
+	};
+}
+//#endregion
+export { o as useNestedListEditor };
+
+//# sourceMappingURL=useNestedListEditor.js.map

package/dist/domains/listEditor/composables/useNestedListEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNestedListEditor.js","names":["DEFAULT_KEY_FIELD","DEFAULT_POSITION_FIELD","DEFAULT_PARENT_FIELD","useNestedListEditor","keyField","options","resolveKey","positionField","parentField","positionMultiplier","maxDepth","getKey","data","calculateSubtreeDepth","node","max","child","d","findNode","model","item","arr","id","found","recalculateSiblings","action","values","siblings","s","v","slots","a","b","sibling","i","pos","recalculateAll","walk","tree","recalculatePositions","cloned","cloneDeep","buildViewItems","flat","expandedKeys","flatIndex","nodes","key","childrenAllowed","isUndefined","hasChildren","childrenCount","isExpanded","remainingDepth","depth","canAddChild","canOutdent","canIndent","parentNode","viewItems","computed","insertAfter","afterIdx","newNode","resolveInsertIndex","hint","idx","addItem","targetSiblings","afterNode","afterParent","insertIdx","deleteItem","parent","opts","updateItem","markDirty","swapSiblings","target","getTargetIndex","removed","moveUp","res","moveDown","moveTop","moveBottom","indent","prev","subtreeDepth","calculateParentDepth","outdent","grandParent","grandSiblings","parentIdx","currentSiblings","targetParentId","isDescendant","n","c","newParentNode","newParentDepth","targetParent","sourceSiblings","sourceIdx","samelist","insertAt","targetIndex"],"sources":["../../../../src/domains/listEditor/composables/useNestedListEditor.ts"],"sourcesContent":["import { computed, type ComputedRef, type Ref } from 'vue'\nimport { cloneDeep, isUndefined } from '@/shared/utils/common'\nimport type {\n  ListEditorKey,\n  ListViewItem,\n  NestedTree,\n  NestedTreeNode,\n  PositionHint,\n} from '@/domains/listEditor/types/listEditorTypes'\n\nexport interface NestedViewItem<TItem> extends ListViewItem<TItem> {\n  node: NestedTreeNode<TItem>\n  depth: number\n  parent: TItem | null\n  parentKey: ListEditorKey | null\n  childrenCount: number\n  hasChildren: boolean\n  childrenAllowed: boolean\n  siblingIndex: number\n  siblingCount: number\n  firstInParent: boolean\n  lastInParent: boolean\n  canAddChild: boolean\n  canIndent: boolean\n  canOutdent: boolean\n}\n\nexport interface UseNestedListEditorOptions {\n  keyField?: string\n  /**\n   * Resolve a row's key; takes precedence over `keyField`. Pass the controller's\n   * `keyOf` so tree ops key rows the same way as dirty/validity tracking — incl.\n   * a FUNCTION get-key, which `keyField` lookup would miss.\n   */\n  getKey?: (data: any) => ListEditorKey\n  positionField?: string\n  parentField?: string\n  positionMultiplier?: number\n  /** `false` = the position field is not managed: tree ops never write it. */\n  managedPosition?: boolean\n  /** Per-action policy (mirrors the flat controller); default 'renumber'. */\n  positionStrategyFor?: (action: 'add' | 'remove' | 'move') => 'renumber' | 'preserve-values'\n  maxDepth: number\n  expandedKeys?: Ref<Set<ListEditorKey>>\n}\n\nexport interface NestedListEditorApi<TItem extends Record<string, any>> {\n  viewItems: ComputedRef<NestedViewItem<TItem>[]>\n  findNode: (id: ListEditorKey) => {\n    node: NestedTreeNode<TItem> | null\n    parent: NestedTreeNode<TItem> | null\n  }\n  addItem: (\n    data: TItem,\n    hint?: PositionHint & {\n      parentId?: ListEditorKey | null\n      asFirstChild?: boolean\n      childrenAllowed?: boolean\n    }\n  ) => NestedTree<TItem>\n  deleteItem: (id: ListEditorKey, opts?: { renumber?: boolean }) => NestedTree<TItem>\n  updateItem: (id: ListEditorKey, data: TItem, markDirty?: boolean) => NestedTree<TItem>\n  moveUp: (id: ListEditorKey) => NestedTree<TItem> | null\n  moveDown: (id: ListEditorKey) => NestedTree<TItem> | null\n  moveTop: (id: ListEditorKey) => NestedTree<TItem> | null\n  moveBottom: (id: ListEditorKey) => NestedTree<TItem> | null\n  indent: (id: ListEditorKey) => NestedTree<TItem> | null\n  outdent: (id: ListEditorKey) => NestedTree<TItem> | null\n  moveTo: (id: ListEditorKey, targetParentId: ListEditorKey | null, targetIndex: number) => NestedTree<TItem> | null\n  recalculatePositions: (model: NestedTree<TItem>) => NestedTree<TItem>\n  calculateSubtreeDepth: (node: NestedTreeNode<TItem>) => number\n}\n\nconst DEFAULT_KEY_FIELD = 'id'\nconst DEFAULT_POSITION_FIELD = 'position'\nconst DEFAULT_PARENT_FIELD = 'parent'\n\n/**\n * Nested list editor core. Pure data behavior shared by ANestedSortableListEditor.\n * Works on a tree of `{ data, children, meta }` nodes. Mutators return a cloned tree and also\n * assign it to `model.value`.\n */\nexport function useNestedListEditor<TItem extends Record<string, any>>(\n  model: Ref<NestedTree<TItem>>,\n  options: UseNestedListEditorOptions\n): NestedListEditorApi<TItem> {\n  const keyField = options.keyField ?? DEFAULT_KEY_FIELD\n  const resolveKey = options.getKey\n  const positionField = options.positionField ?? DEFAULT_POSITION_FIELD\n  const parentField = options.parentField ?? DEFAULT_PARENT_FIELD\n  const positionMultiplier = options.positionMultiplier ?? 1\n  const maxDepth = options.maxDepth\n\n  const getKey = (data: TItem): ListEditorKey => (resolveKey ? resolveKey(data) : (data[keyField] as ListEditorKey))\n\n  const calculateSubtreeDepth = (node: NestedTreeNode<TItem>): number => {\n    if (!node.children || node.children.length === 0) return 1\n    let max = 0\n    for (const child of node.children) {\n      const d = calculateSubtreeDepth(child)\n      if (d > max) max = d\n    }\n    return max + 1\n  }\n\n  const findNode = (\n    id: ListEditorKey,\n    arr: NestedTreeNode<TItem>[] = model.value.children,\n    parent: NestedTreeNode<TItem> | null = null\n  ): { node: NestedTreeNode<TItem> | null; parent: NestedTreeNode<TItem> | null } => {\n    for (const item of arr) {\n      if (getKey(item.data) === id) return { node: item, parent }\n      if (item.children && item.children.length > 0) {\n        const found = findNode(id, item.children, item)\n        if (found.node) return found\n      }\n    }\n    return { node: null, parent: null }\n  }\n\n  const recalculateSiblings = (siblings: NestedTreeNode<TItem>[], action: 'add' | 'remove' | 'move' = 'move') => {\n    if (options.managedPosition === false) return\n    const strategy = options.positionStrategyFor?.(action) ?? 'renumber'\n    if (strategy === 'preserve-values') {\n      if (action !== 'move') return\n      const values = siblings.map((s) => s.data[positionField])\n      // As in the flat editor: without a finite number on every row there is no slot set to move\n      // through, and inventing one would write a wrong payload.\n      if (!values.every((v) => typeof v === 'number' && Number.isFinite(v))) {\n        console.warn(\n          `[listEditor] position strategy \"preserve-values\" needs a finite numeric \\`${positionField}\\` ` +\n            'on every row; found ' +\n            JSON.stringify(values) +\n            ' — leaving positions untouched.'\n        )\n        return\n      }\n      const slots = (values as number[]).slice().sort((a, b) => a - b)\n      siblings.forEach((sibling, i) => {\n        if (sibling.data[positionField] !== slots[i]) {\n          ;(sibling.data as any)[positionField] = slots[i]\n          sibling.meta.dirty = true\n        }\n      })\n      return\n    }\n    let pos = 1 * positionMultiplier\n    for (const sibling of siblings) {\n      if (sibling.data[positionField] !== pos) {\n        ;(sibling.data as any)[positionField] = pos\n        // Flag dirty so a partial-subset save persists the new position;\n        // otherwise reorders are lost on reload and rows collide on old positions.\n        sibling.meta.dirty = true\n      }\n      pos += positionMultiplier\n    }\n  }\n\n  const recalculateAll = (tree: NestedTree<TItem>) => {\n    const walk = (arr: NestedTreeNode<TItem>[]) => {\n      recalculateSiblings(arr)\n      for (const item of arr) if (item.children && item.children.length) walk(item.children)\n    }\n    walk(tree.children)\n  }\n\n  const recalculatePositions = (tree: NestedTree<TItem>): NestedTree<TItem> => {\n    const cloned = cloneDeep(tree) as NestedTree<TItem>\n    recalculateAll(cloned)\n    return cloned\n  }\n\n  const buildViewItems = (tree: NestedTree<TItem>): NestedViewItem<TItem>[] => {\n    const flat: NestedViewItem<TItem>[] = []\n    const expandedKeys = options.expandedKeys?.value\n    let flatIndex = 0\n    const walk = (nodes: NestedTreeNode<TItem>[], depth: number, parentNode: NestedTreeNode<TItem> | null) => {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i]!\n        const key = getKey(node.data)\n        const childrenAllowed = !isUndefined(node.children)\n        const hasChildren = childrenAllowed && (node.children?.length ?? 0) > 0\n        const childrenCount = node.children?.length ?? 0\n        const isExpanded = expandedKeys ? expandedKeys.has(key) : true\n        const remainingDepth = maxDepth - (depth + 1)\n        const canAddChild = childrenAllowed && remainingDepth > 0\n        const canOutdent = depth > 0\n        const canIndent = i > 0\n        flat.push({\n          key,\n          index: flatIndex++,\n          raw: node.data,\n          position: node.data[positionField] as number | undefined,\n          node,\n          depth,\n          parent: parentNode?.data ?? null,\n          parentKey: parentNode ? getKey(parentNode.data) : null,\n          childrenCount,\n          hasChildren,\n          childrenAllowed,\n          siblingIndex: i,\n          siblingCount: nodes.length,\n          firstInParent: i === 0,\n          lastInParent: i === nodes.length - 1,\n          canAddChild,\n          canIndent,\n          canOutdent,\n        })\n        if (hasChildren && isExpanded) {\n          walk(node.children as NestedTreeNode<TItem>[], depth + 1, node)\n        }\n      }\n    }\n    walk(tree.children, 0, null)\n    return flat\n  }\n\n  const viewItems = computed<NestedViewItem<TItem>[]>(() => buildViewItems(model.value))\n\n  const insertAfter = (siblings: NestedTreeNode<TItem>[], afterIdx: number, newNode: NestedTreeNode<TItem>) => {\n    siblings.splice(afterIdx + 1, 0, newNode)\n  }\n\n  const resolveInsertIndex = (siblings: NestedTreeNode<TItem>[], hint?: PositionHint): number => {\n    if (!hint) return siblings.length\n    if (hint.afterId !== undefined) {\n      const idx = siblings.findIndex((s) => getKey(s.data) === hint.afterId)\n      return idx === -1 ? siblings.length : idx + 1\n    }\n    if (hint.afterIndex !== undefined) {\n      if (hint.afterIndex < 0) return siblings.length\n      return Math.min(hint.afterIndex + 1, siblings.length)\n    }\n    if (hint.index !== undefined) {\n      return Math.max(0, Math.min(hint.index, siblings.length))\n    }\n    return siblings.length\n  }\n\n  const addItem = (\n    data: TItem,\n    hint?: PositionHint & {\n      parentId?: ListEditorKey | null\n      asFirstChild?: boolean\n      childrenAllowed?: boolean\n    }\n  ): NestedTree<TItem> => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const childrenAllowed = hint?.childrenAllowed ?? true\n    const newNode: NestedTreeNode<TItem> = {\n      data: cloneDeep(data) as TItem,\n      children: childrenAllowed ? [] : undefined,\n      meta: { dirty: false },\n    }\n\n    let targetSiblings: NestedTreeNode<TItem>[] = cloned.children\n    let parentNode: NestedTreeNode<TItem> | null = null\n\n    if (hint?.parentId !== undefined && hint.parentId !== null) {\n      const { node } = findNode(hint.parentId, cloned.children)\n      if (node && node.children) {\n        targetSiblings = node.children\n        parentNode = node\n      }\n    }\n\n    if (hint?.afterId !== undefined) {\n      const { node: afterNode, parent: afterParent } = findNode(hint.afterId, cloned.children)\n      if (afterNode) {\n        const siblings = afterParent ? (afterParent.children as NestedTreeNode<TItem>[]) : cloned.children\n        const idx = siblings.indexOf(afterNode)\n        if (idx !== -1) {\n          insertAfter(siblings, idx, newNode)\n          ;(newNode.data as any)[parentField] = afterParent ? getKey(afterParent.data) : null\n          recalculateSiblings(siblings, 'add')\n          model.value = cloned\n          return cloned\n        }\n      }\n    }\n\n    const insertIdx = hint?.asFirstChild ? 0 : resolveInsertIndex(targetSiblings, hint)\n    targetSiblings.splice(insertIdx, 0, newNode)\n    ;(newNode.data as any)[parentField] = parentNode ? getKey(parentNode.data) : null\n    recalculateSiblings(targetSiblings, 'add')\n    model.value = cloned\n    return cloned\n  }\n\n  // `renumber: false` leaves the siblings' positions as they are: a row already deleted on the backend,\n  // which does not renumber either, so the gap the server has stays in the editor too.\n  const deleteItem = (id: ListEditorKey, opts?: { renumber?: boolean }): NestedTree<TItem> => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const { node, parent } = findNode(id, cloned.children)\n    if (!node) return cloned\n    const siblings = parent ? (parent.children as NestedTreeNode<TItem>[]) : cloned.children\n    const idx = siblings.indexOf(node)\n    if (idx === -1) return cloned\n    siblings.splice(idx, 1)\n    if (opts?.renumber !== false) recalculateSiblings(siblings, 'remove')\n    model.value = cloned\n    return cloned\n  }\n\n  const updateItem = (id: ListEditorKey, data: TItem, markDirty = true): NestedTree<TItem> => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const { node } = findNode(id, cloned.children)\n    if (!node) return cloned\n    node.data = cloneDeep(data) as TItem\n    // An edit must be persisted by partial-subset saves. `markDirty=false` is for\n    // snapshot restore on edit-cancel, which must NOT flag the node dirty.\n    if (markDirty) node.meta.dirty = true\n    model.value = cloned\n    return cloned\n  }\n\n  const swapSiblings = (\n    cloned: NestedTree<TItem>,\n    id: ListEditorKey,\n    getTargetIndex: (siblings: NestedTreeNode<TItem>[], currentIdx: number) => number | null\n  ): NestedTree<TItem> | null => {\n    const { node, parent } = findNode(id, cloned.children)\n    if (!node) return null\n    const siblings = parent ? (parent.children as NestedTreeNode<TItem>[]) : cloned.children\n    const idx = siblings.indexOf(node)\n    if (idx === -1) return null\n    const target = getTargetIndex(siblings, idx)\n    if (target === null || target === idx) return null\n    const removed = siblings.splice(idx, 1)[0]!\n    siblings.splice(target, 0, removed)\n    if (options.managedPosition === false) removed.meta.dirty = true\n    recalculateSiblings(siblings)\n    return cloned\n  }\n\n  const moveUp = (id: ListEditorKey): NestedTree<TItem> | null => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const res = swapSiblings(cloned, id, (_s, idx) => (idx > 0 ? idx - 1 : null))\n    if (res) model.value = res\n    return res\n  }\n\n  const moveDown = (id: ListEditorKey): NestedTree<TItem> | null => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const res = swapSiblings(cloned, id, (s, idx) => (idx < s.length - 1 ? idx + 1 : null))\n    if (res) model.value = res\n    return res\n  }\n\n  const moveTop = (id: ListEditorKey): NestedTree<TItem> | null => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const res = swapSiblings(cloned, id, (_s, idx) => (idx > 0 ? 0 : null))\n    if (res) model.value = res\n    return res\n  }\n\n  const moveBottom = (id: ListEditorKey): NestedTree<TItem> | null => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const res = swapSiblings(cloned, id, (s, idx) => (idx < s.length - 1 ? s.length - 1 : null))\n    if (res) model.value = res\n    return res\n  }\n\n  /**\n   * Indent: move the item under its previous sibling as its last child.\n   * Fails if: no previous sibling, previous sibling doesn't allow children,\n   * or the resulting depth would exceed maxDepth.\n   */\n  const indent = (id: ListEditorKey): NestedTree<TItem> | null => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const { node, parent } = findNode(id, cloned.children)\n    if (!node) return null\n    const siblings = parent ? (parent.children as NestedTreeNode<TItem>[]) : cloned.children\n    const idx = siblings.indexOf(node)\n    if (idx <= 0) return null\n    const prev = siblings[idx - 1]!\n    if (isUndefined(prev.children)) return null\n    const subtreeDepth = calculateSubtreeDepth(node)\n    const prevDepth = calculateParentDepth(cloned, getKey(prev.data))\n    if (prevDepth + 1 + subtreeDepth > maxDepth) return null\n\n    siblings.splice(idx, 1)\n    prev.children!.push(node)\n    ;(node.data as any)[parentField] = getKey(prev.data)\n    // Persist the reparent even when the position number is unchanged (QA 85050 BUG-13).\n    node.meta.dirty = true\n    recalculateSiblings(siblings)\n    recalculateSiblings(prev.children!)\n    model.value = cloned\n    return cloned\n  }\n\n  /**\n   * Outdent: move the item up one level — it becomes the next sibling of its current parent.\n   * Fails if the item is already at root.\n   */\n  const outdent = (id: ListEditorKey): NestedTree<TItem> | null => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const { node, parent } = findNode(id, cloned.children)\n    if (!node || !parent) return null\n\n    const { parent: grandParent } = findNode(getKey(parent.data), cloned.children)\n    const grandSiblings = grandParent ? (grandParent.children as NestedTreeNode<TItem>[]) : cloned.children\n    const parentIdx = grandSiblings.indexOf(parent)\n    if (parentIdx === -1) return null\n\n    const currentSiblings = parent.children as NestedTreeNode<TItem>[]\n    const idx = currentSiblings.indexOf(node)\n    if (idx === -1) return null\n    currentSiblings.splice(idx, 1)\n    grandSiblings.splice(parentIdx + 1, 0, node)\n    ;(node.data as any)[parentField] = grandParent ? getKey(grandParent.data) : null\n    // Persist the reparent even when the position number is unchanged (QA 85050 BUG-13).\n    node.meta.dirty = true\n\n    recalculateSiblings(currentSiblings)\n    recalculateSiblings(grandSiblings)\n    model.value = cloned\n    return cloned\n  }\n\n  const calculateParentDepth = (tree: NestedTree<TItem>, id: ListEditorKey): number => {\n    const walk = (arr: NestedTreeNode<TItem>[], depth: number): number | null => {\n      for (const item of arr) {\n        if (getKey(item.data) === id) return depth\n        if (item.children && item.children.length) {\n          const d = walk(item.children, depth + 1)\n          if (d !== null) return d\n        }\n      }\n      return null\n    }\n    return walk(tree.children, 0) ?? 0\n  }\n\n  /**\n   * Move a node to a specific parent at a specific index. Used by drag/drop.\n   * Respects maxDepth — returns null if the move would exceed it.\n   */\n  const moveTo = (\n    id: ListEditorKey,\n    targetParentId: ListEditorKey | null,\n    targetIndex: number\n  ): NestedTree<TItem> | null => {\n    const cloned = cloneDeep(model.value) as NestedTree<TItem>\n    const { node, parent } = findNode(id, cloned.children)\n    if (!node) return null\n\n    if (targetParentId !== null) {\n      const isDescendant = (n: NestedTreeNode<TItem>): boolean => {\n        if (!n.children) return false\n        for (const c of n.children) {\n          if (getKey(c.data) === targetParentId) return true\n          if (isDescendant(c)) return true\n        }\n        return false\n      }\n      if (getKey(node.data) === targetParentId || isDescendant(node)) return null\n    }\n\n    let targetSiblings: NestedTreeNode<TItem>[]\n    let newParentNode: NestedTreeNode<TItem> | null = null\n    let newParentDepth = 0\n    if (targetParentId === null) {\n      targetSiblings = cloned.children\n      newParentDepth = 0\n    } else {\n      const { node: targetParent } = findNode(targetParentId, cloned.children)\n      if (!targetParent || isUndefined(targetParent.children)) return null\n      targetSiblings = targetParent.children\n      newParentNode = targetParent\n      newParentDepth = calculateParentDepth(cloned, targetParentId) + 1\n    }\n\n    const subtreeDepth = calculateSubtreeDepth(node)\n    if (newParentDepth + subtreeDepth > maxDepth) return null\n\n    const sourceSiblings = parent ? (parent.children as NestedTreeNode<TItem>[]) : cloned.children\n    const sourceIdx = sourceSiblings.indexOf(node)\n    if (sourceIdx === -1) return null\n\n    const samelist = sourceSiblings === targetSiblings\n    const removed = sourceSiblings.splice(sourceIdx, 1)[0]!\n    let insertAt = targetIndex\n    if (samelist && sourceIdx < targetIndex) insertAt = targetIndex - 1\n    insertAt = Math.max(0, Math.min(insertAt, targetSiblings.length))\n    targetSiblings.splice(insertAt, 0, removed)\n    ;(removed.data as any)[parentField] = newParentNode ? getKey(newParentNode.data) : null\n    // Flag explicitly: a reparent at an unchanged position number (root pos 2 →\n    // a group's 2nd child, also pos 2) isn't caught by recalculateSiblings, so the\n    // partial save would omit it and the child reverts to root on reload (BUG-13).\n    removed.meta.dirty = true\n\n    if (!samelist) recalculateSiblings(sourceSiblings)\n    recalculateSiblings(targetSiblings)\n    model.value = cloned\n    return cloned\n  }\n\n  return {\n    viewItems,\n    findNode,\n    addItem,\n    deleteItem,\n    updateItem,\n    moveUp,\n    moveDown,\n    moveTop,\n    moveBottom,\n    indent,\n    outdent,\n    moveTo,\n    recalculatePositions,\n    calculateSubtreeDepth,\n  }\n}\n"],"mappings":"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"}

package/dist/domains/listEditor/composables/useNestedListEditorController.d.ts

@@ -0,0 +1,136 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowUnwrapRef } from 'vue';
+import { ListEditorKey, ListEditorValidationState, NestedPositionHint, NestedTree, NestedTreeNode } from '../types/listEditorTypes';
+import { NestedViewItem } from './useNestedListEditor';
+import { GetKey, ListEditorValidationResult, PositionOption, PositionStrategy } from './useListEditorController';
+export type { ListEditorValidationResult, GetKey, PositionOption, PositionStrategy };
+/** Flattened ordered row carrying its resolved key (for change-sets + payload). */
+export interface NestedListEditorChanges<TItem> {
+    added: TItem[];
+    updated: TItem[];
+    moved: TItem[];
+    deleted: TItem[];
+    /**
+     * Rows whose parent changed since the last commit (BUG-13 — persisted even
+     * when the position number is unchanged).
+     */
+    reparented: TItem[];
+}
+export interface UseNestedListEditorControllerOptions<TItem extends Record<string, any>> {
+    /** Read the live tree (the editor's v-model, or a consumer store getter). */
+    get: () => NestedTree<TItem>;
+    /** Write the tree back. */
+    set: (tree: NestedTree<TItem>) => void;
+    /** New-row factory. Optional for read-only / no-add trees. Should mint a stable temp id. */
+    factory?: () => TItem;
+    /** Stable row identity. Default `'id'`. Never point this at the position field. */
+    getKey?: GetKey<TItem>;
+    /** Managed order field. Default `'position'`. `false` opts out of position management. */
+    position?: PositionOption<TItem>;
+    /** Parent-key field written onto reparented rows. Default `'parent'`. */
+    parentField?: string;
+    /** Maximum nesting depth (1-based). Enforced by indent/outdent/moveTo. */
+    maxDepth: number;
+    /**
+     * Extra top-level fields to drop from the dirty content-hash (position +
+     * parent are always dropped). Same purpose as the flat controller — a child
+     * collection tracked by a separate editor shouldn't flip its owner amber.
+     * Accepts a getter/ref so a `computed` set is honoured reactively.
+     */
+    dirtyExclude?: MaybeRefOrGetter<string[]>;
+    /** Per-row validity — `true` = valid. Drives the red rail + `hasErrors`. */
+    validate?: (item: TItem) => ListEditorValidationResult;
+    /** Custom dirty predicate (override the default `meta.dirty ∪ content-diff`). */
+    isDirty?: (current: TItem, saved: TItem | undefined) => boolean;
+    /** Custom save payload (overrides `getPayload`). Receives the flattened ordered rows. */
+    payload?: (items: TItem[]) => TItem[];
+    /** Resolve a saved row's key on commit (default: existing key, else mint a temp id). */
+    commitKey?: (saved: TItem, previous: TItem | undefined) => ListEditorKey;
+    /** Normalize the server tree before it becomes the new baseline on commit. */
+    normalizeSaved?: (saved: NestedTree<TItem>) => NestedTree<TItem>;
+}
+/**
+ * Tree-shaped state controller for the nested list editor (v2). A superset of
+ * the flat `ListEditorHandle`: same dirty/validate/commit/reset semantics, but
+ * the row set is a flattened ordered projection of a `NestedTree` and the
+ * mutators are tree ops (indent / outdent / moveTo / addChild …) delegated to
+ * `useNestedListEditor`. Each flattened payload row carries its resolved
+ * `position` and parent key written onto it.
+ */
+export interface NestedListEditorHandle<TItem extends Record<string, any>> {
+    /** Flattened ordered rows (depth-first), matching the rendered order. */
+    items: ComputedRef<TItem[]>;
+    /** Tree view rows (key/index/raw/depth/parent…), as consumed by the renderer. */
+    viewItems: ComputedRef<NestedViewItem<TItem>[]>;
+    hasUnsaved: ComputedRef<boolean>;
+    /** Count of distinct unconfirmed changes (added/edited/moved/reparented rows + deferred deletions). */
+    unsavedCount: ComputedRef<number>;
+    hasErrors: ComputedRef<boolean>;
+    invalidKeys: ComputedRef<Set<ListEditorKey>>;
+    /** Amber: is this row added / edited / moved / reparented since the last commit? */
+    isUnsaved: (key: ListEditorKey) => boolean;
+    /** Red rail (gated): 'invalid' only once the row is unsaved or `validateAll()` ran. */
+    rowState: (item: TItem, key: ListEditorKey, editing?: boolean) => ListEditorValidationState;
+    /** Force-show all invalid rows + return whether the tree is valid. The save guard. */
+    validateAll: () => boolean;
+    /** Flattened ordered array (each row carrying its resolved position + parent key) for a full-DTO save. */
+    getPayload: () => TItem[];
+    /** Change-set for partial-save endpoints (added/updated/moved/deleted/reparented), keyed. */
+    getChanges: () => NestedListEditorChanges<TItem>;
+    /** Adopt the saved tree as the new baseline; backfill keys; clear dirty/submitted. */
+    commit: (saved?: NestedTree<TItem>) => void;
+    /** Adopt only these rows as saved (a server-confirmed single-row op); other pending work stays. */
+    acceptRows: (keys: ListEditorKey[]) => void;
+    /** Discard unsaved edits back to the last committed baseline (or a given tree). */
+    reset: (tree?: NestedTree<TItem>) => void;
+    addItem: (item?: TItem, hint?: NestedPositionHint) => void;
+    addAfter: (afterKey: ListEditorKey, item?: TItem, childrenAllowed?: boolean) => void;
+    addChild: (parentKey: ListEditorKey, item?: TItem, childrenAllowed?: boolean) => void;
+    updateItem: (key: ListEditorKey, data: TItem, markDirty?: boolean) => void;
+    deleteItem: (key: ListEditorKey, opts?: {
+        trackDeleted?: boolean;
+        renumber?: boolean;
+    }) => void;
+    restoreDeleted: (key: ListEditorKey) => void;
+    moveUp: (key: ListEditorKey) => boolean;
+    moveDown: (key: ListEditorKey) => boolean;
+    moveTop: (key: ListEditorKey) => boolean;
+    moveBottom: (key: ListEditorKey) => boolean;
+    indent: (key: ListEditorKey) => boolean;
+    outdent: (key: ListEditorKey) => boolean;
+    moveTo: (key: ListEditorKey, targetParentKey: ListEditorKey | null, targetIndex: number) => boolean;
+    recalculatePositions: () => void;
+    /** Escape hatch: a row form (e.g. vuelidate) reports its own validity instead of `validate`. */
+    registerValidity: (key: ListEditorKey, isValid: () => boolean) => () => void;
+    findNode: (key: ListEditorKey) => {
+        node: NestedTreeNode<TItem> | null;
+        parent: NestedTreeNode<TItem> | null;
+    };
+    calculateSubtreeDepth: (node: NestedTreeNode<TItem>) => number;
+}
+/**
+ * Consumer-facing shape of a nested-list-editor handle read through a template/function ref — Vue's
+ * `expose` proxy unwraps the exposed refs, so read `handle.hasUnsaved` (a boolean), not
+ * `handle.hasUnsaved.value`. See {@link ExposedListEditorHandle}.
+ */
+export type ExposedNestedListEditorHandle<TItem extends Record<string, any>> = ShallowUnwrapRef<NestedListEditorHandle<TItem>>;
+/** What `ANestedSortableListEditor` exposes on top of the controller handle. */
+export interface NestedSortableListEditorExtras {
+    /**
+     * Runs a tree mutation the server has already made (a row created through a dialog) and adopts as
+     * saved only the rows it added or edited, plus `keys`. Siblings it only renumbered and other pending
+     * work stay unsaved (the server may not have renumbered them), and so does the position of a created
+     * row the op renumbered. `commit()` would adopt the whole tree instead.
+     */
+    acceptChanges: (op: () => void, keys?: ListEditorKey[]) => void;
+    enterReorderMode: () => void;
+    cancelReorderMode: () => void;
+    applyReorder: () => Promise<void>;
+    expand: (id: ListEditorKey) => void;
+    collapse: (id: ListEditorKey) => void;
+    toggleExpand: (id: ListEditorKey) => void;
+    expandDetail: (id: ListEditorKey) => void;
+    collapseDetail: (id: ListEditorKey) => void;
+}
+/** `ANestedSortableListEditor` read through a template ref: the unwrapped handle and its extras. */
+export type ExposedNestedSortableListEditorHandle<TItem extends Record<string, any>> = ExposedNestedListEditorHandle<TItem> & NestedSortableListEditorExtras;
+export declare function useNestedListEditorController<TItem extends Record<string, any>>(options: UseNestedListEditorControllerOptions<TItem>): NestedListEditorHandle<TItem>;