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

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

@@ -1 +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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"}
+{"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, as in 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 for `ANestedSortableListEditor`. Works on a tree of `{ data, children, meta }` nodes.\n * Mutators return a cloned tree and also 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      // Same as the flat editor: without a finite number on every row there is no slot set to move through.\n      // 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` keeps sibling positions. The row is already\n  // deleted on the backend, which does not renumber either.\n  // So the editor keeps the same gap the server has.\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

@@ -116,10 +116,11 @@ export type ExposedNestedListEditorHandle<TItem extends Record<string, any>> = S
 /** 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.
+     * Runs a tree mutation the server already made (e.g. a row created through a dialog).
+     * Adopts as saved only the rows it added or edited, plus `keys`.
+     * Siblings it only renumbered, other pending work and a renumbered position of
+     * a created row stay unsaved, because the server may not have renumbered them.
+     * `commit()` would adopt the whole tree instead.
      */
     acceptChanges: (op: () => void, keys?: ListEditorKey[]) => void;
     enterReorderMode: () => void;

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

@@ -1,8 +1,8 @@
-import { cloneDeep as e } from "../../../shared/utils/common.js";
+import { useNestedListEditor as e } from "./useNestedListEditor.js";
 import { nextListEditorTempId as t } from "../utils/tempId.js";
-import { useNestedListEditor as n } from "./useNestedListEditor.js";
+import { cloneDeep as n } from "../../../shared/utils/common.js";
 import { computed as r, reactive as i, ref as a, toValue as o, watch as s } from "vue";
-//#region src/domains/listEditor/composables/useNestedListEditorController.ts
+// src/domains/listEditor/composables/useNestedListEditorController.ts
 var c = (e) => {
 	let t = [], n = (e) => {
 		for (let r of e) t.push(r.data), r.children && r.children.length && n(r.children);
@@ -18,7 +18,7 @@ function u(u) {
 	let d = typeof u.getKey == "function" ? null : u.getKey ?? "id", f = (e) => typeof u.getKey == "function" ? u.getKey(e) : e[d], p = d ?? "id", m = u.position ?? "position", h = m !== !1, g = typeof m == "object" ? m.field : m === !1 ? "position" : m, _ = typeof m == "object" && m.multiplier ? m.multiplier : 1, v = u.parentField ?? "parent", y = r({
 		get: () => u.get(),
 		set: (e) => u.set(e)
-	}), b = n(y, {
+	}), b = e(y, {
 		keyField: p,
 		getKey: f,
 		positionField: g,
@@ -32,7 +32,7 @@ function u(u) {
 		h && delete t[g], delete t[v];
 		for (let e of C.value) delete t[e];
 		return JSON.stringify(t);
-	}, T = a(/* @__PURE__ */ new Map()), E = a(/* @__PURE__ */ new Map()), D = a(null), O = (t) => e(t), k = (e) => {
+	}, T = a(/* @__PURE__ */ new Map()), E = a(/* @__PURE__ */ new Map()), D = a(null), O = (e) => n(e), k = (e) => {
 		let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = (e, i) => {
 			for (let a of e) {
 				let e = f(a.data);
@@ -164,9 +164,9 @@ function u(u) {
 			let n = L(f(e.data));
 			(u.commitKey ? u.commitKey(e.data, n) : f(e.data)) == null && d && (e.data[p] = t()), e.meta.dirty = !1;
 		}), u.set(i), k(i), N.value = /* @__PURE__ */ new Map(), P.value = /* @__PURE__ */ new Set(), F.value = /* @__PURE__ */ new Set(), A.value = !1;
-	}, $ = (t) => {
-		if (t.length === 0) return;
-		let n = new Set(t), r = O(u.get()), i = new Map(T.value), a = new Map(E.value), o = D.value ? O(D.value) : {
+	}, $ = (e) => {
+		if (e.length === 0) return;
+		let t = new Set(e), r = O(u.get()), i = new Map(T.value), a = new Map(E.value), o = D.value ? O(D.value) : {
 			...r,
 			children: []
 		}, s = (e, t) => {
@@ -186,35 +186,35 @@ function u(u) {
 			if (l(o, (n) => {
 				t === void 0 && f(n.data) === e && (t = n);
 			}), t) return t.children || (t.children = []), t.children;
-		}, d = /* @__PURE__ */ new Set(), p = (t, r) => {
-			t.forEach((l, u) => {
+		}, d = /* @__PURE__ */ new Set(), p = (e, r) => {
+			e.forEach((l, u) => {
 				let m = f(l.data);
-				if (d.add(m), n.has(m)) {
+				if (d.add(m), t.has(m)) {
 					i.set(m, w(l.data)), a.set(m, r), l.meta.dirty = !1, N.value.delete(m), P.value.delete(m);
-					let n = s(o.children, m), d = e(l);
-					d.children = n ? n.node.children : l.children ? [] : void 0, d.meta = {
+					let t = s(o.children, m), d = n(l);
+					d.children = t ? t.node.children : l.children ? [] : void 0, d.meta = {
 						...d.meta,
 						dirty: !1
 					};
 					let p = c(r);
-					if (!p) n && n.siblings.splice(n.index, 0, d);
+					if (!p) t && t.siblings.splice(t.index, 0, d);
 					else {
-						let e = 0;
+						let t = 0;
 						for (let n = u - 1; n >= 0; n--) {
-							let r = p.findIndex((e) => f(e.data) === f(t[n].data));
+							let r = p.findIndex((t) => f(t.data) === f(e[n].data));
 							if (r !== -1) {
-								e = r + 1;
+								t = r + 1;
 								break;
 							}
 						}
-						p.splice(e, 0, d);
+						p.splice(t, 0, d);
 					}
 				}
 				l.children && l.children.length && p(l.children, m);
 			});
 		};
 		p(r.children, null);
-		for (let e of n) d.has(e) || (i.delete(e), a.delete(e), F.value.delete(e), s(o.children, e));
+		for (let e of t) d.has(e) || (i.delete(e), a.delete(e), F.value.delete(e), s(o.children, e));
 		T.value = i, E.value = a, D.value = o, u.set(r);
 	}, ee = (e) => {
 		let t = e ?? (D.value ? O(D.value) : u.get());
@@ -294,7 +294,6 @@ function u(u) {
 		calculateSubtreeDepth: b.calculateSubtreeDepth
 	};
 }
-//#endregion
 export { u as useNestedListEditorController };
 
 //# sourceMappingURL=useNestedListEditorController.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useNestedListEditorController.js","names":["flatten","out","walk","n","nodes","tree","walkNodes","visit","useNestedListEditorController","keyField","options","keyOf","item","keyFieldName","positionOpt","managedPosition","positionField","positionMultiplier","parentField","model","computed","v","useNestedListEditor","action","items","viewItems","dirtyExclude","toValue","normalize","copy","f","baselineHashes","ref","baselineParents","baselineTree","cloneTree","cloneDeep","captureBaseline","hashes","parents","key","parentKey","t","watch","submitted","registeredValidity","reactive","isItemDirty","saved","baselineTreeRow","node","baseHash","addedBaseline","editedKeys","deletedKeys","live","base","stale","revived","isRowEdited","hit","treeHasKey","found","unsavedKeys","isUnsaved","hasPendingMove","hasUnsaved","unsavedCount","keys","resolveValidity","registered","invalidKeys","hasErrors","rowState","invalid","editing","warning","validateAll","buildPayload","row","getPayload","getChanges","added","updated","moved","reparented","payload","byKey","baseParent","nowParent","deleted","commit","source","normalized","next","previous","nextListEditorTempId","acceptRows","wanted","detach","i","baseSiblings","siblings","at","index","seen","s","reset","restore","addItem","data","hint","addAfter","afterKey","addChild","updateItem","markDirty","dropFromBaseline","removed","opts","targetParentKey","targetIndex","isValid"],"sources":["../../../../src/domains/listEditor/composables/useNestedListEditorController.ts"],"sourcesContent":["import {\n  computed,\n  reactive,\n  ref,\n  toValue,\n  watch,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type Ref,\n  type ShallowUnwrapRef,\n} from 'vue'\nimport type {\n  ListEditorKey,\n  ListEditorValidationState,\n  NestedPositionHint,\n  NestedTree,\n  NestedTreeNode,\n} from '@/domains/listEditor/types/listEditorTypes'\nimport { useNestedListEditor, type NestedViewItem } from '@/domains/listEditor/composables/useNestedListEditor'\nimport type {\n  GetKey,\n  ListEditorValidationResult,\n  PositionOption,\n  PositionStrategy,\n} from '@/domains/listEditor/composables/useListEditorController'\nimport { nextListEditorTempId } from '@/domains/listEditor/utils/tempId'\nimport { cloneDeep } from '@/shared/utils/common'\n\nexport type { ListEditorValidationResult, GetKey, PositionOption, PositionStrategy }\n\n/** Flattened ordered row carrying its resolved key (for change-sets + payload). */\nexport interface NestedListEditorChanges<TItem> {\n  added: TItem[]\n  updated: TItem[]\n  moved: TItem[]\n  deleted: TItem[]\n  /**\n   * Rows whose parent changed since the last commit (BUG-13 — persisted even\n   * when the position number is unchanged).\n   */\n  reparented: TItem[]\n}\n\nexport interface UseNestedListEditorControllerOptions<TItem extends Record<string, any>> {\n  /** Read the live tree (the editor's v-model, or a consumer store getter). */\n  get: () => NestedTree<TItem>\n  /** Write the tree back. */\n  set: (tree: NestedTree<TItem>) => void\n  /** New-row factory. Optional for read-only / no-add trees. Should mint a stable temp id. */\n  factory?: () => TItem\n  /** Stable row identity. Default `'id'`. Never point this at the position field. */\n  getKey?: GetKey<TItem>\n  /** Managed order field. Default `'position'`. `false` opts out of position management. */\n  position?: PositionOption<TItem>\n  /** Parent-key field written onto reparented rows. Default `'parent'`. */\n  parentField?: string\n  /** Maximum nesting depth (1-based). Enforced by indent/outdent/moveTo. */\n  maxDepth: number\n  /**\n   * Extra top-level fields to drop from the dirty content-hash (position +\n   * parent are always dropped). Same purpose as the flat controller — a child\n   * collection tracked by a separate editor shouldn't flip its owner amber.\n   * Accepts a getter/ref so a `computed` set is honoured reactively.\n   */\n  dirtyExclude?: MaybeRefOrGetter<string[]>\n  /** Per-row validity — `true` = valid. Drives the red rail + `hasErrors`. */\n  validate?: (item: TItem) => ListEditorValidationResult\n  /** Custom dirty predicate (override the default `meta.dirty ∪ content-diff`). */\n  isDirty?: (current: TItem, saved: TItem | undefined) => boolean\n  /** Custom save payload (overrides `getPayload`). Receives the flattened ordered rows. */\n  payload?: (items: TItem[]) => TItem[]\n  /** Resolve a saved row's key on commit (default: existing key, else mint a temp id). */\n  commitKey?: (saved: TItem, previous: TItem | undefined) => ListEditorKey\n  /** Normalize the server tree before it becomes the new baseline on commit. */\n  normalizeSaved?: (saved: NestedTree<TItem>) => NestedTree<TItem>\n}\n\n/**\n * Tree-shaped state controller for the nested list editor (v2). A superset of\n * the flat `ListEditorHandle`: same dirty/validate/commit/reset semantics, but\n * the row set is a flattened ordered projection of a `NestedTree` and the\n * mutators are tree ops (indent / outdent / moveTo / addChild …) delegated to\n * `useNestedListEditor`. Each flattened payload row carries its resolved\n * `position` and parent key written onto it.\n */\nexport interface NestedListEditorHandle<TItem extends Record<string, any>> {\n  /** Flattened ordered rows (depth-first), matching the rendered order. */\n  items: ComputedRef<TItem[]>\n  /** Tree view rows (key/index/raw/depth/parent…), as consumed by the renderer. */\n  viewItems: ComputedRef<NestedViewItem<TItem>[]>\n  hasUnsaved: ComputedRef<boolean>\n  /** Count of distinct unconfirmed changes (added/edited/moved/reparented rows + deferred deletions). */\n  unsavedCount: ComputedRef<number>\n  hasErrors: ComputedRef<boolean>\n  invalidKeys: ComputedRef<Set<ListEditorKey>>\n  /** Amber: is this row added / edited / moved / reparented since the last commit? */\n  isUnsaved: (key: ListEditorKey) => boolean\n  /** Red rail (gated): 'invalid' only once the row is unsaved or `validateAll()` ran. */\n  rowState: (item: TItem, key: ListEditorKey, editing?: boolean) => ListEditorValidationState\n  /** Force-show all invalid rows + return whether the tree is valid. The save guard. */\n  validateAll: () => boolean\n  /** Flattened ordered array (each row carrying its resolved position + parent key) for a full-DTO save. */\n  getPayload: () => TItem[]\n  /** Change-set for partial-save endpoints (added/updated/moved/deleted/reparented), keyed. */\n  getChanges: () => NestedListEditorChanges<TItem>\n  /** Adopt the saved tree as the new baseline; backfill keys; clear dirty/submitted. */\n  commit: (saved?: NestedTree<TItem>) => void\n  /** Adopt only these rows as saved (a server-confirmed single-row op); other pending work stays. */\n  acceptRows: (keys: ListEditorKey[]) => void\n  /** Discard unsaved edits back to the last committed baseline (or a given tree). */\n  reset: (tree?: NestedTree<TItem>) => void\n\n  // Tree mutations — delegate to useNestedListEditor (which carries BUG-13).\n  addItem: (item?: TItem, hint?: NestedPositionHint) => void\n  addAfter: (afterKey: ListEditorKey, item?: TItem, childrenAllowed?: boolean) => void\n  addChild: (parentKey: ListEditorKey, item?: TItem, childrenAllowed?: boolean) => void\n  updateItem: (key: ListEditorKey, data: TItem, markDirty?: boolean) => void\n  deleteItem: (key: ListEditorKey, opts?: { trackDeleted?: boolean; renumber?: boolean }) => void\n  restoreDeleted: (key: ListEditorKey) => void\n  moveUp: (key: ListEditorKey) => boolean\n  moveDown: (key: ListEditorKey) => boolean\n  moveTop: (key: ListEditorKey) => boolean\n  moveBottom: (key: ListEditorKey) => boolean\n  indent: (key: ListEditorKey) => boolean\n  outdent: (key: ListEditorKey) => boolean\n  moveTo: (key: ListEditorKey, targetParentKey: ListEditorKey | null, targetIndex: number) => boolean\n  recalculatePositions: () => void\n\n  /** Escape hatch: a row form (e.g. vuelidate) reports its own validity instead of `validate`. */\n  registerValidity: (key: ListEditorKey, isValid: () => boolean) => () => void\n\n  // Internal handles the editor needs to drive the tree directly (find a node,\n  // subtree depth for drag, the underlying `editor.moveTo` returning the tree).\n  findNode: (key: ListEditorKey) => {\n    node: NestedTreeNode<TItem> | null\n    parent: NestedTreeNode<TItem> | null\n  }\n  calculateSubtreeDepth: (node: NestedTreeNode<TItem>) => number\n}\n\n/**\n * Consumer-facing shape of a nested-list-editor handle read through a template/function ref — Vue's\n * `expose` proxy unwraps the exposed refs, so read `handle.hasUnsaved` (a boolean), not\n * `handle.hasUnsaved.value`. See {@link ExposedListEditorHandle}.\n */\nexport type ExposedNestedListEditorHandle<TItem extends Record<string, any>> = ShallowUnwrapRef<\n  NestedListEditorHandle<TItem>\n>\n\n/** What `ANestedSortableListEditor` exposes on top of the controller handle. */\nexport interface NestedSortableListEditorExtras {\n  /**\n   * Runs a tree mutation the server has already made (a row created through a dialog) and adopts as\n   * saved only the rows it added or edited, plus `keys`. Siblings it only renumbered and other pending\n   * work stay unsaved (the server may not have renumbered them), and so does the position of a created\n   * row the op renumbered. `commit()` would adopt the whole tree instead.\n   */\n  acceptChanges: (op: () => void, keys?: ListEditorKey[]) => void\n  enterReorderMode: () => void\n  cancelReorderMode: () => void\n  applyReorder: () => Promise<void>\n  expand: (id: ListEditorKey) => void\n  collapse: (id: ListEditorKey) => void\n  toggleExpand: (id: ListEditorKey) => void\n  expandDetail: (id: ListEditorKey) => void\n  collapseDetail: (id: ListEditorKey) => void\n}\n\n/** `ANestedSortableListEditor` read through a template ref: the unwrapped handle and its extras. */\nexport type ExposedNestedSortableListEditorHandle<TItem extends Record<string, any>> =\n  ExposedNestedListEditorHandle<TItem> & NestedSortableListEditorExtras\n\nconst flatten = <TItem extends Record<string, any>>(tree: NestedTree<TItem>): TItem[] => {\n  const out: TItem[] = []\n  const walk = (nodes: NestedTreeNode<TItem>[]) => {\n    for (const n of nodes) {\n      out.push(n.data)\n      if (n.children && n.children.length) walk(n.children)\n    }\n  }\n  walk(tree.children)\n  return out\n}\n\nconst walkNodes = <TItem extends Record<string, any>>(\n  tree: NestedTree<TItem>,\n  visit: (node: NestedTreeNode<TItem>) => void\n): void => {\n  const walk = (nodes: NestedTreeNode<TItem>[]) => {\n    for (const n of nodes) {\n      visit(n)\n      if (n.children && n.children.length) walk(n.children)\n    }\n  }\n  walk(tree.children)\n}\n\nexport function useNestedListEditorController<TItem extends Record<string, any>>(\n  options: UseNestedListEditorControllerOptions<TItem>\n): NestedListEditorHandle<TItem> {\n  const keyField = (typeof options.getKey === 'function' ? null : (options.getKey ?? 'id')) as keyof TItem | null\n  const keyOf = (item: TItem): ListEditorKey =>\n    typeof options.getKey === 'function' ? options.getKey(item) : (item[keyField as keyof TItem] as ListEditorKey)\n  const keyFieldName = (keyField ?? 'id') as string\n\n  const positionOpt = options.position ?? 'position'\n  const managedPosition = positionOpt !== false\n  const positionField = (\n    typeof positionOpt === 'object' ? positionOpt.field : positionOpt === false ? 'position' : positionOpt\n  ) as string\n  const positionMultiplier = typeof positionOpt === 'object' && positionOpt.multiplier ? positionOpt.multiplier : 1\n  const parentField = options.parentField ?? 'parent'\n\n  // Two-way bridge to the consumer's tree: the composable's per-op\n  // `model.value = cloned` writes back via `set`, the getter re-reads live edits.\n  const model = computed<NestedTree<TItem>>({\n    get: () => options.get(),\n    set: (v) => options.set(v),\n  }) as unknown as Ref<NestedTree<TItem>>\n\n  const tree = useNestedListEditor<TItem>(model, {\n    keyField: keyFieldName,\n    // Pass the controller's keyOf so tree ops resolve keys identically to\n    // invalidKeys/dirty tracking — supports a function get-key, not just a field.\n    getKey: keyOf,\n    positionField,\n    parentField,\n    positionMultiplier,\n    managedPosition,\n    positionStrategyFor: (action) =>\n      (typeof positionOpt === 'object' && (positionOpt.strategyOverrides?.[action] ?? positionOpt.strategy)) ||\n      'renumber',\n    maxDepth: options.maxDepth,\n  })\n\n  const items = computed<TItem[]>(() => flatten(options.get()))\n  const viewItems = tree.viewItems\n\n  // Baseline = last committed snapshot. `hashes` powers content-diff dirty\n  // (position + parent excluded so a reorder/reparent never lights up via the\n  // content hash — meta.dirty / the reparented set carries those instead).\n  const dirtyExclude = computed<string[]>(() => toValue(options.dirtyExclude) ?? [])\n  const normalize = (item: TItem): string => {\n    const copy = { ...item } as Record<string, unknown>\n    if (managedPosition) delete copy[positionField]\n    delete copy[parentField]\n    for (const f of dirtyExclude.value) delete copy[f]\n    return JSON.stringify(copy)\n  }\n  const baselineHashes = ref(new Map<ListEditorKey, string>()) as Ref<Map<ListEditorKey, string>>\n  // Parent-key per row at baseline — drives reparented detection (BUG-13).\n  const baselineParents = ref(new Map<ListEditorKey, ListEditorKey | null>()) as Ref<\n    Map<ListEditorKey, ListEditorKey | null>\n  >\n  const baselineTree = ref<NestedTree<TItem> | null>(null) as Ref<NestedTree<TItem> | null>\n\n  const cloneTree = (t: NestedTree<TItem>): NestedTree<TItem> => cloneDeep(t)\n\n  const captureBaseline = (t: NestedTree<TItem>) => {\n    const hashes = new Map<ListEditorKey, string>()\n    const parents = new Map<ListEditorKey, ListEditorKey | null>()\n    const walk = (nodes: NestedTreeNode<TItem>[], parentKey: ListEditorKey | null) => {\n      for (const n of nodes) {\n        const key = keyOf(n.data)\n        hashes.set(key, normalize(n.data))\n        parents.set(key, parentKey)\n        if (n.children && n.children.length) walk(n.children, key)\n      }\n    }\n    walk(t.children, null)\n    baselineHashes.value = hashes\n    baselineParents.value = parents\n    baselineTree.value = cloneTree(t)\n  }\n  captureBaseline(options.get())\n  // Re-hash when the excluded-field set changes; `sync` so baseline + live\n  // normalize() never disagree mid-flush. (Mirrors the flat controller.)\n  watch(\n    dirtyExclude,\n    () => {\n      if (!baselineTree.value) return\n      const hashes = new Map<ListEditorKey, string>()\n      walkNodes(baselineTree.value, (n) => hashes.set(keyOf(n.data), normalize(n.data)))\n      baselineHashes.value = hashes\n    },\n    { flush: 'sync' }\n  )\n\n  const submitted = ref(false)\n  // Reactive so a row form (re)registering its validity re-runs invalidKeys/rowState.\n  const registeredValidity = reactive(new Map<ListEditorKey, () => boolean>())\n\n  // Amber = added OR content-edited OR reparented (vs baseline). Position is\n  // excluded, so a displaced sibling's pure renumber is NOT amber (matches the flat\n  // editor + the \"only the actively-moved subtree lights up\" UX); BUG-13 adds the\n  // parent-changed signal so a reparent registers even at an unchanged position\n  // number. `getChanges().moved` reads meta.dirty, so displaced siblings' new\n  // positions are still persisted; `hasPendingMove` (below) feeds the leave guard.\n  const isItemDirty = (node: NestedTreeNode<TItem>, key: ListEditorKey, parentKey: ListEditorKey | null): boolean => {\n    if (options.isDirty) {\n      const saved = baselineTreeRow(key)\n      return options.isDirty(node.data, saved)\n    }\n    const baseHash = baselineHashes.value.get(key)\n    if (baseHash === undefined) return true // added\n    if (baseHash !== normalize(node.data)) return true // content-edited (pos/parent excluded)\n    // Reparented vs baseline (BUG-13).\n    if (baselineParents.value.has(key)) {\n      const baseParent = baselineParents.value.get(key) ?? null\n      if ((baseParent ?? null) !== (parentKey ?? null)) return true\n    }\n    return false\n  }\n\n  // `addedBaseline` = first-seen content hash of each ADDED node; `editedKeys` = STICKY set of\n  // nodes whose content has since diverged. Gates the validation rail on \"has this row been edited\"\n  // rather than just \"is it unsaved\" (sticky like vuelidate `$dirty`) — mirrors the flat controller.\n  const addedBaseline = ref(new Map<ListEditorKey, string>()) as Ref<Map<ListEditorKey, string>>\n  const editedKeys = ref(new Set<ListEditorKey>()) as Ref<Set<ListEditorKey>>\n  // Deferred-deletion tombstones (baseline keys removed but not yet saved). Immediate deletes skip\n  // this so they don't read as unsaved. Drives hasUnsaved / unsavedCount / getChanges().deleted.\n  const deletedKeys = ref(new Set<ListEditorKey>()) as Ref<Set<ListEditorKey>>\n  watch(\n    () => options.get(),\n    (tree) => {\n      const live = new Set<ListEditorKey>()\n      walkNodes(tree, (n) => {\n        const key = keyOf(n.data)\n        live.add(key)\n        if (!baselineHashes.value.has(key) && !addedBaseline.value.has(key)) {\n          addedBaseline.value.set(key, normalize(n.data))\n        }\n        if (!editedKeys.value.has(key)) {\n          const base = baselineHashes.value.get(key) ?? addedBaseline.value.get(key)\n          if (base !== undefined && base !== normalize(n.data)) editedKeys.value.add(key)\n        }\n      })\n      const stale: ListEditorKey[] = []\n      for (const key of addedBaseline.value.keys()) if (!live.has(key)) stale.push(key)\n      for (const key of stale) addedBaseline.value.delete(key)\n      // A tombstoned key that becomes live again (re-add before save) drops its tombstone.\n      const revived: ListEditorKey[] = []\n      for (const key of deletedKeys.value) if (live.has(key)) revived.push(key)\n      for (const key of revived) deletedKeys.value.delete(key)\n    },\n    { immediate: true, deep: true }\n  )\n\n  const isRowEdited = (key: ListEditorKey): boolean => editedKeys.value.has(key)\n\n  const baselineTreeRow = (key: ListEditorKey): TItem | undefined => {\n    if (!baselineTree.value) return undefined\n    let hit: TItem | undefined\n    walkNodes(baselineTree.value, (n) => {\n      if (hit === undefined && keyOf(n.data) === key) hit = n.data\n    })\n    return hit\n  }\n\n  const treeHasKey = (key: ListEditorKey): boolean => {\n    let found = false\n    walkNodes(options.get(), (n) => {\n      if (!found && keyOf(n.data) === key) found = true\n    })\n    return found\n  }\n\n  const unsavedKeys = computed<Set<ListEditorKey>>(() => {\n    const out = new Set<ListEditorKey>()\n    const walk = (nodes: NestedTreeNode<TItem>[], parentKey: ListEditorKey | null) => {\n      for (const n of nodes) {\n        const key = keyOf(n.data)\n        if (isItemDirty(n, key, parentKey)) out.add(key)\n        if (n.children && n.children.length) walk(n.children, key)\n      }\n    }\n    walk(options.get().children, null)\n    return out\n  })\n\n  const isUnsaved = (key: ListEditorKey): boolean => unsavedKeys.value.has(key)\n  // A pure position reorder sets meta.dirty (recalculateSiblings) but is deliberately\n  // kept OUT of per-row amber (only the actively-moved subtree lights up). It IS a\n  // pending change though, so it must arm the leave guard — surface it as an aggregate\n  // signal (M2b) that survives Apply and clears on commit (which resets meta.dirty).\n  const hasPendingMove = computed<boolean>(() => {\n    let found = false\n    walkNodes(options.get(), (n) => {\n      if (n.meta.dirty) found = true\n    })\n    return found\n  })\n  const hasUnsaved = computed<boolean>(\n    () => unsavedKeys.value.size > 0 || deletedKeys.value.size > 0 || hasPendingMove.value\n  )\n  // Distinct unconfirmed changes = union of live dirty keys (added/edited/moved/reparented) and\n  // deferred-deletion tombstones. Drives the \"N unconfirmed changes\" indicator.\n  const unsavedCount = computed<number>(() => {\n    const keys = new Set<ListEditorKey>(unsavedKeys.value)\n    for (const key of deletedKeys.value) keys.add(key)\n    return keys.size\n  })\n\n  const resolveValidity = (item: TItem, key: ListEditorKey): { invalid: boolean; warning: boolean } => {\n    const registered = registeredValidity.get(key)\n    if (registered) return { invalid: !registered(), warning: false }\n    if (!options.validate) return { invalid: false, warning: false }\n    const r = options.validate(item)\n    if (typeof r === 'boolean') return { invalid: !r, warning: false }\n    return { invalid: !r.valid, warning: r.valid && r.state === 'warning' }\n  }\n\n  const invalidKeys = computed<Set<ListEditorKey>>(() => {\n    const out = new Set<ListEditorKey>()\n    walkNodes(options.get(), (n) => {\n      const key = keyOf(n.data)\n      if (resolveValidity(n.data, key).invalid) out.add(key)\n    })\n    return out\n  })\n  const hasErrors = computed<boolean>(() => invalidKeys.value.size > 0)\n\n  // Red rail for an invalid row that has been edited, is unsaved (added), or after a save attempt —\n  // mirrors the flat controller. The editor suppresses the red while the row is the one being edited,\n  // so a still-being-filled row reads amber and only goes red once collapsed. (QA 85050 batch 7)\n  const rowState = (item: TItem, key: ListEditorKey, editing = false): ListEditorValidationState => {\n    const { invalid, warning } = resolveValidity(item, key)\n    // See flat controller: red when edited/unsaved/submitted, amber while being filled, red once\n    // collapsed; a save attempt (`submitted`) reds it even while open. (QA 85050 batch 7)\n    if (invalid) {\n      if (submitted.value) return 'invalid'\n      if (editing) return null\n      return isRowEdited(key) || isUnsaved(key) ? 'invalid' : null\n    }\n    if (warning) return 'warning'\n    return null\n  }\n\n  const validateAll = (): boolean => {\n    submitted.value = true\n    return invalidKeys.value.size === 0\n  }\n\n  // Flattened ordered payload; parent key is resolved from tree structure (so a\n  // reparent is reflected even if the node's own parent field lagged).\n  const buildPayload = (): TItem[] => {\n    const out: TItem[] = []\n    const walk = (nodes: NestedTreeNode<TItem>[], parentKey: ListEditorKey | null) => {\n      for (const n of nodes) {\n        const row = { ...n.data } as TItem\n        ;(row as Record<string, unknown>)[parentField] = parentKey\n        out.push(row)\n        if (n.children && n.children.length) walk(n.children, keyOf(n.data))\n      }\n    }\n    walk(options.get().children, null)\n    return out\n  }\n\n  const getPayload = (): TItem[] => (options.payload ? options.payload(buildPayload()) : buildPayload())\n\n  const getChanges = (): NestedListEditorChanges<TItem> => {\n    const added: TItem[] = []\n    const updated: TItem[] = []\n    const moved: TItem[] = []\n    const reparented: TItem[] = []\n    const payload = buildPayload()\n    const byKey = new Map<ListEditorKey, TItem>()\n    for (const row of payload) byKey.set(keyOf(row), row)\n\n    walkNodes(options.get(), (n) => {\n      const key = keyOf(n.data)\n      const row = byKey.get(key) ?? n.data\n      const baseHash = baselineHashes.value.get(key)\n      if (baseHash === undefined) {\n        added.push(row)\n      } else if (baseHash !== normalize(n.data)) {\n        updated.push(row)\n      }\n      // meta.dirty without a content change => a move/reparent (position/parent\n      // changed). recalculateSiblings + BUG-13 set meta.dirty on those.\n      if (baseHash !== undefined && n.meta.dirty && baseHash === normalize(n.data)) {\n        moved.push(row)\n      }\n      // Reparented = parent key differs from baseline (subset of moved, but\n      // surfaced separately for partial-multi saves that re-link parents).\n      if (baselineParents.value.has(key)) {\n        const baseParent = baselineParents.value.get(key) ?? null\n        const nowParent = (row as Record<string, unknown>)[parentField] as ListEditorKey | null\n        if ((baseParent ?? null) !== (nowParent ?? null)) reparented.push(row)\n      }\n    })\n\n    // Deferred deletions come from the tombstone set, so an IMMEDIATE delete (already persisted on the\n    // backend, no tombstone) does not re-appear here as a local deleted change.\n    const deleted: TItem[] = []\n    for (const key of deletedKeys.value) {\n      const row = baselineTreeRow(key)\n      if (row !== undefined) deleted.push(row)\n    }\n    return { added, updated, moved, deleted, reparented }\n  }\n\n  const commit = (saved?: NestedTree<TItem>): void => {\n    const source = saved ?? options.get()\n    const normalized = options.normalizeSaved ? options.normalizeSaved(source) : source\n    // Backfill missing keys + clear meta.dirty on the committed tree.\n    const next = cloneTree(normalized)\n    walkNodes(next, (n) => {\n      const previous = baselineTreeRow(keyOf(n.data))\n      const resolvedKey = options.commitKey ? options.commitKey(n.data, previous) : keyOf(n.data)\n      if (resolvedKey === undefined || resolvedKey === null) {\n        if (keyField) (n.data as Record<string, unknown>)[keyFieldName] = nextListEditorTempId()\n      }\n      n.meta.dirty = false\n    })\n    options.set(next)\n    captureBaseline(next)\n    addedBaseline.value = new Map()\n    editedKeys.value = new Set()\n    deletedKeys.value = new Set()\n    submitted.value = false\n  }\n\n  // Adopt ONLY the given rows as saved (server-confirmed single-row ops); other pending work stays.\n  // The saved tree follows along — reset() and getChanges().deleted read it: an accepted row takes its\n  // current data and place there, an accepted key no longer in the tree leaves it.\n  const acceptRows = (keys: ListEditorKey[]): void => {\n    if (keys.length === 0) return\n    const wanted = new Set(keys)\n    const next = cloneTree(options.get())\n    const hashes = new Map(baselineHashes.value)\n    const parents = new Map(baselineParents.value)\n    const base: NestedTree<TItem> = baselineTree.value ? cloneTree(baselineTree.value) : { ...next, children: [] }\n    type Detached = { node: NestedTreeNode<TItem>; siblings: NestedTreeNode<TItem>[]; index: number }\n    const detach = (nodes: NestedTreeNode<TItem>[], key: ListEditorKey): Detached | undefined => {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i]!\n        if (keyOf(node.data) === key) return { node: nodes.splice(i, 1)[0]!, siblings: nodes, index: i }\n        const found = node.children?.length ? detach(node.children, key) : undefined\n        if (found) return found\n      }\n      return undefined\n    }\n    const baseSiblings = (parentKey: ListEditorKey | null): NestedTreeNode<TItem>[] | undefined => {\n      if (parentKey === null) return base.children\n      let hit: NestedTreeNode<TItem> | undefined\n      walkNodes(base, (n) => {\n        if (hit === undefined && keyOf(n.data) === parentKey) hit = n\n      })\n      if (!hit) return undefined\n      if (!hit.children) hit.children = []\n      return hit.children\n    }\n    const live = new Set<ListEditorKey>()\n    const walk = (nodes: NestedTreeNode<TItem>[], parentKey: ListEditorKey | null) => {\n      nodes.forEach((n, index) => {\n        const key = keyOf(n.data)\n        live.add(key)\n        if (wanted.has(key)) {\n          hashes.set(key, normalize(n.data))\n          parents.set(key, parentKey)\n          n.meta.dirty = false\n          addedBaseline.value.delete(key)\n          editedKeys.value.delete(key)\n          const previous = detach(base.children, key)\n          const saved = cloneDeep(n)\n          // A row added without children allowed stays without them; a saved row keeps its saved children.\n          saved.children = previous ? previous.node.children : n.children ? [] : undefined\n          saved.meta = { ...saved.meta, dirty: false }\n          const siblings = baseSiblings(parentKey)\n          if (!siblings) {\n            // The new parent is not in the saved tree (e.g. it was this row's own saved child, detached\n            // with it): keep the row where it was saved rather than drop it and its children.\n            if (previous) previous.siblings.splice(previous.index, 0, saved)\n          } else {\n            // After the nearest preceding sibling the saved tree knows, so pending rows don't skew it.\n            let at = 0\n            for (let i = index - 1; i >= 0; i--) {\n              const seen = siblings.findIndex((s) => keyOf(s.data) === keyOf(nodes[i]!.data))\n              if (seen !== -1) {\n                at = seen + 1\n                break\n              }\n            }\n            siblings.splice(at, 0, saved)\n          }\n        }\n        if (n.children && n.children.length) walk(n.children, key)\n      })\n    }\n    walk(next.children, null)\n    for (const key of wanted) {\n      if (live.has(key)) continue\n      hashes.delete(key)\n      parents.delete(key)\n      // Gone from the backend: no longer a pending deletion either.\n      deletedKeys.value.delete(key)\n      detach(base.children, key)\n    }\n    baselineHashes.value = hashes\n    baselineParents.value = parents\n    baselineTree.value = base\n    options.set(next)\n  }\n\n  const reset = (t?: NestedTree<TItem>): void => {\n    const restore = t ?? (baselineTree.value ? cloneTree(baselineTree.value) : options.get())\n    options.set(restore)\n    addedBaseline.value = new Map()\n    editedKeys.value = new Set()\n    deletedKeys.value = new Set()\n    submitted.value = false\n  }\n\n  // --- Tree mutations (delegate to useNestedListEditor) -----------------------\n\n  const addItem = (item?: TItem, hint?: NestedPositionHint): void => {\n    const data = item ?? options.factory?.()\n    if (data === undefined) return // no item + no factory (read-only) → no-op\n    tree.addItem(data, hint)\n  }\n  const addAfter = (afterKey: ListEditorKey, item?: TItem, childrenAllowed = true): void => {\n    const data = item ?? options.factory?.()\n    if (data === undefined) return\n    tree.addItem(data, { afterId: afterKey, childrenAllowed })\n  }\n  const addChild = (parentKey: ListEditorKey, item?: TItem, childrenAllowed = true): void => {\n    const data = item ?? options.factory?.()\n    if (data === undefined) return\n    tree.addItem(data, { parentId: parentKey, childrenAllowed })\n  }\n  const updateItem = (key: ListEditorKey, data: TItem, markDirty = true): void => {\n    tree.updateItem(key, data, markDirty)\n  }\n  // An immediate delete: the row is gone on the backend, and the editor removes it with its subtree, so\n  // neither is part of the saved tree `reset()` restores any more.\n  const dropFromBaseline = (key: ListEditorKey): void => {\n    if (!baselineTree.value) return\n    const base = cloneTree(baselineTree.value)\n    const detach = (nodes: NestedTreeNode<TItem>[]): NestedTreeNode<TItem> | undefined => {\n      for (let i = 0; i < nodes.length; i++) {\n        if (keyOf(nodes[i]!.data) === key) return nodes.splice(i, 1)[0]\n        const found = nodes[i]!.children?.length ? detach(nodes[i]!.children!) : undefined\n        if (found) return found\n      }\n      return undefined\n    }\n    const removed = detach(base.children)\n    if (!removed) return\n    const hashes = new Map(baselineHashes.value)\n    const parents = new Map(baselineParents.value)\n    walkNodes({ ...base, children: [removed] }, (n) => {\n      hashes.delete(keyOf(n.data))\n      parents.delete(keyOf(n.data))\n    })\n    baselineHashes.value = hashes\n    baselineParents.value = parents\n    baselineTree.value = base\n  }\n\n  const deleteItem = (key: ListEditorKey, opts?: { trackDeleted?: boolean; renumber?: boolean }): void => {\n    // A previously-saved row removed in deferred mode is tombstoned (counts as unsaved + reported in\n    // getChanges().deleted). `trackDeleted: false` (immediate — already deleted on the backend) skips it.\n    // `treeHasKey` guards against a phantom tombstone: an immediate delete removes the row in the\n    // component's own handler (trackDeleted:false), then a consumer removing it again (acceptChanges\n    // around deleteItem) re-calls deleteItem for the now-gone key — without the guard that second call\n    // would tombstone a baseline row that is already deleted, surfacing a bogus unconfirmed change.\n    if (baselineHashes.value.has(key) && opts?.trackDeleted !== false && treeHasKey(key)) {\n      deletedKeys.value.add(key)\n    } else if (baselineHashes.value.has(key) && treeHasKey(key)) {\n      dropFromBaseline(key)\n    }\n    tree.deleteItem(key, { renumber: opts?.renumber })\n  }\n\n  const restoreDeleted = (key: ListEditorKey): void => {\n    deletedKeys.value.delete(key)\n  }\n  const moveUp = (key: ListEditorKey): boolean => tree.moveUp(key) !== null\n  const moveDown = (key: ListEditorKey): boolean => tree.moveDown(key) !== null\n  const moveTop = (key: ListEditorKey): boolean => tree.moveTop(key) !== null\n  const moveBottom = (key: ListEditorKey): boolean => tree.moveBottom(key) !== null\n  const indent = (key: ListEditorKey): boolean => tree.indent(key) !== null\n  const outdent = (key: ListEditorKey): boolean => tree.outdent(key) !== null\n  const moveTo = (key: ListEditorKey, targetParentKey: ListEditorKey | null, targetIndex: number): boolean =>\n    tree.moveTo(key, targetParentKey, targetIndex) !== null\n  const recalculatePositions = (): void => {\n    options.set(tree.recalculatePositions(options.get()))\n  }\n\n  const registerValidity = (key: ListEditorKey, isValid: () => boolean): (() => void) => {\n    registeredValidity.set(key, isValid)\n    return () => registeredValidity.delete(key)\n  }\n\n  return {\n    items,\n    viewItems,\n    hasUnsaved,\n    unsavedCount,\n    hasErrors,\n    invalidKeys,\n    isUnsaved,\n    rowState,\n    validateAll,\n    getPayload,\n    getChanges,\n    commit,\n    acceptRows,\n    reset,\n    addItem,\n    addAfter,\n    addChild,\n    updateItem,\n    deleteItem,\n    restoreDeleted,\n    moveUp,\n    moveDown,\n    moveTop,\n    moveBottom,\n    indent,\n    outdent,\n    moveTo,\n    recalculatePositions,\n    registerValidity,\n    findNode: tree.findNode,\n    calculateSubtreeDepth: tree.calculateSubtreeDepth,\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"useNestedListEditorController.js","names":["flatten","out","walk","n","nodes","tree","walkNodes","visit","useNestedListEditorController","keyField","options","keyOf","item","keyFieldName","positionOpt","managedPosition","positionField","positionMultiplier","parentField","model","computed","v","useNestedListEditor","action","items","viewItems","dirtyExclude","toValue","normalize","copy","f","baselineHashes","ref","baselineParents","baselineTree","cloneTree","cloneDeep","t","captureBaseline","hashes","parents","key","parentKey","watch","submitted","registeredValidity","reactive","isItemDirty","saved","baselineTreeRow","node","baseHash","addedBaseline","editedKeys","deletedKeys","live","base","stale","revived","isRowEdited","hit","treeHasKey","found","unsavedKeys","isUnsaved","hasPendingMove","hasUnsaved","unsavedCount","keys","resolveValidity","registered","invalidKeys","hasErrors","rowState","invalid","editing","warning","validateAll","buildPayload","row","getPayload","getChanges","added","updated","moved","reparented","payload","byKey","baseParent","nowParent","deleted","commit","source","normalized","next","previous","nextListEditorTempId","acceptRows","wanted","detach","i","baseSiblings","siblings","at","index","seen","s","reset","restore","addItem","data","hint","addAfter","afterKey","addChild","updateItem","markDirty","dropFromBaseline","removed","opts","targetParentKey","targetIndex","isValid"],"sources":["../../../../src/domains/listEditor/composables/useNestedListEditorController.ts"],"sourcesContent":["import {\n  computed,\n  reactive,\n  ref,\n  toValue,\n  watch,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type Ref,\n  type ShallowUnwrapRef,\n} from 'vue'\nimport type {\n  ListEditorKey,\n  ListEditorValidationState,\n  NestedPositionHint,\n  NestedTree,\n  NestedTreeNode,\n} from '@/domains/listEditor/types/listEditorTypes'\nimport { useNestedListEditor, type NestedViewItem } from '@/domains/listEditor/composables/useNestedListEditor'\nimport type {\n  GetKey,\n  ListEditorValidationResult,\n  PositionOption,\n  PositionStrategy,\n} from '@/domains/listEditor/composables/useListEditorController'\nimport { nextListEditorTempId } from '@/domains/listEditor/utils/tempId'\nimport { cloneDeep } from '@/shared/utils/common'\n\nexport type { ListEditorValidationResult, GetKey, PositionOption, PositionStrategy }\n\n/** Flattened ordered row carrying its resolved key (for change-sets + payload). */\nexport interface NestedListEditorChanges<TItem> {\n  added: TItem[]\n  updated: TItem[]\n  moved: TItem[]\n  deleted: TItem[]\n  /**\n   * Rows whose parent changed since the last commit (BUG-13 — persisted even\n   * when the position number is unchanged).\n   */\n  reparented: TItem[]\n}\n\nexport interface UseNestedListEditorControllerOptions<TItem extends Record<string, any>> {\n  /** Read the live tree (the editor's v-model, or a consumer store getter). */\n  get: () => NestedTree<TItem>\n  /** Write the tree back. */\n  set: (tree: NestedTree<TItem>) => void\n  /** New-row factory. Optional for read-only / no-add trees. Should mint a stable temp id. */\n  factory?: () => TItem\n  /** Stable row identity. Default `'id'`. Never point this at the position field. */\n  getKey?: GetKey<TItem>\n  /** Managed order field. Default `'position'`. `false` opts out of position management. */\n  position?: PositionOption<TItem>\n  /** Parent-key field written onto reparented rows. Default `'parent'`. */\n  parentField?: string\n  /** Maximum nesting depth (1-based). Enforced by indent/outdent/moveTo. */\n  maxDepth: number\n  /**\n   * Extra top-level fields to drop from the dirty content-hash (position +\n   * parent are always dropped). Same purpose as the flat controller — a child\n   * collection tracked by a separate editor shouldn't flip its owner amber.\n   * Accepts a getter/ref so a `computed` set is honoured reactively.\n   */\n  dirtyExclude?: MaybeRefOrGetter<string[]>\n  /** Per-row validity — `true` = valid. Drives the red rail + `hasErrors`. */\n  validate?: (item: TItem) => ListEditorValidationResult\n  /** Custom dirty predicate (override the default `meta.dirty ∪ content-diff`). */\n  isDirty?: (current: TItem, saved: TItem | undefined) => boolean\n  /** Custom save payload (overrides `getPayload`). Receives the flattened ordered rows. */\n  payload?: (items: TItem[]) => TItem[]\n  /** Resolve a saved row's key on commit (default: existing key, else mint a temp id). */\n  commitKey?: (saved: TItem, previous: TItem | undefined) => ListEditorKey\n  /** Normalize the server tree before it becomes the new baseline on commit. */\n  normalizeSaved?: (saved: NestedTree<TItem>) => NestedTree<TItem>\n}\n\n/**\n * Tree-shaped state controller for the nested list editor (v2). A superset of\n * the flat `ListEditorHandle`: same dirty/validate/commit/reset semantics, but\n * the row set is a flattened ordered projection of a `NestedTree` and the\n * mutators are tree ops (indent / outdent / moveTo / addChild …) delegated to\n * `useNestedListEditor`. Each flattened payload row carries its resolved\n * `position` and parent key written onto it.\n */\nexport interface NestedListEditorHandle<TItem extends Record<string, any>> {\n  /** Flattened ordered rows (depth-first), matching the rendered order. */\n  items: ComputedRef<TItem[]>\n  /** Tree view rows (key/index/raw/depth/parent…), as consumed by the renderer. */\n  viewItems: ComputedRef<NestedViewItem<TItem>[]>\n  hasUnsaved: ComputedRef<boolean>\n  /** Count of distinct unconfirmed changes (added/edited/moved/reparented rows + deferred deletions). */\n  unsavedCount: ComputedRef<number>\n  hasErrors: ComputedRef<boolean>\n  invalidKeys: ComputedRef<Set<ListEditorKey>>\n  /** Amber: is this row added / edited / moved / reparented since the last commit? */\n  isUnsaved: (key: ListEditorKey) => boolean\n  /** Red rail (gated): 'invalid' only once the row is unsaved or `validateAll()` ran. */\n  rowState: (item: TItem, key: ListEditorKey, editing?: boolean) => ListEditorValidationState\n  /** Force-show all invalid rows + return whether the tree is valid. The save guard. */\n  validateAll: () => boolean\n  /** Flattened ordered array (each row carrying its resolved position + parent key) for a full-DTO save. */\n  getPayload: () => TItem[]\n  /** Change-set for partial-save endpoints (added/updated/moved/deleted/reparented), keyed. */\n  getChanges: () => NestedListEditorChanges<TItem>\n  /** Adopt the saved tree as the new baseline; backfill keys; clear dirty/submitted. */\n  commit: (saved?: NestedTree<TItem>) => void\n  /** Adopt only these rows as saved (a server-confirmed single-row op); other pending work stays. */\n  acceptRows: (keys: ListEditorKey[]) => void\n  /** Discard unsaved edits back to the last committed baseline (or a given tree). */\n  reset: (tree?: NestedTree<TItem>) => void\n\n  // Tree mutations — delegate to useNestedListEditor (which carries BUG-13).\n  addItem: (item?: TItem, hint?: NestedPositionHint) => void\n  addAfter: (afterKey: ListEditorKey, item?: TItem, childrenAllowed?: boolean) => void\n  addChild: (parentKey: ListEditorKey, item?: TItem, childrenAllowed?: boolean) => void\n  updateItem: (key: ListEditorKey, data: TItem, markDirty?: boolean) => void\n  deleteItem: (key: ListEditorKey, opts?: { trackDeleted?: boolean; renumber?: boolean }) => void\n  restoreDeleted: (key: ListEditorKey) => void\n  moveUp: (key: ListEditorKey) => boolean\n  moveDown: (key: ListEditorKey) => boolean\n  moveTop: (key: ListEditorKey) => boolean\n  moveBottom: (key: ListEditorKey) => boolean\n  indent: (key: ListEditorKey) => boolean\n  outdent: (key: ListEditorKey) => boolean\n  moveTo: (key: ListEditorKey, targetParentKey: ListEditorKey | null, targetIndex: number) => boolean\n  recalculatePositions: () => void\n\n  /** Escape hatch: a row form (e.g. vuelidate) reports its own validity instead of `validate`. */\n  registerValidity: (key: ListEditorKey, isValid: () => boolean) => () => void\n\n  // Internal handles the editor needs to drive the tree directly (find a node,\n  // subtree depth for drag, the underlying `editor.moveTo` returning the tree).\n  findNode: (key: ListEditorKey) => {\n    node: NestedTreeNode<TItem> | null\n    parent: NestedTreeNode<TItem> | null\n  }\n  calculateSubtreeDepth: (node: NestedTreeNode<TItem>) => number\n}\n\n/**\n * Consumer-facing shape of a nested-list-editor handle read through a template/function ref — Vue's\n * `expose` proxy unwraps the exposed refs, so read `handle.hasUnsaved` (a boolean), not\n * `handle.hasUnsaved.value`. See {@link ExposedListEditorHandle}.\n */\nexport type ExposedNestedListEditorHandle<TItem extends Record<string, any>> = ShallowUnwrapRef<\n  NestedListEditorHandle<TItem>\n>\n\n/** What `ANestedSortableListEditor` exposes on top of the controller handle. */\nexport interface NestedSortableListEditorExtras {\n  /**\n   * Runs a tree mutation the server already made (e.g. a row created through a dialog).\n   * Adopts as saved only the rows it added or edited, plus `keys`.\n   * Siblings it only renumbered, other pending work and a renumbered position of\n   * a created row stay unsaved, because the server may not have renumbered them.\n   * `commit()` would adopt the whole tree instead.\n   */\n  acceptChanges: (op: () => void, keys?: ListEditorKey[]) => void\n  enterReorderMode: () => void\n  cancelReorderMode: () => void\n  applyReorder: () => Promise<void>\n  expand: (id: ListEditorKey) => void\n  collapse: (id: ListEditorKey) => void\n  toggleExpand: (id: ListEditorKey) => void\n  expandDetail: (id: ListEditorKey) => void\n  collapseDetail: (id: ListEditorKey) => void\n}\n\n/** `ANestedSortableListEditor` read through a template ref: the unwrapped handle and its extras. */\nexport type ExposedNestedSortableListEditorHandle<TItem extends Record<string, any>> =\n  ExposedNestedListEditorHandle<TItem> & NestedSortableListEditorExtras\n\nconst flatten = <TItem extends Record<string, any>>(tree: NestedTree<TItem>): TItem[] => {\n  const out: TItem[] = []\n  const walk = (nodes: NestedTreeNode<TItem>[]) => {\n    for (const n of nodes) {\n      out.push(n.data)\n      if (n.children && n.children.length) walk(n.children)\n    }\n  }\n  walk(tree.children)\n  return out\n}\n\nconst walkNodes = <TItem extends Record<string, any>>(\n  tree: NestedTree<TItem>,\n  visit: (node: NestedTreeNode<TItem>) => void\n): void => {\n  const walk = (nodes: NestedTreeNode<TItem>[]) => {\n    for (const n of nodes) {\n      visit(n)\n      if (n.children && n.children.length) walk(n.children)\n    }\n  }\n  walk(tree.children)\n}\n\nexport function useNestedListEditorController<TItem extends Record<string, any>>(\n  options: UseNestedListEditorControllerOptions<TItem>\n): NestedListEditorHandle<TItem> {\n  const keyField = (typeof options.getKey === 'function' ? null : (options.getKey ?? 'id')) as keyof TItem | null\n  const keyOf = (item: TItem): ListEditorKey =>\n    typeof options.getKey === 'function' ? options.getKey(item) : (item[keyField as keyof TItem] as ListEditorKey)\n  const keyFieldName = (keyField ?? 'id') as string\n\n  const positionOpt = options.position ?? 'position'\n  const managedPosition = positionOpt !== false\n  const positionField = (\n    typeof positionOpt === 'object' ? positionOpt.field : positionOpt === false ? 'position' : positionOpt\n  ) as string\n  const positionMultiplier = typeof positionOpt === 'object' && positionOpt.multiplier ? positionOpt.multiplier : 1\n  const parentField = options.parentField ?? 'parent'\n\n  // Two-way bridge to the consumer's tree: the composable's per-op\n  // `model.value = cloned` writes back via `set`, the getter re-reads live edits.\n  const model = computed<NestedTree<TItem>>({\n    get: () => options.get(),\n    set: (v) => options.set(v),\n  }) as unknown as Ref<NestedTree<TItem>>\n\n  const tree = useNestedListEditor<TItem>(model, {\n    keyField: keyFieldName,\n    // Pass the controller's keyOf so tree ops resolve keys identically to\n    // invalidKeys/dirty tracking — supports a function get-key, not just a field.\n    getKey: keyOf,\n    positionField,\n    parentField,\n    positionMultiplier,\n    managedPosition,\n    positionStrategyFor: (action) =>\n      (typeof positionOpt === 'object' && (positionOpt.strategyOverrides?.[action] ?? positionOpt.strategy)) ||\n      'renumber',\n    maxDepth: options.maxDepth,\n  })\n\n  const items = computed<TItem[]>(() => flatten(options.get()))\n  const viewItems = tree.viewItems\n\n  // Baseline = last committed snapshot. `hashes` powers content-diff dirty\n  // (position + parent excluded so a reorder/reparent never lights up via the\n  // content hash — meta.dirty / the reparented set carries those instead).\n  const dirtyExclude = computed<string[]>(() => toValue(options.dirtyExclude) ?? [])\n  const normalize = (item: TItem): string => {\n    const copy = { ...item } as Record<string, unknown>\n    if (managedPosition) delete copy[positionField]\n    delete copy[parentField]\n    for (const f of dirtyExclude.value) delete copy[f]\n    return JSON.stringify(copy)\n  }\n  const baselineHashes = ref(new Map<ListEditorKey, string>()) as Ref<Map<ListEditorKey, string>>\n  // Parent-key per row at baseline — drives reparented detection (BUG-13).\n  const baselineParents = ref(new Map<ListEditorKey, ListEditorKey | null>()) as Ref<\n    Map<ListEditorKey, ListEditorKey | null>\n  >\n  const baselineTree = ref<NestedTree<TItem> | null>(null) as Ref<NestedTree<TItem> | null>\n\n  const cloneTree = (t: NestedTree<TItem>): NestedTree<TItem> => cloneDeep(t)\n\n  const captureBaseline = (t: NestedTree<TItem>) => {\n    const hashes = new Map<ListEditorKey, string>()\n    const parents = new Map<ListEditorKey, ListEditorKey | null>()\n    const walk = (nodes: NestedTreeNode<TItem>[], parentKey: ListEditorKey | null) => {\n      for (const n of nodes) {\n        const key = keyOf(n.data)\n        hashes.set(key, normalize(n.data))\n        parents.set(key, parentKey)\n        if (n.children && n.children.length) walk(n.children, key)\n      }\n    }\n    walk(t.children, null)\n    baselineHashes.value = hashes\n    baselineParents.value = parents\n    baselineTree.value = cloneTree(t)\n  }\n  captureBaseline(options.get())\n  // Re-hash when the excluded-field set changes; `sync` so baseline + live\n  // normalize() never disagree mid-flush. (Mirrors the flat controller.)\n  watch(\n    dirtyExclude,\n    () => {\n      if (!baselineTree.value) return\n      const hashes = new Map<ListEditorKey, string>()\n      walkNodes(baselineTree.value, (n) => hashes.set(keyOf(n.data), normalize(n.data)))\n      baselineHashes.value = hashes\n    },\n    { flush: 'sync' }\n  )\n\n  const submitted = ref(false)\n  // Reactive so a row form (re)registering its validity re-runs invalidKeys/rowState.\n  const registeredValidity = reactive(new Map<ListEditorKey, () => boolean>())\n\n  // Amber = added OR content-edited OR reparented (vs baseline). Position is\n  // excluded, so a displaced sibling's pure renumber is NOT amber (matches the flat\n  // editor + the \"only the actively-moved subtree lights up\" UX); BUG-13 adds the\n  // parent-changed signal so a reparent registers even at an unchanged position\n  // number. `getChanges().moved` reads meta.dirty, so displaced siblings' new\n  // positions are still persisted; `hasPendingMove` (below) feeds the leave guard.\n  const isItemDirty = (node: NestedTreeNode<TItem>, key: ListEditorKey, parentKey: ListEditorKey | null): boolean => {\n    if (options.isDirty) {\n      const saved = baselineTreeRow(key)\n      return options.isDirty(node.data, saved)\n    }\n    const baseHash = baselineHashes.value.get(key)\n    if (baseHash === undefined) return true // added\n    if (baseHash !== normalize(node.data)) return true // content-edited (pos/parent excluded)\n    // Reparented vs baseline (BUG-13).\n    if (baselineParents.value.has(key)) {\n      const baseParent = baselineParents.value.get(key) ?? null\n      if ((baseParent ?? null) !== (parentKey ?? null)) return true\n    }\n    return false\n  }\n\n  // `addedBaseline` = first-seen content hash of each ADDED node; `editedKeys` = STICKY set of\n  // nodes whose content has since diverged. Gates the validation rail on \"has this row been edited\"\n  // rather than just \"is it unsaved\" (sticky like vuelidate `$dirty`) — mirrors the flat controller.\n  const addedBaseline = ref(new Map<ListEditorKey, string>()) as Ref<Map<ListEditorKey, string>>\n  const editedKeys = ref(new Set<ListEditorKey>()) as Ref<Set<ListEditorKey>>\n  // Deferred-deletion tombstones (baseline keys removed but not yet saved). Immediate deletes skip\n  // this so they don't read as unsaved. Drives hasUnsaved / unsavedCount / getChanges().deleted.\n  const deletedKeys = ref(new Set<ListEditorKey>()) as Ref<Set<ListEditorKey>>\n  watch(\n    () => options.get(),\n    (tree) => {\n      const live = new Set<ListEditorKey>()\n      walkNodes(tree, (n) => {\n        const key = keyOf(n.data)\n        live.add(key)\n        if (!baselineHashes.value.has(key) && !addedBaseline.value.has(key)) {\n          addedBaseline.value.set(key, normalize(n.data))\n        }\n        if (!editedKeys.value.has(key)) {\n          const base = baselineHashes.value.get(key) ?? addedBaseline.value.get(key)\n          if (base !== undefined && base !== normalize(n.data)) editedKeys.value.add(key)\n        }\n      })\n      const stale: ListEditorKey[] = []\n      for (const key of addedBaseline.value.keys()) if (!live.has(key)) stale.push(key)\n      for (const key of stale) addedBaseline.value.delete(key)\n      // A tombstoned key that becomes live again (re-add before save) drops its tombstone.\n      const revived: ListEditorKey[] = []\n      for (const key of deletedKeys.value) if (live.has(key)) revived.push(key)\n      for (const key of revived) deletedKeys.value.delete(key)\n    },\n    { immediate: true, deep: true }\n  )\n\n  const isRowEdited = (key: ListEditorKey): boolean => editedKeys.value.has(key)\n\n  const baselineTreeRow = (key: ListEditorKey): TItem | undefined => {\n    if (!baselineTree.value) return undefined\n    let hit: TItem | undefined\n    walkNodes(baselineTree.value, (n) => {\n      if (hit === undefined && keyOf(n.data) === key) hit = n.data\n    })\n    return hit\n  }\n\n  const treeHasKey = (key: ListEditorKey): boolean => {\n    let found = false\n    walkNodes(options.get(), (n) => {\n      if (!found && keyOf(n.data) === key) found = true\n    })\n    return found\n  }\n\n  const unsavedKeys = computed<Set<ListEditorKey>>(() => {\n    const out = new Set<ListEditorKey>()\n    const walk = (nodes: NestedTreeNode<TItem>[], parentKey: ListEditorKey | null) => {\n      for (const n of nodes) {\n        const key = keyOf(n.data)\n        if (isItemDirty(n, key, parentKey)) out.add(key)\n        if (n.children && n.children.length) walk(n.children, key)\n      }\n    }\n    walk(options.get().children, null)\n    return out\n  })\n\n  const isUnsaved = (key: ListEditorKey): boolean => unsavedKeys.value.has(key)\n  // A pure position reorder sets meta.dirty (recalculateSiblings) but is deliberately\n  // kept OUT of per-row amber (only the actively-moved subtree lights up). It IS a\n  // pending change though, so it must arm the leave guard — surface it as an aggregate\n  // signal (M2b) that survives Apply and clears on commit (which resets meta.dirty).\n  const hasPendingMove = computed<boolean>(() => {\n    let found = false\n    walkNodes(options.get(), (n) => {\n      if (n.meta.dirty) found = true\n    })\n    return found\n  })\n  const hasUnsaved = computed<boolean>(\n    () => unsavedKeys.value.size > 0 || deletedKeys.value.size > 0 || hasPendingMove.value\n  )\n  // Distinct unconfirmed changes = union of live dirty keys (added/edited/moved/reparented) and\n  // deferred-deletion tombstones. Drives the \"N unconfirmed changes\" indicator.\n  const unsavedCount = computed<number>(() => {\n    const keys = new Set<ListEditorKey>(unsavedKeys.value)\n    for (const key of deletedKeys.value) keys.add(key)\n    return keys.size\n  })\n\n  const resolveValidity = (item: TItem, key: ListEditorKey): { invalid: boolean; warning: boolean } => {\n    const registered = registeredValidity.get(key)\n    if (registered) return { invalid: !registered(), warning: false }\n    if (!options.validate) return { invalid: false, warning: false }\n    const r = options.validate(item)\n    if (typeof r === 'boolean') return { invalid: !r, warning: false }\n    return { invalid: !r.valid, warning: r.valid && r.state === 'warning' }\n  }\n\n  const invalidKeys = computed<Set<ListEditorKey>>(() => {\n    const out = new Set<ListEditorKey>()\n    walkNodes(options.get(), (n) => {\n      const key = keyOf(n.data)\n      if (resolveValidity(n.data, key).invalid) out.add(key)\n    })\n    return out\n  })\n  const hasErrors = computed<boolean>(() => invalidKeys.value.size > 0)\n\n  // Red rail for an invalid row that has been edited, is unsaved (added), or after a save attempt —\n  // mirrors the flat controller. The editor suppresses the red while the row is the one being edited,\n  // so a still-being-filled row reads amber and only goes red once collapsed. (QA 85050 batch 7)\n  const rowState = (item: TItem, key: ListEditorKey, editing = false): ListEditorValidationState => {\n    const { invalid, warning } = resolveValidity(item, key)\n    // See flat controller: red when edited/unsaved/submitted, amber while being filled, red once\n    // collapsed; a save attempt (`submitted`) reds it even while open. (QA 85050 batch 7)\n    if (invalid) {\n      if (submitted.value) return 'invalid'\n      if (editing) return null\n      return isRowEdited(key) || isUnsaved(key) ? 'invalid' : null\n    }\n    if (warning) return 'warning'\n    return null\n  }\n\n  const validateAll = (): boolean => {\n    submitted.value = true\n    return invalidKeys.value.size === 0\n  }\n\n  // Flattened ordered payload; parent key is resolved from tree structure (so a\n  // reparent is reflected even if the node's own parent field lagged).\n  const buildPayload = (): TItem[] => {\n    const out: TItem[] = []\n    const walk = (nodes: NestedTreeNode<TItem>[], parentKey: ListEditorKey | null) => {\n      for (const n of nodes) {\n        const row = { ...n.data } as TItem\n        ;(row as Record<string, unknown>)[parentField] = parentKey\n        out.push(row)\n        if (n.children && n.children.length) walk(n.children, keyOf(n.data))\n      }\n    }\n    walk(options.get().children, null)\n    return out\n  }\n\n  const getPayload = (): TItem[] => (options.payload ? options.payload(buildPayload()) : buildPayload())\n\n  const getChanges = (): NestedListEditorChanges<TItem> => {\n    const added: TItem[] = []\n    const updated: TItem[] = []\n    const moved: TItem[] = []\n    const reparented: TItem[] = []\n    const payload = buildPayload()\n    const byKey = new Map<ListEditorKey, TItem>()\n    for (const row of payload) byKey.set(keyOf(row), row)\n\n    walkNodes(options.get(), (n) => {\n      const key = keyOf(n.data)\n      const row = byKey.get(key) ?? n.data\n      const baseHash = baselineHashes.value.get(key)\n      if (baseHash === undefined) {\n        added.push(row)\n      } else if (baseHash !== normalize(n.data)) {\n        updated.push(row)\n      }\n      // meta.dirty without a content change => a move/reparent (position/parent\n      // changed). recalculateSiblings + BUG-13 set meta.dirty on those.\n      if (baseHash !== undefined && n.meta.dirty && baseHash === normalize(n.data)) {\n        moved.push(row)\n      }\n      // Reparented = parent key differs from baseline (subset of moved, but\n      // surfaced separately for partial-multi saves that re-link parents).\n      if (baselineParents.value.has(key)) {\n        const baseParent = baselineParents.value.get(key) ?? null\n        const nowParent = (row as Record<string, unknown>)[parentField] as ListEditorKey | null\n        if ((baseParent ?? null) !== (nowParent ?? null)) reparented.push(row)\n      }\n    })\n\n    // Deferred deletions come from the tombstone set, so an IMMEDIATE delete (already persisted on the\n    // backend, no tombstone) does not re-appear here as a local deleted change.\n    const deleted: TItem[] = []\n    for (const key of deletedKeys.value) {\n      const row = baselineTreeRow(key)\n      if (row !== undefined) deleted.push(row)\n    }\n    return { added, updated, moved, deleted, reparented }\n  }\n\n  const commit = (saved?: NestedTree<TItem>): void => {\n    const source = saved ?? options.get()\n    const normalized = options.normalizeSaved ? options.normalizeSaved(source) : source\n    // Backfill missing keys + clear meta.dirty on the committed tree.\n    const next = cloneTree(normalized)\n    walkNodes(next, (n) => {\n      const previous = baselineTreeRow(keyOf(n.data))\n      const resolvedKey = options.commitKey ? options.commitKey(n.data, previous) : keyOf(n.data)\n      if (resolvedKey === undefined || resolvedKey === null) {\n        if (keyField) (n.data as Record<string, unknown>)[keyFieldName] = nextListEditorTempId()\n      }\n      n.meta.dirty = false\n    })\n    options.set(next)\n    captureBaseline(next)\n    addedBaseline.value = new Map()\n    editedKeys.value = new Set()\n    deletedKeys.value = new Set()\n    submitted.value = false\n  }\n\n  // The saved tree is updated too, because `reset()` and `getChanges().deleted` read it.\n  // An accepted row takes its current data and place there. An accepted key no longer in the tree leaves it.\n  const acceptRows = (keys: ListEditorKey[]): void => {\n    if (keys.length === 0) return\n    const wanted = new Set(keys)\n    const next = cloneTree(options.get())\n    const hashes = new Map(baselineHashes.value)\n    const parents = new Map(baselineParents.value)\n    const base: NestedTree<TItem> = baselineTree.value ? cloneTree(baselineTree.value) : { ...next, children: [] }\n    type Detached = { node: NestedTreeNode<TItem>; siblings: NestedTreeNode<TItem>[]; index: number }\n    const detach = (nodes: NestedTreeNode<TItem>[], key: ListEditorKey): Detached | undefined => {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i]!\n        if (keyOf(node.data) === key) return { node: nodes.splice(i, 1)[0]!, siblings: nodes, index: i }\n        const found = node.children?.length ? detach(node.children, key) : undefined\n        if (found) return found\n      }\n      return undefined\n    }\n    const baseSiblings = (parentKey: ListEditorKey | null): NestedTreeNode<TItem>[] | undefined => {\n      if (parentKey === null) return base.children\n      let hit: NestedTreeNode<TItem> | undefined\n      walkNodes(base, (n) => {\n        if (hit === undefined && keyOf(n.data) === parentKey) hit = n\n      })\n      if (!hit) return undefined\n      if (!hit.children) hit.children = []\n      return hit.children\n    }\n    const live = new Set<ListEditorKey>()\n    const walk = (nodes: NestedTreeNode<TItem>[], parentKey: ListEditorKey | null) => {\n      nodes.forEach((n, index) => {\n        const key = keyOf(n.data)\n        live.add(key)\n        if (wanted.has(key)) {\n          hashes.set(key, normalize(n.data))\n          parents.set(key, parentKey)\n          n.meta.dirty = false\n          addedBaseline.value.delete(key)\n          editedKeys.value.delete(key)\n          const previous = detach(base.children, key)\n          const saved = cloneDeep(n)\n          // A row added without children allowed stays without them; a saved row keeps its saved children.\n          saved.children = previous ? previous.node.children : n.children ? [] : undefined\n          saved.meta = { ...saved.meta, dirty: false }\n          const siblings = baseSiblings(parentKey)\n          if (!siblings) {\n            // The new parent is not in the saved tree, e.g. it was this row's own saved child detached with it.\n            // Keep the row at its saved place rather than drop it and its children.\n            if (previous) previous.siblings.splice(previous.index, 0, saved)\n          } else {\n            // Insert after the nearest preceding sibling the saved tree knows, so pending rows do not skew the index.\n            let at = 0\n            for (let i = index - 1; i >= 0; i--) {\n              const seen = siblings.findIndex((s) => keyOf(s.data) === keyOf(nodes[i]!.data))\n              if (seen !== -1) {\n                at = seen + 1\n                break\n              }\n            }\n            siblings.splice(at, 0, saved)\n          }\n        }\n        if (n.children && n.children.length) walk(n.children, key)\n      })\n    }\n    walk(next.children, null)\n    for (const key of wanted) {\n      if (live.has(key)) continue\n      hashes.delete(key)\n      parents.delete(key)\n      // Gone from the backend: no longer a pending deletion either.\n      deletedKeys.value.delete(key)\n      detach(base.children, key)\n    }\n    baselineHashes.value = hashes\n    baselineParents.value = parents\n    baselineTree.value = base\n    options.set(next)\n  }\n\n  const reset = (t?: NestedTree<TItem>): void => {\n    const restore = t ?? (baselineTree.value ? cloneTree(baselineTree.value) : options.get())\n    options.set(restore)\n    addedBaseline.value = new Map()\n    editedKeys.value = new Set()\n    deletedKeys.value = new Set()\n    submitted.value = false\n  }\n\n  // --- Tree mutations (delegate to useNestedListEditor) -----------------------\n\n  const addItem = (item?: TItem, hint?: NestedPositionHint): void => {\n    const data = item ?? options.factory?.()\n    if (data === undefined) return // no item + no factory (read-only) → no-op\n    tree.addItem(data, hint)\n  }\n  const addAfter = (afterKey: ListEditorKey, item?: TItem, childrenAllowed = true): void => {\n    const data = item ?? options.factory?.()\n    if (data === undefined) return\n    tree.addItem(data, { afterId: afterKey, childrenAllowed })\n  }\n  const addChild = (parentKey: ListEditorKey, item?: TItem, childrenAllowed = true): void => {\n    const data = item ?? options.factory?.()\n    if (data === undefined) return\n    tree.addItem(data, { parentId: parentKey, childrenAllowed })\n  }\n  const updateItem = (key: ListEditorKey, data: TItem, markDirty = true): void => {\n    tree.updateItem(key, data, markDirty)\n  }\n  // Immediate delete: the row is gone on the backend and the editor removes it with its subtree.\n  // So neither stays in the saved tree that `reset()` restores.\n  const dropFromBaseline = (key: ListEditorKey): void => {\n    if (!baselineTree.value) return\n    const base = cloneTree(baselineTree.value)\n    const detach = (nodes: NestedTreeNode<TItem>[]): NestedTreeNode<TItem> | undefined => {\n      for (let i = 0; i < nodes.length; i++) {\n        if (keyOf(nodes[i]!.data) === key) return nodes.splice(i, 1)[0]\n        const found = nodes[i]!.children?.length ? detach(nodes[i]!.children!) : undefined\n        if (found) return found\n      }\n      return undefined\n    }\n    const removed = detach(base.children)\n    if (!removed) return\n    const hashes = new Map(baselineHashes.value)\n    const parents = new Map(baselineParents.value)\n    walkNodes({ ...base, children: [removed] }, (n) => {\n      hashes.delete(keyOf(n.data))\n      parents.delete(keyOf(n.data))\n    })\n    baselineHashes.value = hashes\n    baselineParents.value = parents\n    baselineTree.value = base\n  }\n\n  const deleteItem = (key: ListEditorKey, opts?: { trackDeleted?: boolean; renumber?: boolean }): void => {\n    // A saved row removed in deferred mode is tombstoned: it counts as unsaved and appears in `getChanges().deleted`.\n    // `trackDeleted: false` (immediate, already deleted on the backend) skips this.\n    // `treeHasKey` prevents a phantom tombstone when a consumer calls\n    // `deleteItem` again for a row the component already removed.\n    if (baselineHashes.value.has(key) && opts?.trackDeleted !== false && treeHasKey(key)) {\n      deletedKeys.value.add(key)\n    } else if (baselineHashes.value.has(key) && treeHasKey(key)) {\n      dropFromBaseline(key)\n    }\n    tree.deleteItem(key, { renumber: opts?.renumber })\n  }\n\n  const restoreDeleted = (key: ListEditorKey): void => {\n    deletedKeys.value.delete(key)\n  }\n  const moveUp = (key: ListEditorKey): boolean => tree.moveUp(key) !== null\n  const moveDown = (key: ListEditorKey): boolean => tree.moveDown(key) !== null\n  const moveTop = (key: ListEditorKey): boolean => tree.moveTop(key) !== null\n  const moveBottom = (key: ListEditorKey): boolean => tree.moveBottom(key) !== null\n  const indent = (key: ListEditorKey): boolean => tree.indent(key) !== null\n  const outdent = (key: ListEditorKey): boolean => tree.outdent(key) !== null\n  const moveTo = (key: ListEditorKey, targetParentKey: ListEditorKey | null, targetIndex: number): boolean =>\n    tree.moveTo(key, targetParentKey, targetIndex) !== null\n  const recalculatePositions = (): void => {\n    options.set(tree.recalculatePositions(options.get()))\n  }\n\n  const registerValidity = (key: ListEditorKey, isValid: () => boolean): (() => void) => {\n    registeredValidity.set(key, isValid)\n    return () => registeredValidity.delete(key)\n  }\n\n  return {\n    items,\n    viewItems,\n    hasUnsaved,\n    unsavedCount,\n    hasErrors,\n    invalidKeys,\n    isUnsaved,\n    rowState,\n    validateAll,\n    getPayload,\n    getChanges,\n    commit,\n    acceptRows,\n    reset,\n    addItem,\n    addAfter,\n    addChild,\n    updateItem,\n    deleteItem,\n    restoreDeleted,\n    moveUp,\n    moveDown,\n    moveTop,\n    moveBottom,\n    indent,\n    outdent,\n    moveTo,\n    recalculatePositions,\n    registerValidity,\n    findNode: tree.findNode,\n    calculateSubtreeDepth: tree.calculateSubtreeDepth,\n  }\n}\n"],"mappings":"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"}

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

@@ -1,5 +1,5 @@
 import { computed as e, ref as t, watch as n } from "vue";
-//#region src/domains/listEditor/composables/useReorderMode.ts
+// src/domains/listEditor/composables/useReorderMode.ts
 var r = Symbol("le.sharedReorderRegistry");
 function i(r) {
 	let i = t(!1), a = t(null), o = e(() => r.mode.value === "reorder"), s = e(() => r.movedKeys.value.size), c = e(() => s.value > 0), l = () => r.clonePayload ? r.clonePayload(r.modelValue.value) : r.cloneModel(r.modelValue.value), u = () => r.embedded?.value === !0;
@@ -34,7 +34,6 @@ function i(r) {
 		}
 	};
 }
-//#endregion
 export { r as SharedReorderRegistryKey, i as useReorderMode };
 
 //# sourceMappingURL=useReorderMode.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useReorderMode.js","names":["SharedReorderRegistryKey","useReorderMode","applying","ref","applyError","reorderMode","computed","options","movedCount","hasPendingChanges","clonePayload","isEmbedded","watch","newMode","oldMode","payload","err"],"sources":["../../../../src/domains/listEditor/composables/useReorderMode.ts"],"sourcesContent":["import { computed, ref, watch, type ComputedRef, type InjectionKey, type Ref } from 'vue'\nimport type { ListEditorKey } from '@/domains/listEditor/types/listEditorTypes'\n\n// Registry that lets embedded inner editors push their reorder pending-count\n// up to the nearest non-embedded outer editor. The outer's reorder toolbar\n// status (\"N pending changes\") then reflects child moves too — so toggling\n// the order of an answer inside a question increments the outer's counter\n// just like a question move would.\nexport interface SharedReorderRegistry {\n  register: (\n    id: symbol,\n    movedCount: ComputedRef<number>,\n    hasPendingChanges: ComputedRef<boolean>,\n    validateAll: () => boolean\n  ) => void\n  unregister: (id: symbol) => void\n}\n\nexport const SharedReorderRegistryKey = Symbol('le.sharedReorderRegistry') as InjectionKey<SharedReorderRegistry>\n\nexport type ReorderModeValue = 'view' | 'reorder'\n\nexport interface UseReorderModeEmit<T> {\n  reorderStart: () => void\n  reorderCancel: () => void\n  reorderApplied: (payload: T) => void\n  reorderApplyError: (err: unknown) => void\n  reorderEnd: () => void\n}\n\nexport interface UseReorderModeOptions<T> {\n  /**\n   * v-model-backed mode ref — the composable reads + writes, but the\n   * component owns the `defineModel('mode', ...)` so external\n   * `v-model:mode` bindings still flow. Passing the ref in avoids\n   * duplicating the defineModel contract inside the composable.\n   */\n  mode: Ref<ReorderModeValue>\n  /**\n   * Reorder snapshot — cloned on enter, restored on cancel, cleared on\n   * apply. Stays at component level (the dirty-baseline needs to read it\n   * indirectly too), but the composable owns every assignment.\n   */\n  snapshot: Ref<T | null>\n  /**\n   * Keys the user has actively moved this session (drag, arrow buttons,\n   * indent/outdent). Cleared on every mode transition. Stays at component\n   * level because the per-row decorator reads it for the `moved` flag.\n   */\n  movedKeys: Ref<Set<ListEditorKey>>\n  modelValue: Ref<T>\n  /**\n   * Deep-clone the model value for snapshotting. Caller-provided because\n   * the nested tree shape and flat array shape need different serializer\n   * handling (both use `cloneDeep` in practice, but the callsite already\n   * imports it).\n   */\n  cloneModel: (m: T) => T\n  applyModel: (m: T) => void\n  canEnterReorder: ComputedRef<boolean>\n  /**\n   * Hook run after mode flips to `reorder` but before emit — nested uses\n   * this to expand every branch + init sortable instances, flat uses it\n   * (via nothing — the sortable initialises lazily via a watch in the\n   * flat variant). Left optional.\n   */\n  onEnter?: () => void\n  /**\n   * Hook run after mode flips back to `view` on cancel — nested destroys\n   * its sortable instances here. Flat doesn't need it.\n   */\n  onCancel?: () => void\n  /**\n   * Hook run after apply succeeds — nested destroys its sortable instances\n   * here. Flat doesn't need it.\n   */\n  onApplyEnd?: () => void\n  /**\n   * Called from the mode watcher when mode flips externally from `view` to\n   * `reorder` (e.g. v-model:mode bound by the parent) — each variant uses\n   * this to clear variant-specific caches that `enterReorderMode` itself\n   * also clears via its own call-site. The flat variant clears editing +\n   * expanded; nested clears editing only (children-expanded stays).\n   */\n  onExternalEnter?: () => void\n  /**\n   * Called from the mode watcher when an EMBEDDED editor flips externally from\n   * `reorder` back to `view` (its parent's Cancel or Apply). Embedded editors\n   * have no own snapshot/apply/cancel, so this is their only exit hook — the\n   * flat variant uses it to reconcile immediate (backend) deletes made during\n   * the session: on a parent Cancel the parent's snapshot restore resurrects\n   * the deleted row, which must be re-removed; on Apply it stayed gone (no-op).\n   */\n  onEmbeddedExit?: () => void\n  /**\n   * Async persist callback wired from the parent — identical semantics to\n   * the old `props.onReorderApply`. Receives the cloned payload (array for\n   * flat, tree for nested); throwing surfaces the error in the header\n   * toolbar via `applyError`.\n   */\n  onReorderApply?: (payload: T) => Promise<void> | void\n  /**\n   * Optional override for the payload passed to `onReorderApply` + the\n   * `reorder-applied` emit — defaults to `cloneModel(modelValue)`. Exists\n   * so consumers could send a different shape than their stored snapshot\n   * if the need arises; both current callers use the default.\n   */\n  clonePayload?: (m: T) => T\n  /**\n   * Embedded mode — the editor follows external mode changes but does NOT\n   * own a snapshot or apply/cancel logic. The parent (a non-embedded outer\n   * editor) takes a deep snapshot covering this editor's data too, so cancel\n   * at the top restores everything. Used for the \"shared reorder\" pattern\n   * where a single Reorder button drives multiple stacked editors.\n   */\n  embedded?: ComputedRef<boolean> | Ref<boolean>\n  emit: UseReorderModeEmit<T>\n}\n\nexport interface UseReorderModeApi {\n  applying: Ref<boolean>\n  applyError: Ref<string | null>\n  hasPendingChanges: ComputedRef<boolean>\n  movedCount: ComputedRef<number>\n  reorderMode: ComputedRef<boolean>\n  enterReorderMode: () => void\n  cancelReorderMode: () => void\n  applyReorder: () => Promise<void>\n}\n\n/**\n * Reorder-mode state machine shared between ASortableListEditor and\n * ANestedSortableListEditor. Owns the `applying` + `applyError` flags, the\n * pending-changes counters, and the enter / cancel / apply transitions —\n * plus the mode watcher that fires when the v-model:mode flips externally.\n *\n * The snapshot and `movedKeys` sets stay at component level because the\n * per-row decorator + dirty-baseline read them directly; the composable\n * takes them as refs so it can still drive the state machine.\n */\nexport function useReorderMode<T>(options: UseReorderModeOptions<T>): UseReorderModeApi {\n  const applying = ref(false)\n  const applyError = ref<string | null>(null)\n\n  const reorderMode = computed(() => options.mode.value === 'reorder')\n  const movedCount = computed(() => options.movedKeys.value.size)\n  const hasPendingChanges = computed(() => movedCount.value > 0)\n\n  const clonePayload = (): T =>\n    options.clonePayload ? options.clonePayload(options.modelValue.value) : options.cloneModel(options.modelValue.value)\n\n  const isEmbedded = (): boolean => options.embedded?.value === true\n\n  const enterReorderMode = () => {\n    if (!options.canEnterReorder.value || reorderMode.value) return\n    if (!isEmbedded()) {\n      options.snapshot.value = options.cloneModel(options.modelValue.value)\n    }\n    options.movedKeys.value = new Set()\n    applyError.value = null\n    options.mode.value = 'reorder'\n    options.onEnter?.()\n    options.emit.reorderStart()\n  }\n\n  const cancelReorderMode = () => {\n    if (!reorderMode.value || applying.value) return\n    if (!isEmbedded() && options.snapshot.value) {\n      options.applyModel(options.snapshot.value as T)\n    }\n    options.snapshot.value = null\n    options.movedKeys.value = new Set()\n    applyError.value = null\n    applying.value = false\n    options.mode.value = 'view'\n    options.onCancel?.()\n    options.emit.reorderCancel()\n    options.emit.reorderEnd()\n  }\n\n  const applyReorder = async () => {\n    if (!reorderMode.value) return\n    const payload = clonePayload()\n    applyError.value = null\n    if (!isEmbedded() && options.onReorderApply) {\n      applying.value = true\n      try {\n        await options.onReorderApply(payload)\n      } catch (err) {\n        applying.value = false\n        applyError.value = err instanceof Error ? err.message : String(err)\n        options.emit.reorderApplyError(err)\n        return\n      }\n      applying.value = false\n    }\n    // Deliberately keep `movedKeys` populated — consumer still has to persist\n    // the new order via their own API call before rows are truly \"saved\"; we\n    // let them clear the state via `commit()` on success.\n    options.snapshot.value = null\n    options.mode.value = 'view'\n    options.onApplyEnd?.()\n    options.emit.reorderApplied(payload)\n    options.emit.reorderEnd()\n  }\n\n  // Handle external mode flips (v-model:mode from a parent) — mirror the\n  // same bookkeeping enterReorderMode / cancelReorderMode do so the state\n  // stays consistent whether the transition came from a button click or a\n  // parent binding. Embedded editors do NOT take a snapshot; their parent\n  // (the outer non-embedded editor) owns one that covers nested data too.\n  //\n  // The view→reorder→view cleanup path differs between embedded and\n  // non-embedded:\n  //   - non-embedded cancel: snapshot is set → clear state here\n  //   - non-embedded apply: applyReorder nulls snapshot BEFORE flipping\n  //     mode, so the snapshot-guarded branch is skipped → movedKeys stays\n  //     populated until consumer calls commit() (the contract)\n  //   - embedded: no snapshot ever, clear state on every view transition\n  //     so the inner editor's movedKeys doesn't outlive a parent\n  //     cancel/apply (otherwise rows would render as `unsaved` after the\n  //     parent restores the original data)\n  // Immediate: an editor mounted with mode already `reorder` needs the same snapshot, or Cancel keeps the moves.\n  watch(\n    options.mode,\n    (newMode, oldMode) => {\n      if (newMode === 'reorder' && oldMode !== 'reorder') {\n        if (!isEmbedded() && !options.snapshot.value) {\n          options.snapshot.value = options.cloneModel(options.modelValue.value)\n        }\n        options.movedKeys.value = new Set()\n        options.onExternalEnter?.()\n      }\n      if (newMode === 'view' && oldMode === 'reorder') {\n        if (options.snapshot.value) {\n          options.snapshot.value = null\n          options.movedKeys.value = new Set()\n          applyError.value = null\n          applying.value = false\n        } else if (isEmbedded()) {\n          options.movedKeys.value = new Set()\n          applyError.value = null\n          applying.value = false\n          // Reconcile session immediate (backend) deletes: the parent has already flushed both props, so\n          // the model reflects a Cancel's snapshot-restore (deleted row resurrected → re-remove) or an\n          // Apply (row stayed gone → the re-remove is a no-op). Deferred deletes need nothing here.\n          options.onEmbeddedExit?.()\n        }\n      }\n    },\n    { immediate: true }\n  )\n\n  return {\n    applying,\n    applyError,\n    hasPendingChanges,\n    movedCount,\n    reorderMode,\n    enterReorderMode,\n    cancelReorderMode,\n    applyReorder,\n  }\n}\n"],"mappings":";;AAkBA,IAAaA,IAA2B,OAAO,0BAA0B;AA0HzE,SAAgBC,EAAkB,GAAsD;CACtF,IAAMC,IAAWC,EAAI,EAAK,GACpBC,IAAaD,EAAmB,IAAI,GAEpCE,IAAcC,QAAeC,EAAQ,KAAK,UAAU,SAAS,GAC7DC,IAAaF,QAAeC,EAAQ,UAAU,MAAM,IAAI,GACxDE,IAAoBH,QAAeE,EAAW,QAAQ,CAAC,GAEvDE,UACJH,EAAQ,eAAeA,EAAQ,aAAaA,EAAQ,WAAW,KAAK,IAAIA,EAAQ,WAAWA,EAAQ,WAAW,KAAK,GAE/GI,UAA4BJ,EAAQ,UAAU,UAAU;CAsG9D,OA9BAK,EACEL,EAAQ,OACP,GAAS,MAAY;EAQpB,AAPIM,MAAY,aAAaC,MAAY,cACnC,CAACH,EAAW,KAAK,CAACJ,EAAQ,SAAS,UACrC,EAAQ,SAAS,QAAQA,EAAQ,WAAWA,EAAQ,WAAW,KAAK,IAEtE,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClCA,EAAQ,kBAAkB,IAExBM,MAAY,UAAUC,MAAY,cAChCP,EAAQ,SAAS,SACnB,EAAQ,SAAS,QAAQ,MACzB,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClC,EAAW,QAAQ,MACnB,EAAS,QAAQ,MACRI,EAAW,MACpB,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClC,EAAW,QAAQ,MACnB,EAAS,QAAQ,IAIjBJ,EAAQ,iBAAiB;CAG/B,GACA,EAAE,WAAW,GAAK,CACpB,GAEO;EACL;EACA;EACA;EACA;EACA;EACA,wBA1G6B;GAC7B,AAAKA,EAAQ,gBAAgB,SAAS,GAAY,UAC7CI,EAAW,MACd,EAAQ,SAAS,QAAQJ,EAAQ,WAAWA,EAAQ,WAAW,KAAK,IAEtE,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClC,EAAW,QAAQ,MACnB,EAAQ,KAAK,QAAQ,WACrBA,EAAQ,UAAU,GAClBA,EAAQ,KAAK,aAAa;EAC5B;EAiGE,yBA/F8B;GAC9B,AAAKF,EAAY,SAAS,GAAS,UAC/B,CAACM,EAAW,KAAKJ,EAAQ,SAAS,SACpCA,EAAQ,WAAWA,EAAQ,SAAS,KAAU,GAEhD,EAAQ,SAAS,QAAQ,MACzB,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClC,EAAW,QAAQ,MACnB,EAAS,QAAQ,IACjB,EAAQ,KAAK,QAAQ,QACrBA,EAAQ,WAAW,GACnBA,EAAQ,KAAK,cAAc,GAC3BA,EAAQ,KAAK,WAAW;EAC1B;EAmFE,0BAjF+B;GAC/B,IAAI,CAACF,EAAY,OAAO;GACxB,IAAMU,IAAUL,EAAa;GAE7B,IADA,EAAW,QAAQ,MACf,CAACC,EAAW,KAAKJ,EAAQ,gBAAgB;IAC3C,EAAS,QAAQ;IACjB,IAAI;KACF,MAAMA,EAAQ,eAAeQ,CAAO;IACtC,SAASC,GAAK;KAGZ,AAFA,EAAS,QAAQ,IACjB,EAAW,QAAQA,aAAe,QAAQA,EAAI,UAAU,OAAOA,CAAG,GAClET,EAAQ,KAAK,kBAAkBS,CAAG;KAClC;IACF;IACA,EAAS,QAAQ;GACnB;GAQA,AAJA,EAAQ,SAAS,QAAQ,MACzB,EAAQ,KAAK,QAAQ,QACrBT,EAAQ,aAAa,GACrBA,EAAQ,KAAK,eAAeQ,CAAO,GACnCR,EAAQ,KAAK,WAAW;EAC1B;CA0DA;AACF"}
+{"version":3,"file":"useReorderMode.js","names":["SharedReorderRegistryKey","useReorderMode","applying","ref","applyError","reorderMode","computed","options","movedCount","hasPendingChanges","clonePayload","isEmbedded","watch","newMode","oldMode","payload","err"],"sources":["../../../../src/domains/listEditor/composables/useReorderMode.ts"],"sourcesContent":["import { computed, ref, watch, type ComputedRef, type InjectionKey, type Ref } from 'vue'\nimport type { ListEditorKey } from '@/domains/listEditor/types/listEditorTypes'\n\n// Registry that lets embedded inner editors push their reorder pending-count\n// up to the nearest non-embedded outer editor. The outer's reorder toolbar\n// status (\"N pending changes\") then reflects child moves too — so toggling\n// the order of an answer inside a question increments the outer's counter\n// just like a question move would.\nexport interface SharedReorderRegistry {\n  register: (\n    id: symbol,\n    movedCount: ComputedRef<number>,\n    hasPendingChanges: ComputedRef<boolean>,\n    validateAll: () => boolean\n  ) => void\n  unregister: (id: symbol) => void\n}\n\nexport const SharedReorderRegistryKey = Symbol('le.sharedReorderRegistry') as InjectionKey<SharedReorderRegistry>\n\nexport type ReorderModeValue = 'view' | 'reorder'\n\nexport interface UseReorderModeEmit<T> {\n  reorderStart: () => void\n  reorderCancel: () => void\n  reorderApplied: (payload: T) => void\n  reorderApplyError: (err: unknown) => void\n  reorderEnd: () => void\n}\n\nexport interface UseReorderModeOptions<T> {\n  /**\n   * v-model-backed mode ref — the composable reads + writes, but the\n   * component owns the `defineModel('mode', ...)` so external\n   * `v-model:mode` bindings still flow. Passing the ref in avoids\n   * duplicating the defineModel contract inside the composable.\n   */\n  mode: Ref<ReorderModeValue>\n  /**\n   * Reorder snapshot — cloned on enter, restored on cancel, cleared on\n   * apply. Stays at component level (the dirty-baseline needs to read it\n   * indirectly too), but the composable owns every assignment.\n   */\n  snapshot: Ref<T | null>\n  /**\n   * Keys the user has actively moved this session (drag, arrow buttons,\n   * indent/outdent). Cleared on every mode transition. Stays at component\n   * level because the per-row decorator reads it for the `moved` flag.\n   */\n  movedKeys: Ref<Set<ListEditorKey>>\n  modelValue: Ref<T>\n  /**\n   * Deep-clone the model value for snapshotting. Caller-provided because\n   * the nested tree shape and flat array shape need different serializer\n   * handling (both use `cloneDeep` in practice, but the callsite already\n   * imports it).\n   */\n  cloneModel: (m: T) => T\n  applyModel: (m: T) => void\n  canEnterReorder: ComputedRef<boolean>\n  /**\n   * Hook run after mode flips to `reorder` but before emit — nested uses\n   * this to expand every branch + init sortable instances, flat uses it\n   * (via nothing — the sortable initialises lazily via a watch in the\n   * flat variant). Left optional.\n   */\n  onEnter?: () => void\n  /**\n   * Hook run after mode flips back to `view` on cancel — nested destroys\n   * its sortable instances here. Flat doesn't need it.\n   */\n  onCancel?: () => void\n  /**\n   * Hook run after apply succeeds — nested destroys its sortable instances\n   * here. Flat doesn't need it.\n   */\n  onApplyEnd?: () => void\n  /**\n   * Called from the mode watcher when mode flips externally from `view` to\n   * `reorder` (e.g. v-model:mode bound by the parent) — each variant uses\n   * this to clear variant-specific caches that `enterReorderMode` itself\n   * also clears via its own call-site. The flat variant clears editing +\n   * expanded; nested clears editing only (children-expanded stays).\n   */\n  onExternalEnter?: () => void\n  /**\n   * Called from the mode watcher when an EMBEDDED editor flips externally from\n   * `reorder` back to `view` (its parent's Cancel or Apply). Embedded editors\n   * have no own snapshot/apply/cancel, so this is their only exit hook — the\n   * flat variant uses it to reconcile immediate (backend) deletes made during\n   * the session: on a parent Cancel the parent's snapshot restore resurrects\n   * the deleted row, which must be re-removed; on Apply it stayed gone (no-op).\n   */\n  onEmbeddedExit?: () => void\n  /**\n   * Async persist callback wired from the parent — identical semantics to\n   * the old `props.onReorderApply`. Receives the cloned payload (array for\n   * flat, tree for nested); throwing surfaces the error in the header\n   * toolbar via `applyError`.\n   */\n  onReorderApply?: (payload: T) => Promise<void> | void\n  /**\n   * Optional override for the payload passed to `onReorderApply` + the\n   * `reorder-applied` emit — defaults to `cloneModel(modelValue)`. Exists\n   * so consumers could send a different shape than their stored snapshot\n   * if the need arises; both current callers use the default.\n   */\n  clonePayload?: (m: T) => T\n  /**\n   * Embedded mode — the editor follows external mode changes but does NOT\n   * own a snapshot or apply/cancel logic. The parent (a non-embedded outer\n   * editor) takes a deep snapshot covering this editor's data too, so cancel\n   * at the top restores everything. Used for the \"shared reorder\" pattern\n   * where a single Reorder button drives multiple stacked editors.\n   */\n  embedded?: ComputedRef<boolean> | Ref<boolean>\n  emit: UseReorderModeEmit<T>\n}\n\nexport interface UseReorderModeApi {\n  applying: Ref<boolean>\n  applyError: Ref<string | null>\n  hasPendingChanges: ComputedRef<boolean>\n  movedCount: ComputedRef<number>\n  reorderMode: ComputedRef<boolean>\n  enterReorderMode: () => void\n  cancelReorderMode: () => void\n  applyReorder: () => Promise<void>\n}\n\n/**\n * Reorder-mode state machine shared between ASortableListEditor and\n * ANestedSortableListEditor. Owns the `applying` + `applyError` flags, the\n * pending-changes counters, and the enter / cancel / apply transitions —\n * plus the mode watcher that fires when the v-model:mode flips externally.\n *\n * The snapshot and `movedKeys` sets stay at component level because the\n * per-row decorator + dirty-baseline read them directly; the composable\n * takes them as refs so it can still drive the state machine.\n */\nexport function useReorderMode<T>(options: UseReorderModeOptions<T>): UseReorderModeApi {\n  const applying = ref(false)\n  const applyError = ref<string | null>(null)\n\n  const reorderMode = computed(() => options.mode.value === 'reorder')\n  const movedCount = computed(() => options.movedKeys.value.size)\n  const hasPendingChanges = computed(() => movedCount.value > 0)\n\n  const clonePayload = (): T =>\n    options.clonePayload ? options.clonePayload(options.modelValue.value) : options.cloneModel(options.modelValue.value)\n\n  const isEmbedded = (): boolean => options.embedded?.value === true\n\n  const enterReorderMode = () => {\n    if (!options.canEnterReorder.value || reorderMode.value) return\n    if (!isEmbedded()) {\n      options.snapshot.value = options.cloneModel(options.modelValue.value)\n    }\n    options.movedKeys.value = new Set()\n    applyError.value = null\n    options.mode.value = 'reorder'\n    options.onEnter?.()\n    options.emit.reorderStart()\n  }\n\n  const cancelReorderMode = () => {\n    if (!reorderMode.value || applying.value) return\n    if (!isEmbedded() && options.snapshot.value) {\n      options.applyModel(options.snapshot.value as T)\n    }\n    options.snapshot.value = null\n    options.movedKeys.value = new Set()\n    applyError.value = null\n    applying.value = false\n    options.mode.value = 'view'\n    options.onCancel?.()\n    options.emit.reorderCancel()\n    options.emit.reorderEnd()\n  }\n\n  const applyReorder = async () => {\n    if (!reorderMode.value) return\n    const payload = clonePayload()\n    applyError.value = null\n    if (!isEmbedded() && options.onReorderApply) {\n      applying.value = true\n      try {\n        await options.onReorderApply(payload)\n      } catch (err) {\n        applying.value = false\n        applyError.value = err instanceof Error ? err.message : String(err)\n        options.emit.reorderApplyError(err)\n        return\n      }\n      applying.value = false\n    }\n    // Keep `movedKeys` populated. The consumer still has to persist the new order with its own API call.\n    // It clears the state via `commit()` on success.\n    options.snapshot.value = null\n    options.mode.value = 'view'\n    options.onApplyEnd?.()\n    options.emit.reorderApplied(payload)\n    options.emit.reorderEnd()\n  }\n\n  // Handle mode flips from a parent `v-model:mode` with the same bookkeeping as enterReorderMode / cancelReorderMode.\n  // Embedded editors take no snapshot. The outer editor's snapshot covers nested data.\n  // Non-embedded: cancel has a snapshot and clears state here. `applyReorder`\n  // nulls the snapshot before the flip, so `movedKeys` stays until `commit()`.\n  // Embedded: clear state on every view transition, or rows show as `unsaved` after a parent cancel or\n  // apply. Immediate: an editor mounted in `reorder` needs the snapshot too, or Cancel keeps the moves.\n  watch(\n    options.mode,\n    (newMode, oldMode) => {\n      if (newMode === 'reorder' && oldMode !== 'reorder') {\n        if (!isEmbedded() && !options.snapshot.value) {\n          options.snapshot.value = options.cloneModel(options.modelValue.value)\n        }\n        options.movedKeys.value = new Set()\n        options.onExternalEnter?.()\n      }\n      if (newMode === 'view' && oldMode === 'reorder') {\n        if (options.snapshot.value) {\n          options.snapshot.value = null\n          options.movedKeys.value = new Set()\n          applyError.value = null\n          applying.value = false\n        } else if (isEmbedded()) {\n          options.movedKeys.value = new Set()\n          applyError.value = null\n          applying.value = false\n          // Reconcile immediate (backend) deletes from this session. The parent has already flushed both props.\n          // After Cancel the snapshot restore brings the deleted row back,\n          // so it is removed again. After Apply the removal is a no-op.\n          // Deferred deletes need nothing here.\n          options.onEmbeddedExit?.()\n        }\n      }\n    },\n    { immediate: true }\n  )\n\n  return {\n    applying,\n    applyError,\n    hasPendingChanges,\n    movedCount,\n    reorderMode,\n    enterReorderMode,\n    cancelReorderMode,\n    applyReorder,\n  }\n}\n"],"mappings":";;AAkBA,IAAaA,IAA2B,OAAO,0BAA0B;AA0HzE,SAAgBC,EAAkB,GAAsD;CACtF,IAAMC,IAAWC,EAAI,EAAK,GACpBC,IAAaD,EAAmB,IAAI,GAEpCE,IAAcC,QAAeC,EAAQ,KAAK,UAAU,SAAS,GAC7DC,IAAaF,QAAeC,EAAQ,UAAU,MAAM,IAAI,GACxDE,IAAoBH,QAAeE,EAAW,QAAQ,CAAC,GAEvDE,UACJH,EAAQ,eAAeA,EAAQ,aAAaA,EAAQ,WAAW,KAAK,IAAIA,EAAQ,WAAWA,EAAQ,WAAW,KAAK,GAE/GI,UAA4BJ,EAAQ,UAAU,UAAU;CA2F9D,OA/BAK,EACEL,EAAQ,OACP,GAAS,MAAY;EAQpB,AAPIM,MAAY,aAAaC,MAAY,cACnC,CAACH,EAAW,KAAK,CAACJ,EAAQ,SAAS,UACrC,EAAQ,SAAS,QAAQA,EAAQ,WAAWA,EAAQ,WAAW,KAAK,IAEtE,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClCA,EAAQ,kBAAkB,IAExBM,MAAY,UAAUC,MAAY,cAChCP,EAAQ,SAAS,SACnB,EAAQ,SAAS,QAAQ,MACzB,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClC,EAAW,QAAQ,MACnB,EAAS,QAAQ,MACRI,EAAW,MACpB,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClC,EAAW,QAAQ,MACnB,EAAS,QAAQ,IAKjBJ,EAAQ,iBAAiB;CAG/B,GACA,EAAE,WAAW,GAAK,CACpB,GAEO;EACL;EACA;EACA;EACA;EACA;EACA,wBA/F6B;GAC7B,AAAKA,EAAQ,gBAAgB,SAAS,GAAY,UAC7CI,EAAW,MACd,EAAQ,SAAS,QAAQJ,EAAQ,WAAWA,EAAQ,WAAW,KAAK,IAEtE,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClC,EAAW,QAAQ,MACnB,EAAQ,KAAK,QAAQ,WACrBA,EAAQ,UAAU,GAClBA,EAAQ,KAAK,aAAa;EAC5B;EAsFE,yBApF8B;GAC9B,AAAKF,EAAY,SAAS,GAAS,UAC/B,CAACM,EAAW,KAAKJ,EAAQ,SAAS,SACpCA,EAAQ,WAAWA,EAAQ,SAAS,KAAU,GAEhD,EAAQ,SAAS,QAAQ,MACzB,EAAQ,UAAU,wBAAQ,IAAI,IAAI,GAClC,EAAW,QAAQ,MACnB,EAAS,QAAQ,IACjB,EAAQ,KAAK,QAAQ,QACrBA,EAAQ,WAAW,GACnBA,EAAQ,KAAK,cAAc,GAC3BA,EAAQ,KAAK,WAAW;EAC1B;EAwEE,0BAtE+B;GAC/B,IAAI,CAACF,EAAY,OAAO;GACxB,IAAMU,IAAUL,EAAa;GAE7B,IADA,EAAW,QAAQ,MACf,CAACC,EAAW,KAAKJ,EAAQ,gBAAgB;IAC3C,EAAS,QAAQ;IACjB,IAAI;KACF,MAAMA,EAAQ,eAAeQ,CAAO;IACtC,SAASC,GAAK;KAGZ,AAFA,EAAS,QAAQ,IACjB,EAAW,QAAQA,aAAe,QAAQA,EAAI,UAAU,OAAOA,CAAG,GAClET,EAAQ,KAAK,kBAAkBS,CAAG;KAClC;IACF;IACA,EAAS,QAAQ;GACnB;GAOA,AAJA,EAAQ,SAAS,QAAQ,MACzB,EAAQ,KAAK,QAAQ,QACrBT,EAAQ,aAAa,GACrBA,EAAQ,KAAK,eAAeQ,CAAO,GACnCR,EAAQ,KAAK,WAAW;EAC1B;CAgDA;AACF"}

package/dist/domains/listEditor/types/listEditorTypes.d.ts

@@ -35,8 +35,8 @@ export interface NestedPositionHint {
     childrenAllowed?: boolean;
 }
 /**
- * A tree node of any record shape with stable keys addressable via configurable fields (keyField,
- * positionField, parentField). Admin-cms data types like `LinkedListItemKind` are assignable to this.
+ * A tree node of any record shape, addressed via configurable fields (keyField, positionField, parentField).
+ * Admin-cms types like `LinkedListItemKind` are assignable to it.
  */
 export interface NestedTreeNode<TItem = any> {
     data: TItem;