@anzusystems/common-admin 1.47.0-beta.dev-1782074999 → 1.47.0-beta.dev-1782077999

package/dist/labs.d.ts

@@ -1006,6 +1006,29 @@ declare type ExecuteRequestParams<T> = {
     object?: T;
 };
 
+/**
+ * The shape a CONSUMER sees when it reads a list-editor handle through a template/function ref.
+ * Vue's `expose` proxy unwraps every exposed ref, so the reactive fields (`hasUnsaved`, `hasErrors`,
+ * `unsavedCount`, …) arrive as plain VALUES here, not `Ref`s: read `handle.hasUnsaved` (a boolean),
+ * never `handle.hasUnsaved.value` (that is `undefined`). Type your `useTemplateRef` / collected-ref
+ * maps with this so a stray `.value` is a compile error instead of a silently-dead guard/save-gate.
+ */
+export declare type ExposedListEditorHandle<TItem extends Record<string, any>> = ShallowUnwrapRef<ListEditorHandle<TItem>>;
+
+/**
+ * Consumer-facing shape of a nested-list-editor handle read through a template/function ref — Vue's
+ * `expose` proxy unwraps the exposed refs, so read `handle.hasUnsaved` (a boolean), not
+ * `handle.hasUnsaved.value`. See {@link ExposedListEditorHandle}.
+ *
+ * The `ANestedSortableListEditor` component also exposes `hasUnsavedChanges` (a legacy alias of
+ * `hasUnsaved`, likewise a ComputedRef → unwrapped to a boolean here) — included so it can't be
+ * `.value`-read by accident. Its imperative-only extras (addAfterId / resetDirtyBaseline / expand /
+ * reorder / …) are not refs and carry no unwrap hazard; intersect them in the consumer if you call them.
+ */
+export declare type ExposedNestedListEditorHandle<TItem extends Record<string, any>> = ShallowUnwrapRef<NestedListEditorHandle<TItem>> & {
+    hasUnsavedChanges: boolean;
+};
+
 declare type FetchByIdsParams = {
     urlTemplate?: string;
     urlParams?: UrlParams;
@@ -1187,7 +1210,7 @@ export declare interface ListEditorHandle<TItem extends Record<string, any>> {
     /** Amber: is this row added / edited / moved since the last commit? */
     isUnsaved: (key: ListEditorKey) => boolean;
     /** Red rail (gated): 'invalid' only once the row is unsaved or `validateAll()` ran. */
-    rowState: (item: TItem, key: ListEditorKey) => ListEditorValidationState;
+    rowState: (item: TItem, key: ListEditorKey, editing?: boolean) => ListEditorValidationState;
     /** Force-show all invalid rows + return whether the list is valid. The save guard. */
     validateAll: () => boolean;
     /** Normalized ordered array for a full-DTO save. */
@@ -1198,7 +1221,7 @@ export declare interface ListEditorHandle<TItem extends Record<string, any>> {
     commit: (savedItems?: TItem[]) => void;
     /** Discard unsaved edits back to the last committed baseline (or given items). */
     reset: (items?: TItem[]) => void;
-    addItem: (item?: TItem, hint?: PositionHint) => void;
+    addItem: (item?: TItem, hint?: PositionHint) => ListEditorKey | undefined;
     updateItem: (key: ListEditorKey, next: TItem | Partial<TItem> | ((current: TItem) => TItem)) => void;
     /** Remove a row. `trackDeleted: false` (immediate mode) skips the deferred-deletion tombstone. */
     deleteItem: (key: ListEditorKey, opts?: {
@@ -1207,19 +1230,14 @@ export declare interface ListEditorHandle<TItem extends Record<string, any>> {
     /** Clear a deferred-deletion tombstone (the caller re-inserts the row, e.g. reorder Cancel). */
     restoreDeleted: (key: ListEditorKey) => void;
     moveItem: (fromIndex: number, toIndex: number) => void;
+    /** Drop the "moved" flag for the given keys (or all) without touching edits/adds — e.g. reorder Cancel. */
+    clearMoved: (keys?: Iterable<ListEditorKey>) => void;
     /** Escape hatch: a row form (e.g. vuelidate) reports its own validity instead of `validate`. */
     registerValidity: (key: ListEditorKey, isValid: () => boolean) => () => void;
 }
 
 export declare type ListEditorKey = DocId | IntegerId | string;
 
-export declare const ListEditorValidationKey: InjectionKey<ListEditorValidationRegistry>;
-
-export declare interface ListEditorValidationRegistry {
-    register: (key: ListEditorKey, state: Ref<ListEditorValidationState> | ComputedRef<ListEditorValidationState>) => void;
-    unregister: (key: ListEditorKey) => void;
-}
-
 /** Per-row validity. `true` (or `{ valid: true }`) = VALID. Only `valid: false` blocks save. */
 export declare type ListEditorValidationResult = boolean | {
     valid: boolean;
@@ -1322,7 +1340,7 @@ export declare interface NestedListEditorHandle<TItem extends Record<string, any
     /** Amber: is this row added / edited / moved / reparented since the last commit? */
     isUnsaved: (key: ListEditorKey) => boolean;
     /** Red rail (gated): 'invalid' only once the row is unsaved or `validateAll()` ran. */
-    rowState: (item: TItem, key: ListEditorKey) => ListEditorValidationState;
+    rowState: (item: TItem, key: ListEditorKey, editing?: boolean) => ListEditorValidationState;
     /** Force-show all invalid rows + return whether the tree is valid. The save guard. */
     validateAll: () => boolean;
     /** Flattened ordered array (each row carrying its resolved position + parent key) for a full-DTO save. */
@@ -2097,6 +2115,25 @@ export declare function useFilterHelpers<F extends readonly MakeFilterOption<str
     } | null;
 };
 
+/**
+ * Wrap an entity-delete handler so it bypasses the unsaved-changes leave guard.
+ *
+ * An entity delete destroys the record together with any unsaved edits, so the "you have unsaved
+ * changes — really leave?" prompt that the delete's `router.push` would otherwise trigger is
+ * meaningless: the user already confirmed the delete, and there is nothing left to keep. Without this
+ * the delete runs, then the leave-guard fires on the post-delete navigation and choosing "stay" leaves
+ * the view on an already-deleted entity (system error). This acknowledges the guard right before the
+ * delete so the follow-up navigation proceeds without prompting. (QA 85050 batch 7 — BUG-08)
+ *
+ * If `onDelete` REJECTS (the delete failed and never navigated), the acknowledgement is undone
+ * immediately (`unacknowledge()`) so a subsequently-dirtied navigation is still guarded (M1) — the
+ * error is re-thrown so the caller's own handling runs. For this to catch failures, `onDelete` must
+ * let its error propagate (don't swallow it in the action's try/catch).
+ *
+ * Usage: `@delete-record="guardedDelete(() => onDelete(id))"` or wrap the handler once.
+ */
+export declare function useGuardedDelete<A extends unknown[], R>(guard: Pick<UseUnsavedChangesGuardApi, 'acknowledge' | 'unacknowledge'>, onDelete: (...args: A) => R): (...args: A) => R | Promise<Awaited<R>>;
+
 export declare function useJobApi<JobType extends JobBase = JobBase>(client: () => AxiosInstance, system: string): {
     useFetchJobList: () => UseApiFetchListReturnType<JobType[]>;
     fetchJob: (id: number) => Promise<JobType>;
@@ -2154,39 +2191,6 @@ export declare interface UseListEditorControllerOptions<TItem extends Record<str
     normalizeSaved?: (savedItems: TItem[]) => TItem[];
 }
 
-export declare function useListEditorItemValidation(options: UseListEditorItemValidationOptions): void;
-
-declare interface UseListEditorItemValidationOptions {
-    /**
-     * Stable identity of the row in the editor's v-model. Pass a getter so the
-     * composable can re-register if the key ever swaps.
-     */
-    key: () => ListEditorKey;
-    /**
-     * Reactive validation state. Common shape: a computed reading vuelidate's
-     * `v$.$dirty && v$.$invalid` and returning 'invalid' or null.
-     *
-     * Prefer `invalid` (+ optional `dirty`) below: it lets the editor surface the
-     * error once the row is unsaved without relying on mount-relative `$anyDirty`.
-     * `state` is kept for callers that report 'valid'/'warning' or custom logic.
-     */
-    state?: Ref<ListEditorValidationState> | ComputedRef<ListEditorValidationState> | (() => ListEditorValidationState);
-    /**
-     * Whether the row's data fails validation right now (e.g. `() => v$.value.$invalid`).
-     * When provided, the row is flagged 'invalid' as soon as it is invalid AND the
-     * user has had a chance to fix it — i.e. the row is unsaved (added / modified)
-     * or `dirty` below is true. Untouched rows on initial load stay clear so a
-     * persisted-but-invalid record does not light up red before any interaction.
-     */
-    invalid?: () => boolean;
-    /**
-     * Optional extra "has been interacted with" signal OR-ed with the editor's
-     * unsaved tracking (e.g. `() => v$.value.$anyDirty`). Useful when unsaved
-     * tracking is disabled on the editor.
-     */
-    dirty?: () => boolean;
-}
-
 export declare interface UseListEditorOptions {
     keyField?: string;
     positionField?: string;
@@ -2194,25 +2198,6 @@ export declare interface UseListEditorOptions {
     updatePosition?: boolean;
 }
 
-/**
- * Registers a row's vuelidate state with the surrounding list editor so the
- * row shows the red invalid rail (invalid + unsaved/dirty) instead of amber.
- *
- * This is the one blessed shape for row validity sentinels — domain sentinels
- * call their validation composable and delegate here:
- *
- * ```ts
- * const item = computed(() => props.modelValue)
- * const { v$ } = useReviewListItemValidation(item)
- * useListEditorVuelidateSentinel(v$, () => item.value.id ?? item.value.position)
- * ```
- *
- * `key` must return the same key the editor resolves for the row
- * (its `key-field`) or the item's own id/position — the editor's validation
- * registry accepts either.
- */
-export declare function useListEditorVuelidateSentinel(v$: Ref<VuelidateSentinelSource>, key: () => ListEditorKey): void;
-
 /**
  * Nested list editor core. Pure data behavior shared by ANestedSortableListEditor.
  * Works on a tree of `{ data, children, meta }` nodes — shape-compatible with the
@@ -2415,8 +2400,19 @@ declare interface UseUnsavedChangesGuardApi {
      * route/dialog/unload attempt proceeds without prompting. Useful right
      * before a programmatic navigation that the consumer has already
      * confirmed.
+     *
+     * The acknowledgement AUTO-EXPIRES after a few seconds if nothing consumes it
+     * (see `ACKNOWLEDGE_TTL_MS`): a delete that acknowledges up-front but then FAILS
+     * (throws, never navigates) must not leave the guard silently disarmed for the
+     * next unrelated navigation. Consuming it (a real leave) clears the timer.
      */
     acknowledge: () => void;
+    /**
+     * Cancel a pending `acknowledge()` (disarm). Call from a delete's failure path
+     * so a failed/aborted delete restores the guard immediately instead of waiting
+     * for the TTL. No-op if nothing is acknowledged.
+     */
+    unacknowledge: () => void;
 }
 
 declare interface UseUnsavedChangesGuardOptions {
@@ -2491,15 +2487,6 @@ declare interface ViewBodySlotProps<TItem extends Record<string, any>> {
     };
 }
 
-/**
- * Minimal surface of a vuelidate instance the sentinel reads — any
- * `useVuelidate()` return value is structurally assignable.
- */
-export declare interface VuelidateSentinelSource {
-    $invalid: boolean;
-    $anyDirty: boolean;
-}
-
 export { }
 
 declare global {