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

package/dist/domains/listEditor/components/ANestedSortableListEditor.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,1093 @@
+import { cloneDeep as e } from "../../../shared/utils/common.js";
+import { stringToInt as t } from "../../../shared/utils/string.js";
+import { useAlerts as n } from "../../system/composables/alerts.js";
+import { useUnsavedSection as r } from "../../unsavedGuard/composables/useUnsavedSection.js";
+import { useContainerWidth as i } from "../composables/useContainerWidth.js";
+import { useIsTouchDevice as a } from "../composables/useIsTouchDevice.js";
+import { useKeyboardNav as o } from "../composables/useKeyboardNav.js";
+import { useNestedListEditorController as s } from "../composables/useNestedListEditorController.js";
+import { provideListEditorStateScope as c, useNestedListEditorStateEntry as l } from "../composables/useListEditorStateScope.js";
+import { resolveCompactText as u } from "../utils/resolveCompactText.js";
+import { useDeleteDialog as ee } from "../composables/useDeleteDialog.js";
+import { useInlineEditing as te } from "../composables/useInlineEditing.js";
+import { validateAllAndReveal as ne } from "../utils/revealInvalidRows.js";
+import { useListEditorScopeValidity as re } from "../composables/useListEditorScopeValidity.js";
+import { useReorderMode as ie } from "../composables/useReorderMode.js";
+import ae from "./internal/LeDeleteDialog.js";
+import oe from "./internal/LeMoveToPositionDialog.js";
+import se from "./internal/LeEmptyState.js";
+import ce from "./internal/LeStatus.js";
+import { DRAG_CHOSEN_CLASS as le, DRAG_CLASS as ue, DRAG_GHOST_CLASS as de } from "./internal/constants.js";
+import { computeInstruction as fe } from "../composables/useDragInstruction.js";
+import pe from "./internal/LeNestedRow.js";
+import me from "./internal/LeChangeParentDialog.js";
+import { Fragment as he, computed as d, createBlock as ge, createCommentVNode as f, createElementBlock as p, createElementVNode as m, createTextVNode as h, createVNode as g, customRef as _e, defineComponent as _, guardReactiveProps as ve, isRef as ye, mergeModels as be, mergeProps as v, nextTick as y, normalizeClass as xe, normalizeProps as Se, normalizeStyle as Ce, onBeforeUnmount as we, onMounted as Te, openBlock as b, ref as x, renderList as Ee, renderSlot as S, shallowRef as De, toDisplayString as C, unref as w, useModel as Oe, useSlots as ke, useTemplateRef as Ae, watch as T, withCtx as E } from "vue";
+import { useI18n as je } from "vue-i18n";
+import { VAlert as Me } from "vuetify/components/VAlert";
+import { VIcon as Ne } from "vuetify/components/VIcon";
+import { VProgressCircular as Pe } from "vuetify/components/VProgressCircular";
+import { VTooltip as Fe } from "vuetify/components/VTooltip";
+import { VBtn as D } from "vuetify/components/VBtn";
+import { useSortable as Ie } from "@vueuse/integrations/useSortable";
+//#region src/domains/listEditor/components/ANestedSortableListEditor.vue?vue&type=script&setup=true&lang.ts
+var Le = { class: "a-le-card" }, Re = {
+	key: 0,
+	class: "a-le-header"
+}, ze = {
+	key: 0,
+	class: "a-le-title-heading"
+}, Be = { class: "a-le-header-actions" }, Ve = {
+	key: 1,
+	class: "a-le-state a-le-state--loading"
+}, He = {
+	key: 2,
+	class: "a-le-state a-le-state--error"
+}, Ue = {
+	key: 3,
+	class: "a-le-state a-le-state--empty"
+}, We = {
+	class: "a-le-sr-only",
+	"aria-live": "polite",
+	role: "status"
+}, Ge = "a-nested-list-editor__group", Ke = 24, qe = 22, Je = /*@__PURE__*/ _({
+	__name: "ANestedSortableListEditor",
+	props: /*@__PURE__*/ be({
+		maxDepth: {},
+		factory: {
+			type: Function,
+			default: void 0
+		},
+		getKey: {
+			type: [String, Function],
+			default: void 0
+		},
+		position: {
+			type: [
+				String,
+				Boolean,
+				Object
+			],
+			default: void 0
+		},
+		parentField: { default: "parent" },
+		dirtyExclude: { default: void 0 },
+		validate: {
+			type: Function,
+			default: void 0
+		},
+		validationScope: {
+			type: [
+				String,
+				Number,
+				Boolean,
+				Symbol
+			],
+			default: void 0
+		},
+		editor: { default: void 0 },
+		stateKey: { default: void 0 },
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		loading: {
+			type: Boolean,
+			default: !1
+		},
+		error: { default: null },
+		title: { default: null },
+		compactField: { default: null },
+		statusField: { default: null },
+		showAddButton: {
+			type: Boolean,
+			default: !0
+		},
+		showAddChildButton: {
+			type: Boolean,
+			default: !0
+		},
+		showDeleteButton: {
+			type: Boolean,
+			default: !0
+		},
+		showEditButton: {
+			type: Boolean,
+			default: !0
+		},
+		showAddAfterAction: {
+			type: Boolean,
+			default: !1
+		},
+		showMoveToPosition: {
+			type: Boolean,
+			default: !1
+		},
+		showChangeParent: {
+			type: Boolean,
+			default: !1
+		},
+		showExpandToggle: {
+			type: Boolean,
+			default: !0
+		},
+		addLabel: { default: null },
+		emptyTitle: { default: null },
+		disableRowClick: {
+			type: Boolean,
+			default: !1
+		},
+		disableDeleteConfirm: {
+			type: Boolean,
+			default: !1
+		},
+		disableUnsaved: {
+			type: Boolean,
+			default: !1
+		},
+		deleteConfirmTitle: { default: null },
+		deleteConfirmText: { default: null },
+		deleteMode: { default: "deferred" },
+		closeVariant: { default: "auto" },
+		loadingKeys: { default: null },
+		showReorderToggle: {
+			type: Boolean,
+			default: !0
+		},
+		disableReorder: {
+			type: Boolean,
+			default: !1
+		},
+		disableDrag: {
+			type: Boolean,
+			default: !1
+		},
+		onDeleteConfirm: {
+			type: Function,
+			default: void 0
+		},
+		onDelete: {
+			type: Function,
+			default: void 0
+		},
+		onItemSave: {
+			type: Function,
+			default: void 0
+		},
+		onReorderApply: {
+			type: Function,
+			default: void 0
+		},
+		unsavedSectionLabel: { default: void 0 }
+	}, {
+		modelValue: { required: !0 },
+		modelModifiers: {},
+		mode: { default: "view" },
+		modeModifiers: {}
+	}),
+	emits: /*@__PURE__*/ be([
+		"add",
+		"add-child",
+		"edit",
+		"deleted",
+		"close",
+		"item-saved",
+		"item-expand",
+		"reorder-start",
+		"reorder-cancel",
+		"reorder-applied",
+		"reorder-apply-error",
+		"reorder-end",
+		"indent",
+		"outdent"
+	], ["update:modelValue", "update:mode"]),
+	setup(_, { expose: be, emit: Je }) {
+		let O = _, k = Je, Ye = Oe(_, "modelValue"), Xe = null;
+		T(Ye, () => Xe = null, { flush: "sync" });
+		let A = _e((e, t) => ({
+			get: () => {
+				e();
+				let t = Ye.value;
+				return Xe ?? t;
+			},
+			set: (e) => {
+				Xe = e, Ye.value = e, t(), y(() => {
+					Xe === e && (Xe = null, t());
+				});
+			}
+		})), Ze = Oe(_, "mode"), { t: j } = je(), Qe = ke(), { showWarningT: $e } = n(), et = Ae("rootEl"), { isNarrow: tt } = i(et), nt = a(), rt = d(() => O.closeVariant === "icon" ? "icon" : O.closeVariant === "labeled" ? "labeled" : tt.value ? "icon" : "labeled"), M = x(/* @__PURE__ */ new Set()), N = x(/* @__PURE__ */ new Set()), it = O.getKey ?? "id", at = typeof it == "function" ? "id" : it, P = (e) => typeof it == "function" ? it(e) : e[it], ot = (() => {
+			let e = O.position;
+			return e === void 0 || e === !1 ? "position" : typeof e == "object" ? e.field : e;
+		})();
+		((e) => {
+			let t = (e) => {
+				for (let n of e) n.children && n.children.length > 0 && (M.value.add(P(n.data)), t(n.children));
+			};
+			t(e.children);
+		})(A.value);
+		let st = {
+			get: () => A.value,
+			set: (e) => A.value = e,
+			factory: O.factory,
+			getKey: O.getKey,
+			position: O.position,
+			parentField: O.parentField,
+			maxDepth: O.maxDepth,
+			dirtyExclude: () => O.dirtyExclude ?? [],
+			validate: O.validate
+		}, ct = O.editor ? null : l(O.stateKey, st), F = O.editor ?? ct?.handle ?? s(st), lt = c(ct?.childScope ?? null), I = d(() => {
+			let e = [], t = 0, n = O.maxDepth, r = (i, a, o) => {
+				for (let s = 0; s < i.length; s++) {
+					let c = i[s], l = P(c.data), u = c.children !== void 0, ee = u && (c.children?.length ?? 0) > 0, te = c.children?.length ?? 0, ne = n - (a + 1);
+					e.push({
+						key: l,
+						index: t++,
+						raw: c.data,
+						position: c.data[ot],
+						node: c,
+						depth: a,
+						parent: o?.data ?? null,
+						parentKey: o ? P(o.data) : null,
+						childrenCount: te,
+						hasChildren: ee,
+						childrenAllowed: u,
+						siblingIndex: s,
+						siblingCount: i.length,
+						firstInParent: s === 0,
+						lastInParent: s === i.length - 1,
+						canAddChild: u && ne > 0,
+						canIndent: s > 0,
+						canOutdent: a > 0
+					}), ee && r(c.children, a + 1, c);
+				}
+			};
+			return r(A.value.children, 0, null), e;
+		});
+		T(() => I.value.map((e) => String(e.key)).join("|"), () => lt.retainOwners(I.value.map((e) => e.key)), { flush: "post" });
+		let ut = De(null), dt = x(/* @__PURE__ */ new Set()), L = x(/* @__PURE__ */ new Set()), R = x(/* @__PURE__ */ new Set()), ft = (e) => {
+			F.commit(e), dt.value = /* @__PURE__ */ new Set();
+		}, z = (e) => {
+			let { node: t } = F.findNode(e);
+			if (!t) {
+				dt.value.add(e);
+				return;
+			}
+			let n = (e) => {
+				dt.value.add(P(e.data)), e.children && e.children.forEach(n);
+			};
+			n(t);
+		}, pt = /* @__PURE__ */ new Map(), B = d(() => {
+			let e = [], t = /* @__PURE__ */ new Set();
+			for (let n of I.value) {
+				t.add(n.key);
+				let r = U.value.has(n.key), i = N.value.has(n.key), a = M.value.has(n.key), o = O.loadingKeys?.has(n.key) ?? !1, s = dt.value.has(n.key), c = !O.readonly && F.isUnsaved(n.key), l = O.disableUnsaved || O.readonly ? !1 : c || s, u = pt.get(n.key);
+				if (u && u.raw === n.raw && u.index === n.index && u.position === n.position && u.depth === n.depth && u.parentKey === n.parentKey && u.childrenCount === n.childrenCount && u.firstInParent === n.firstInParent && u.lastInParent === n.lastInParent && u.editing === r && u.expanded === i && u.childrenExpanded === a && u.loading === o && u.dirty === c && u.moved === s && u.unsaved === l) {
+					e.push(u);
+					continue;
+				}
+				let ee = {
+					...n,
+					editing: r,
+					expanded: i,
+					childrenExpanded: a,
+					loading: o,
+					dirty: c,
+					moved: s,
+					unsaved: l
+				};
+				pt.set(n.key, ee), e.push(ee);
+			}
+			for (let e of pt.keys()) t.has(e) || pt.delete(e);
+			return e;
+		}), mt = d(() => A.value.children.length === 0), ht = d(() => I.value.length), V = Ae("rowsContainer"), H = d(() => !O.readonly && !O.disabled && !O.loading), gt = d(() => H.value && !O.disableReorder && ht.value > 1), _t = d(() => !!Qe.item), vt = d(() => !!Qe["item-readonly"]), yt = d(() => !!O.onItemSave), { editingKeys: U, editingSnapshots: bt, clearEditing: xt, beginEdit: St, cancelEdit: Ct, commitEdit: wt, closeEdit: Tt, requestAutoOpen: Et } = te({
+			rowsContainer: V,
+			rowSelector: ".a-le-row-wrapper",
+			isInlineEdit: _t,
+			restoreSnapshot: (e, t) => F.updateItem(e, t, !1),
+			watchKeys: () => {
+				let e = [], t = (n) => {
+					for (let r of n) e.push(P(r.data)), r.children && r.children.length && t(r.children);
+				};
+				return t(A.value.children), e;
+			},
+			findEntry: (e) => {
+				let { node: t } = F.findNode(e);
+				return t ? { data: t.data } : null;
+			},
+			afterAutoOpen: (e) => {
+				let { parent: t } = F.findNode(e);
+				t && M.value.add(P(t.data));
+			}
+		}), { applying: Dt, applyError: Ot, hasPendingChanges: kt, movedCount: At, reorderMode: W, enterReorderMode: jt, cancelReorderMode: G, applyReorder: Mt } = ie({
+			mode: Ze,
+			snapshot: ut,
+			movedKeys: dt,
+			modelValue: A,
+			cloneModel: (t) => e(t),
+			applyModel: (e) => {
+				A.value = e;
+			},
+			canEnterReorder: gt,
+			onEnter: () => {
+				L.value = /* @__PURE__ */ new Set(), R.value = /* @__PURE__ */ new Set(), xt();
+				for (let e of q.value) M.value.add(e);
+				y(() => {
+					K.value && X();
+				});
+			},
+			onExternalEnter: () => {
+				L.value = /* @__PURE__ */ new Set(), R.value = /* @__PURE__ */ new Set(), xt();
+			},
+			onCancel: () => {
+				for (let e of L.value) F.restoreDeleted(e);
+				for (let e of R.value) F.deleteItem(e, {
+					trackDeleted: !1,
+					renumber: !1
+				});
+				L.value = /* @__PURE__ */ new Set(), R.value = /* @__PURE__ */ new Set(), qt();
+			},
+			onApplyEnd: () => {
+				L.value = /* @__PURE__ */ new Set(), R.value = /* @__PURE__ */ new Set(), qt();
+			},
+			onReorderApply: (e) => O.onReorderApply?.(e),
+			emit: {
+				reorderStart: () => k("reorder-start"),
+				reorderCancel: () => k("reorder-cancel"),
+				reorderApplied: (e) => k("reorder-applied", e),
+				reorderApplyError: (e) => k("reorder-apply-error", e),
+				reorderEnd: () => k("reorder-end")
+			}
+		}), Nt = d(() => At.value + L.value.size), Pt = d(() => kt.value || L.value.size > 0), Ft = d(() => H.value && O.showAddButton && !W.value), K = d(() => W.value && !nt.value && !O.disableDrag), It = d(() => O.addLabel ?? j("common.sortable.add")), Lt = d(() => O.emptyTitle ?? j("common.sortable.emptyTitle")), Rt = d(() => O.deleteConfirmTitle ?? j("common.sortable.deleteConfirmTitle")), zt = d(() => O.deleteConfirmText ?? (O.deleteMode === "immediate" ? j("common.sortable.deleteConfirmText") : j("common.sortable.deleteConfirmTextDeferred"))), Bt = d(() => !O.readonly && O.showReorderToggle && !W.value && ht.value > 0), Vt = d(() => !!O.title && tt.value), q = d(() => {
+			let e = [], t = (n) => {
+				for (let r of n) r.children && r.children.length > 0 && (e.push(P(r.data)), t(r.children));
+			};
+			return t(A.value.children), e;
+		}), J = d(() => q.value.length > 0 && q.value.every((e) => M.value.has(e))), Ht = d(() => !W.value && q.value.length > 0), Ut = () => {
+			if (J.value) for (let e of q.value) M.value.delete(e);
+			else for (let e of q.value) M.value.add(e);
+		}, Wt = d(() => !!(O.title || Qe.header || Qe["reorder-toggle"] || Bt.value || Ht.value || W.value)), Gt = x([]), Kt = x(0), qt = () => {
+			for (let e of Gt.value) try {
+				e.stop();
+			} catch {}
+			Gt.value = [];
+		}, Y = x(null), Jt = (e, t) => {
+			let n = document.elementFromPoint(e, t);
+			if (!n) return null;
+			let r = n.closest(".a-le-row-wrapper");
+			if (!r || !V.value || !V.value.contains(r)) return null;
+			let i = Qt(r.getAttribute("data-id"));
+			if (i === null) return null;
+			let a = B.value.find((e) => e.key === i);
+			return a ? {
+				el: r,
+				viewItem: a
+			} : null;
+		}, Yt = (e, t) => {
+			if (!Y.value || !V.value) return;
+			let n = Jt(e, t);
+			if (!n) {
+				Y.value.instruction = null;
+				return;
+			}
+			let r = V.value.getBoundingClientRect(), i = (n.el.querySelector(":scope > .a-le-row") ?? n.el).getBoundingClientRect();
+			Y.value.instruction = fe({
+				pointer: {
+					x: e,
+					y: t
+				},
+				hoveredRow: {
+					key: n.viewItem.key,
+					rect: i,
+					depth: n.viewItem.depth,
+					parentKey: n.viewItem.parentKey,
+					siblingIndex: n.viewItem.siblingIndex,
+					siblingCount: n.viewItem.siblingCount
+				},
+				sourceKey: Y.value.sourceKey,
+				sourceSubtreeDepth: Y.value.sourceSubtreeDepth,
+				viewItems: B.value,
+				maxDepth: O.maxDepth,
+				indentPx: Ke,
+				containerLeft: r.left,
+				containerPaddingLeft: qe
+			});
+		}, Xt = (e) => {
+			Yt(e.clientX, e.clientY);
+		}, Zt = (e, t) => {
+			F.moveTo(t, e.parentKey, e.index) ? (z(t), e.makeChild && e.parentKey !== null && M.value.add(e.parentKey)) : ($e("common.sortable.error.maxDeepExceed"), Kt.value++, y(() => X()));
+		}, X = () => {
+			if (qt(), !K.value || !V.value) return;
+			let e = Array.from(V.value.querySelectorAll("." + Ge));
+			for (let t of e) {
+				let e = Ie(t, [], {
+					group: {
+						name: "a-nested",
+						pull: !0,
+						put: !0
+					},
+					handle: ".a-le-drag-handle",
+					animation: 0,
+					ghostClass: de,
+					chosenClass: le,
+					dragClass: ue,
+					fallbackOnBody: !0,
+					forceFallback: !0,
+					fallbackTolerance: 3,
+					onStart: (e) => {
+						let t = e.item, n = Qt(t.getAttribute("data-id"));
+						if (n === null) return;
+						let r = F.findNode(n).node, i = r ? F.calculateSubtreeDepth(r) : 1;
+						Y.value = {
+							sourceKey: n,
+							sourceSubtreeDepth: i,
+							instruction: null
+						}, document.addEventListener("pointermove", Xt, { passive: !0 });
+					},
+					onMove: (e) => {
+						let t = e.originalEvent;
+						if (t) {
+							if ("clientX" in t && "clientY" in t) Yt(t.clientX, t.clientY);
+							else if ("touches" in t) {
+								let e = t;
+								e.touches.length > 0 && Yt(e.touches[0].clientX, e.touches[0].clientY);
+							}
+						}
+						return !1;
+					},
+					onEnd: () => {
+						document.removeEventListener("pointermove", Xt);
+						let e = Y.value;
+						if (Y.value = null, !e) return;
+						let t = e.instruction;
+						t !== null && t.type !== "blocked" && Zt(t, e.sourceKey);
+					}
+				});
+				Gt.value.push(e);
+			}
+		}, Qt = (e) => {
+			if (e === null || e === "") return null;
+			let n = t(e);
+			return String(n) === e ? n : e;
+		};
+		T(() => K.value, () => {
+			K.value ? y(() => X()) : qt();
+		}), T(() => Kt.value, () => {
+			K.value && y(() => X());
+		}), T(() => B.value.map((e) => e.key).join("|"), () => {
+			K.value && y(() => X());
+		}), Te(() => {
+			K.value && X();
+		}), we(() => {
+			qt(), document.removeEventListener("pointermove", Xt);
+		});
+		let Z = d(() => {
+			let e = Y.value;
+			if (!e || e.instruction === null || !V.value) return null;
+			let t = e.instruction;
+			if (t.type === "blocked") return null;
+			let n = V.value.querySelector(`.a-le-row-wrapper[data-id="${CSS.escape(String(t.refKey))}"]`);
+			if (!n) return null;
+			let r = n.querySelector(":scope > .a-le-row"), i = V.value.getBoundingClientRect(), a = (r ?? n).getBoundingClientRect(), o = qe + t.depth * Ke, s = t.refEdge === "top" ? a.top - i.top : a.bottom - i.top, c = {
+				top: s,
+				left: o,
+				right: 16
+			}, l = null;
+			if (t.levelRowKey !== null) {
+				let e = V.value.querySelector(`.a-le-row-wrapper[data-id="${CSS.escape(String(t.levelRowKey))}"]`);
+				if (e) {
+					let t = (e.querySelector(":scope > .a-le-row") ?? e).getBoundingClientRect(), n = t.top - i.top + t.height / 2;
+					n < s && (l = {
+						top: n,
+						height: s - n,
+						left: o
+					});
+				}
+			}
+			return {
+				line: c,
+				connector: l
+			};
+		}), $t = () => {
+			Ft.value && (Et(), O.factory && F.addItem(), k("add", void 0));
+		}, en = (e) => {
+			H.value && (Et(), O.factory && F.addAfter(e.key, void 0, e.childrenAllowed), k("add", {
+				afterId: e.key,
+				childrenAllowed: e.childrenAllowed
+			}));
+		}, tn = (e) => {
+			H.value && e.canAddChild && (Et(), M.value.add(e.key), k("add-child", e), O.factory && F.addChild(e.key, void 0, !0), k("add", {
+				parentId: e.key,
+				childrenAllowed: !0
+			}));
+		}, nn = (e) => {
+			H.value && !W.value && (U.value.has(e.key) ? vn(e) : (_t.value && St(e), k("edit", e)));
+		}, rn = (e) => {
+			if (O.disabled || O.loading) return;
+			let t = e.key, n = M.value.has(t);
+			n ? M.value.delete(t) : M.value.add(t), k("item-expand", e, !n);
+		}, an = (e) => {
+			if (O.disabled || O.loading) return;
+			let t = e.key, n = N.value.has(t);
+			n ? N.value.delete(t) : N.value.add(t), k("item-expand", e, !n);
+		}, on = (e) => O.disableRowClick || O.disabled || O.loading || W.value ? !1 : !!(e.editing || e.expanded || !O.readonly && O.showEditButton), sn = (e) => {
+			on(e) && (e.editing || e.expanded ? vn(e) : O.readonly && vt.value ? an(e) : nn(e));
+		}, { deleteDialog: cn, deleteInFlight: ln, deleteError: un, onDeleteClick: dn, onDeleteDialogConfirm: fn, onDeleteDialogCancel: pn } = ee({
+			onDeleteConfirm: (e) => !O.onDeleteConfirm || O.onDeleteConfirm(e),
+			onDelete: (e) => O.onDelete?.(e),
+			onDeleted: (e) => {
+				U.value.delete(e.key), bt.value.delete(e.key), N.value.delete(e.key), M.value.delete(e.key);
+				let t = O.deleteMode === "deferred";
+				W.value && (t ? L.value.add(e.key) : R.value.add(e.key)), t ? F.deleteItem(e.key, { trackDeleted: !0 }) : F.deleteItem(e.key, {
+					trackDeleted: !1,
+					renumber: !1
+				}), k("deleted", e);
+			},
+			disableDeleteConfirm: () => O.disableDeleteConfirm
+		}), mn = async (e) => {
+			H.value && await dn(e);
+		}, hn = x(/* @__PURE__ */ new Set()), gn = async (e) => {
+			if (!hn.value.has(e.key)) {
+				hn.value.add(e.key);
+				try {
+					O.onItemSave && await O.onItemSave(e.raw);
+				} finally {
+					hn.value.delete(e.key);
+				}
+				wt(e), k("item-saved", e);
+			}
+		}, _n = (e) => {
+			Ct(e);
+		}, vn = (e) => {
+			Tt(e), k("close", e);
+		}, yn = (e) => {
+			F.moveUp(e) && z(e);
+		}, bn = (e) => {
+			F.moveDown(e) && z(e);
+		}, xn = (e) => {
+			F.moveTop(e) && z(e);
+		}, Sn = (e) => {
+			F.moveBottom(e) && z(e);
+		}, Cn = (e) => {
+			F.indent(e.key) ? (z(e.key), k("indent", e)) : $e("common.sortable.error.maxDeepExceed");
+		}, wn = (e) => {
+			F.outdent(e.key) && (z(e.key), k("outdent", e));
+		}, Tn = (e) => u(e, { compactField: O.compactField }), En = (e, t) => t === void 0 ? null : F.rowState(e, t, U.value.has(t)), Dn = /* @__PURE__ */ new Map(), On = (e) => {
+			let t = Dn.get(e);
+			return t || (t = {
+				edit: () => {
+					let t = Q(e);
+					t && nn(t);
+				},
+				save: () => {
+					let t = Q(e);
+					return t ? gn(t) : void 0;
+				},
+				cancel: () => {
+					let t = Q(e);
+					t && _n(t);
+				},
+				close: () => {
+					let t = Q(e);
+					t && vn(t);
+				},
+				delete: async () => {
+					let t = Q(e);
+					t && await mn(t);
+				},
+				addAfter: () => {
+					let t = Q(e);
+					t && en(t);
+				},
+				addChild: () => {
+					let t = Q(e);
+					t && tn(t);
+				},
+				toggleExpand: () => {
+					let t = Q(e);
+					t && rn(t);
+				},
+				toggleDetail: () => {
+					let t = Q(e);
+					t && an(t);
+				},
+				moveUp: () => yn(e),
+				moveDown: () => bn(e),
+				moveTop: () => xn(e),
+				moveBottom: () => Sn(e),
+				indent: () => {
+					let t = Q(e);
+					t && Cn(t);
+				},
+				outdent: () => {
+					let t = Q(e);
+					t && wn(t);
+				},
+				update: (t) => F.updateItem(e, t)
+			}, Dn.set(e, t)), t;
+		};
+		T(() => B.value, (e) => {
+			if (Dn.size === 0) return;
+			let t = new Set(e.map((e) => e.key));
+			for (let e of Dn.keys()) t.has(e) || Dn.delete(e);
+		});
+		let kn = (e) => ({
+			item: {
+				...e,
+				validationState: En(e.raw, e.key)
+			},
+			raw: e.raw,
+			index: e.index,
+			key: e.key,
+			depth: e.depth,
+			parent: e.parent,
+			parentKey: e.parentKey,
+			childrenCount: e.childrenCount,
+			hasChildren: e.hasChildren,
+			childrenAllowed: e.childrenAllowed,
+			firstInParent: e.firstInParent,
+			lastInParent: e.lastInParent,
+			readonly: O.readonly,
+			disabled: O.disabled,
+			expanded: e.expanded,
+			childrenExpanded: e.childrenExpanded,
+			editing: e.editing,
+			dirty: e.dirty,
+			unsaved: e.unsaved,
+			moved: e.moved,
+			reorderMode: W.value,
+			canMoveUp: !e.firstInParent,
+			canMoveDown: !e.lastInParent,
+			canIndent: e.canIndent,
+			canOutdent: e.canOutdent,
+			canAddChild: e.canAddChild,
+			touch: nt.value,
+			stateKeyPrefix: lt.prefixFor(e.key),
+			actions: On(e.key)
+		}), An = d(() => ({
+			applying: Dt.value,
+			hasPendingChanges: Pt.value,
+			movedCount: Nt.value,
+			error: Ot.value,
+			actions: {
+				apply: Mt,
+				cancel: G
+			}
+		})), jn = d(() => ({
+			mode: Ze.value,
+			disabled: !gt.value,
+			hasPendingChanges: kt.value,
+			actions: {
+				enterReorderMode: jt,
+				exitReorderMode: G
+			}
+		})), Mn = d(() => new Set(q.value)), Q = (e) => B.value.find((t) => t.key === e), Nn = o({
+			viewItems: d(() => B.value.map((e) => ({
+				key: e.key,
+				expanded: e.childrenExpanded,
+				canExpand: Mn.value.has(e.key),
+				canIndent: !0,
+				canOutdent: !0
+			}))),
+			variant: "nested",
+			isReorderMode: W,
+			disabled: d(() => !H.value),
+			isEditing: (e) => U.value.has(e),
+			onToggleEdit: (e) => {
+				let t = Q(e);
+				t && nn(t);
+			},
+			onCancelEdit: (e) => {
+				let t = Q(e);
+				t && vn(t);
+			},
+			onMoveUp: (e) => yn(e),
+			onMoveDown: (e) => bn(e),
+			onMoveTop: (e) => xn(e),
+			onMoveBottom: (e) => Sn(e),
+			onIndent: (e) => {
+				let t = Q(e);
+				t && Cn(t);
+			},
+			onOutdent: (e) => {
+				let t = Q(e);
+				t && wn(t);
+			},
+			onToggleChildren: (e) => {
+				let t = Q(e);
+				t && rn(t);
+			},
+			onCancelReorder: () => G()
+		}), Pn = x(!1), $ = De(null), Fn = d(() => {
+			let e = $.value;
+			if (!e) return null;
+			let t = F.findNode(e.key), n = t.parent?.children ?? A.value.children, r = n.findIndex((t) => P(t.data) === e.key);
+			return {
+				parentId: t.parent ? P(t.parent.data) : null,
+				total: n.length,
+				currentIndex: r
+			};
+		}), In = d(() => $.value ? Tn($.value.raw) : ""), Ln = (e) => {
+			O.showMoveToPosition && ($.value = e, Pn.value = !0);
+		}, Rn = (e) => {
+			let t = Fn.value, n = $.value;
+			if ($.value = null, !t || !n || e === t.currentIndex) return;
+			let r = e > t.currentIndex ? e + 1 : e;
+			F.moveTo(n.key, t.parentId, r) && z(n.key);
+		}, zn = x(!1), Bn = De(null), Vn = (e) => {
+			O.showChangeParent && (Bn.value = e, zn.value = !0);
+		}, Hn = (e, t) => {
+			let n = Bn.value;
+			if (Bn.value = null, !n) return;
+			let r = 0;
+			r = e === null ? A.value.children.length : F.findNode(e).node?.children?.length ?? 0;
+			let i = t === "first" ? 0 : r;
+			F.moveTo(n.key, e, i) && (z(n.key), e !== null && M.value.add(e));
+		}, Un = d(() => ({
+			reorderMode: W.value,
+			readonly: O.readonly,
+			canInteract: H.value,
+			dragEnabled: K.value,
+			showExpandToggle: O.showExpandToggle,
+			showEditButton: O.showEditButton,
+			showDeleteButton: O.showDeleteButton,
+			showAddChildButton: O.showAddChildButton,
+			showAddAfterAction: O.showAddAfterAction,
+			showMoveToPosition: O.showMoveToPosition,
+			showChangeParent: O.showChangeParent,
+			showInlineSaveFooter: yt.value,
+			statusField: O.statusField,
+			effectiveCloseVariant: rt.value,
+			keyboardNav: Nn,
+			isRowClickable: on,
+			resolveCompactText: Tn,
+			resolveValidation: (e, t) => En(e, t),
+			buildSlotProps: kn
+		})), Wn = {
+			onRowClick: sn,
+			onChevronClick: rn,
+			onEditClick: nn,
+			onDeleteClick: mn,
+			onCloseClick: vn,
+			onSaveClick: gn,
+			onCancelClick: _n,
+			onAddAfterClick: en,
+			onAddChildClick: tn,
+			moveUp: (e) => yn(e),
+			moveDown: (e) => bn(e),
+			moveTop: (e) => xn(e),
+			moveBottom: (e) => Sn(e),
+			indent: Cn,
+			outdent: wn,
+			openMoveToPosition: Ln,
+			openChangeParent: Vn
+		}, Gn = d(() => B.value.filter((e) => e.parentKey === null)), Kn = () => {
+			let e = /* @__PURE__ */ new Map(), t = (n) => {
+				for (let r of n) e.set(P(r.data), r), r.children?.length && t(r.children);
+			};
+			return t(A.value.children), e;
+		}, qn = () => new Set([...Kn().keys()].filter((e) => F.isUnsaved(e))), Jn = (e, t = []) => {
+			let n = new Set(Kn().keys()), r = qn();
+			e(), y(() => {
+				let e = Kn(), i = [.../* @__PURE__ */ new Set([...t, ...[...qn()].filter((e) => !r.has(e))])], a = i.filter((t) => !n.has(t) && e.get(t)?.meta.dirty);
+				F.acceptRows(i);
+				let o = Kn();
+				for (let e of a) {
+					let t = o.get(e);
+					t && F.updateItem(e, t.data, !0);
+				}
+			});
+		};
+		r(() => O.unsavedSectionLabel && !O.disableUnsaved ? {
+			label: O.unsavedSectionLabel,
+			dirty: F.hasUnsaved.value
+		} : []);
+		let Yn = () => ne(F, (e) => {
+			let t = F.findNode(e).parent;
+			for (; t;) M.value.add(P(t.data)), t = F.findNode(P(t.data)).parent;
+			let n = F.viewItems.value.find((t) => t.key === e);
+			n && St(n);
+		});
+		return re({
+			hasErrors: F.hasErrors,
+			validationScope: O.validationScope,
+			validateProvided: O.validate !== void 0,
+			reveal: Yn
+		}), be({
+			...F,
+			validateAll: Yn,
+			commit: ft,
+			acceptChanges: Jn,
+			viewItems: I,
+			enterReorderMode: jt,
+			cancelReorderMode: G,
+			applyReorder: Mt,
+			expand: (e) => M.value.add(e),
+			collapse: (e) => M.value.delete(e),
+			toggleExpand: (e) => {
+				M.value.has(e) ? M.value.delete(e) : M.value.add(e);
+			},
+			expandDetail: (e) => N.value.add(e),
+			collapseDetail: (e) => N.value.delete(e)
+		}), (e, t) => (b(), p("div", {
+			ref_key: "rootEl",
+			ref: et,
+			class: xe(["a-nested-list-editor", [`a-nested-list-editor--mode-${Ze.value}`, {
+				"a-nested-list-editor--readonly": _.readonly,
+				"a-nested-list-editor--disabled": _.disabled,
+				"a-nested-list-editor--touch": w(nt),
+				"a-nested-list-editor--drag-enabled": K.value
+			}]])
+		}, [
+			m("div", Le, [
+				Wt.value ? (b(), p("div", Re, [S(e.$slots, "header", v({ title: _.title }, jn.value), () => [_.title ? (b(), p("h3", ze, C(_.title), 1)) : f("", !0), m("div", Be, [w(W) ? S(e.$slots, "reorder-toolbar", Se(ve(An.value)), () => [
+					g(ce, {
+						class: xe({ "a-le-toolbar-status--pending": Pt.value }),
+						"has-pending-changes": Pt.value,
+						"pending-count": Nt.value,
+						error: w(Ot)
+					}, null, 8, [
+						"class",
+						"has-pending-changes",
+						"pending-count",
+						"error"
+					]),
+					g(D, {
+						variant: "text",
+						size: "small",
+						disabled: w(Dt),
+						onClick: w(G)
+					}, {
+						default: E(() => [h(C(w(j)("common.sortable.reorderCancel")), 1)]),
+						_: 1
+					}, 8, ["disabled", "onClick"]),
+					g(D, {
+						color: "primary",
+						variant: "flat",
+						size: "small",
+						"prepend-icon": "mdi-check",
+						loading: w(Dt),
+						disabled: w(Dt) || !Pt.value,
+						onClick: w(Mt)
+					}, {
+						default: E(() => [h(C(w(j)("common.sortable.reorderApply")), 1)]),
+						_: 1
+					}, 8, [
+						"loading",
+						"disabled",
+						"onClick"
+					])
+				], void 0, 0) : (b(), p(he, { key: 1 }, [Ht.value && Vt.value ? (b(), ge(D, {
+					key: 0,
+					"aria-label": J.value ? w(j)("common.sortable.collapseAll") : w(j)("common.sortable.expandAll"),
+					variant: "tonal",
+					color: "primary",
+					icon: "",
+					size: "x-small",
+					onClick: Ut
+				}, {
+					default: E(() => [g(Ne, {
+						icon: J.value ? "mdi-unfold-less-horizontal" : "mdi-unfold-more-horizontal",
+						size: "18"
+					}, null, 8, ["icon"]), g(Fe, {
+						activator: "parent",
+						location: "bottom",
+						text: J.value ? w(j)("common.sortable.collapseAll") : w(j)("common.sortable.expandAll")
+					}, null, 8, ["text"])]),
+					_: 1
+				}, 8, ["aria-label"])) : Ht.value ? (b(), ge(D, {
+					key: 1,
+					variant: "tonal",
+					color: "primary",
+					size: "small",
+					"prepend-icon": J.value ? "mdi-unfold-less-horizontal" : "mdi-unfold-more-horizontal",
+					onClick: Ut
+				}, {
+					default: E(() => [h(C(J.value ? w(j)("common.sortable.collapseAll") : w(j)("common.sortable.expandAll")), 1)]),
+					_: 1
+				}, 8, ["prepend-icon"])) : f("", !0), Bt.value ? S(e.$slots, "reorder-toggle", Se(ve(jn.value)), () => [Vt.value ? (b(), ge(D, {
+					key: 0,
+					"aria-label": w(j)("common.sortable.reorder"),
+					variant: "tonal",
+					color: "primary",
+					icon: "",
+					size: "x-small",
+					disabled: !gt.value,
+					onClick: w(jt)
+				}, {
+					default: E(() => [g(Ne, {
+						icon: "mdi-sort",
+						size: "18"
+					}), g(Fe, {
+						activator: "parent",
+						location: "bottom",
+						text: w(j)("common.sortable.reorder")
+					}, null, 8, ["text"])]),
+					_: 1
+				}, 8, [
+					"aria-label",
+					"disabled",
+					"onClick"
+				])) : (b(), ge(D, {
+					key: 1,
+					variant: "tonal",
+					color: "primary",
+					"prepend-icon": "mdi-sort",
+					size: "small",
+					disabled: !gt.value,
+					onClick: w(jt)
+				}, {
+					default: E(() => [h(C(w(j)("common.sortable.reorder")), 1)]),
+					_: 1
+				}, 8, ["disabled", "onClick"]))], void 0, 2) : f("", !0)], 64))])])])) : f("", !0),
+				_.loading ? (b(), p("div", Ve, [g(Pe, {
+					indeterminate: "",
+					color: "primary",
+					size: "32"
+				})])) : _.error ? (b(), p("div", He, [g(Me, {
+					type: "error",
+					variant: "tonal",
+					density: "compact",
+					border: "start"
+				}, {
+					default: E(() => [h(C(_.error), 1)]),
+					_: 1
+				})])) : mt.value ? (b(), p("div", Ue, [S(e.$slots, "empty", {
+					readonly: _.readonly,
+					disabled: _.disabled,
+					actions: { add: $t }
+				}, () => [g(se, {
+					title: Lt.value,
+					"add-label": It.value,
+					"can-add": Ft.value,
+					onAdd: $t
+				}, null, 8, [
+					"title",
+					"add-label",
+					"can-add"
+				])])])) : (b(), p("div", {
+					key: Kt.value,
+					ref_key: "rowsContainer",
+					ref: V,
+					class: xe(["a-nested-list-editor__rows", { "a-nested-list-editor__rows--dragging": Y.value !== null }])
+				}, [m("div", {
+					class: xe([Ge, "a-nested-list-editor__group--root"]),
+					"data-parent-id": ""
+				}, [(b(!0), p(he, null, Ee(Gn.value, (t) => (b(), ge(pe, {
+					key: String(t.key),
+					vi: t,
+					"view-items": B.value,
+					"drag-state": Y.value,
+					context: Un.value,
+					callbacks: Wn
+				}, {
+					item: E((t) => [S(e.$slots, "item", v({ ref_for: !0 }, t))]),
+					"item-compact": E((t) => [S(e.$slots, "item-compact", v({ ref_for: !0 }, t))]),
+					"item-readonly": E((t) => [S(e.$slots, "item-readonly", v({ ref_for: !0 }, t))]),
+					"item-status": E((t) => [S(e.$slots, "item-status", v({ ref_for: !0 }, t))]),
+					"item-footer": E((t) => [S(e.$slots, "item-footer", v({ ref_for: !0 }, t))]),
+					"item-actions": E((t) => [S(e.$slots, "item-actions", v({ ref_for: !0 }, t))]),
+					"before-item": E((t) => [S(e.$slots, "before-item", v({ ref_for: !0 }, t))]),
+					"after-item": E((t) => [S(e.$slots, "after-item", v({ ref_for: !0 }, t))]),
+					_: 3
+				}, 8, [
+					"vi",
+					"view-items",
+					"drag-state",
+					"context"
+				]))), 128))], 2), Z.value === null ? f("", !0) : (b(), p(he, { key: 0 }, [Z.value.connector === null ? f("", !0) : (b(), p("div", {
+					key: 0,
+					class: "a-nested-list-editor__drop-connector",
+					style: Ce({
+						left: `${Z.value.connector.left}px`,
+						top: `${Z.value.connector.top}px`,
+						height: `${Z.value.connector.height}px`
+					})
+				}, null, 4)), m("div", {
+					class: "a-nested-list-editor__drop-line",
+					style: Ce({
+						top: `${Z.value.line.top}px`,
+						left: `${Z.value.line.left}px`,
+						right: `${Z.value.line.right}px`
+					})
+				}, [...t[3] ||= [m("span", { class: "a-nested-list-editor__drop-line-dot" }, null, -1)]], 4)], 64))], 2)),
+				Ft.value && !_.loading && !_.error && !mt.value ? S(e.$slots, "add-button", {
+					readonly: _.readonly,
+					disabled: _.disabled,
+					props: { onClick: $t },
+					actions: { add: $t }
+				}, () => [m("button", {
+					type: "button",
+					class: "a-le-row-add",
+					onClick: $t
+				}, [g(Ne, {
+					icon: "mdi-plus",
+					size: "18"
+				}), m("span", null, C(It.value), 1)])], void 0, 5) : f("", !0)
+			]),
+			g(oe, {
+				modelValue: Pn.value,
+				"onUpdate:modelValue": t[0] ||= (e) => Pn.value = e,
+				total: Fn.value?.total ?? 0,
+				"current-index": Fn.value?.currentIndex ?? 0,
+				"item-label": In.value,
+				onConfirm: Rn
+			}, null, 8, [
+				"modelValue",
+				"total",
+				"current-index",
+				"item-label"
+			]),
+			g(me, {
+				modelValue: zn.value,
+				"onUpdate:modelValue": t[1] ||= (e) => zn.value = e,
+				tree: A.value,
+				"source-key": Bn.value?.key ?? null,
+				"key-field": w(at),
+				"max-depth": _.maxDepth,
+				"resolve-label": Tn,
+				"calculate-subtree-depth": w(F).calculateSubtreeDepth,
+				onConfirm: Hn
+			}, null, 8, [
+				"modelValue",
+				"tree",
+				"source-key",
+				"key-field",
+				"max-depth",
+				"calculate-subtree-depth"
+			]),
+			g(ae, {
+				modelValue: w(cn),
+				"onUpdate:modelValue": t[2] ||= (e) => ye(cn) ? cn.value = e : null,
+				title: Rt.value,
+				text: zt.value,
+				"confirm-label": w(j)("common.sortable.delete"),
+				"cancel-label": w(j)("common.button.cancel"),
+				error: w(un),
+				"in-flight": w(ln),
+				onConfirm: w(fn),
+				onCancel: w(pn)
+			}, null, 8, [
+				"modelValue",
+				"title",
+				"text",
+				"confirm-label",
+				"cancel-label",
+				"error",
+				"in-flight",
+				"onConfirm",
+				"onCancel"
+			]),
+			m("div", We, C(w(Nn).grabbedKey.value === null ? "" : w(j)("common.sortable.keyboardGrab.status", {
+				n: w(Nn).grabbedIndex.value + 1,
+				total: w(Nn).totalCount.value
+			})), 1)
+		], 2));
+	}
+});
+//#endregion
+export { Je as default };
+
+//# sourceMappingURL=ANestedSortableListEditor.vue_vue_type_script_setup_true_lang.js.map