@modufolio/panel 0.1.0

package/dist/Components/Table/useTableRowFocus.d.ts

@@ -0,0 +1,27 @@
+import { TableRecord } from './tableTypes';
+interface RowFocusOptions {
+    /** -1 means "nothing external is driving the highlight". */
+    externalIndex: () => number;
+    loading: () => boolean;
+    bulkActionsEnabled: () => boolean;
+    /** The rendered rows, which is what an index refers to. */
+    visibleRecords: () => TableRecord[];
+    toggleSelect: (record: TableRecord) => void;
+    onActivate: (record: TableRecord) => void;
+    /** Root element, so focus stays inside this table when several are mounted. */
+    root: () => HTMLElement | null;
+}
+/**
+ * Keyboard navigation and the highlighted row.
+ *
+ * The highlight lags the index deliberately: a drawer opening or a record
+ * paginating pushes several indexes through in quick succession, and moving
+ * the highlight for each one reads as a flicker.
+ */
+export declare function useTableRowFocus(options: RowFocusOptions): {
+    focusedRowIndex: import('vue').ComputedRef<number>;
+    stableFocusedRowIndex: import('vue').Ref<number, number>;
+    handleTableKeyDown: (event: KeyboardEvent) => void;
+    handleRowFocus: (index: number) => void;
+};
+export {};

package/dist/Components/Table/useTableSelection.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+import { TableRecord } from './tableTypes';
+/**
+ * Row selection for the bulk-actions bar.
+ *
+ * Records are held by identity rather than by id: a table's rows are the very
+ * objects handed to it, so nothing has to know which field is the key.
+ */
+export declare function useTableSelection(records: () => TableRecord[]): {
+    selectedRecords: Ref<TableRecord[], TableRecord[]>;
+    allSelected: import('vue').ComputedRef<boolean>;
+    isSelected: (record: TableRecord) => boolean;
+    toggleSelect: (record: TableRecord) => void;
+    toggleSelectAll: () => void;
+};

package/dist/Components/Table/useTableTree.d.ts

@@ -0,0 +1,23 @@
+import { TableRecord } from './tableTypes';
+interface TreeOptions {
+    /** Off for tables whose records are a flat list. */
+    enabled: () => boolean;
+    records: () => TableRecord[];
+    /** Field on each record holding its nesting level (0 = top-level). */
+    depthKey: () => string;
+}
+/**
+ * Collapsible hierarchy for tables whose records arrive in depth-first order
+ * (a page tree, say). Parentage is read off the depth of the *next* row, so
+ * nothing needs a parent id.
+ */
+export declare function useTableTree({ enabled, records, depthKey }: TreeOptions): {
+    collapsedRecords: import('vue').Reactive<Set<TableRecord>>;
+    treeParents: import('vue').ComputedRef<Set<TableRecord>>;
+    showTreeToggle: import('vue').ComputedRef<boolean>;
+    allTreeCollapsed: import('vue').ComputedRef<boolean>;
+    visibleRecords: import('vue').ComputedRef<TableRecord[]>;
+    toggleCollapse: (record: TableRecord) => void;
+    toggleAllTree: () => void;
+};
+export {};

package/dist/Components/Widgets/StatCard.vue.d.ts

@@ -0,0 +1,81 @@
+declare var __VLS_11: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        required: true;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+    change: {
+        type: NumberConstructor;
+        default: null;
+    };
+    icon: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: null;
+    };
+    format: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        required: true;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+    change: {
+        type: NumberConstructor;
+        default: null;
+    };
+    icon: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: null;
+    };
+    format: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    change: number;
+    description: string;
+    format: string;
+    icon: string | Record<string, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Widgets/StatsWidget.vue.d.ts

@@ -0,0 +1,27 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    columns: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: unknown) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    columns: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: unknown) => boolean;
+    };
+}>> & Readonly<{}>, {
+    columns: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Wizard/Wizard.vue.d.ts

@@ -0,0 +1,99 @@
+import { PropType } from 'vue';
+interface WizardStep {
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+declare var __VLS_2: `step-${number}`, __VLS_3: {
+    currentStep: number;
+    stepIndex: number;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_2>]?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    steps: {
+        type: PropType<WizardStep[]>;
+        required: true;
+        validator: (steps: unknown) => boolean;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    skippable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    submitting: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    submitLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    showCancel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    cancelLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+    submit: (...args: any[]) => void;
+    cancel: (...args: any[]) => void;
+    "step-change": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    steps: {
+        type: PropType<WizardStep[]>;
+        required: true;
+        validator: (steps: unknown) => boolean;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    skippable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    submitting: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    submitLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    showCancel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    cancelLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onSubmit?: ((...args: any[]) => any) | undefined;
+    onCancel?: ((...args: any[]) => any) | undefined;
+    "onStep-change"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: number;
+    submitting: boolean;
+    showCancel: boolean;
+    submitLabel: string;
+    cancelLabel: string;
+    skippable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Composables/useAsyncData.d.ts

@@ -0,0 +1,48 @@
+import { Ref, WatchSource } from 'vue';
+/**
+ * Reactive async-data primitive — the panel's standard way to run a fetch and
+ * expose its lifecycle. Inspired by Solid's `createResource`: one place owns
+ * `{ data, loading, error }`, requests are guarded against stale/post-teardown
+ * resolution, and cleanup is automatic via the current effect scope.
+ *
+ * The fetcher receives a `{ signal }` context first (pass it to `apiFetch` so
+ * a superseded or torn-down request is actually cancelled, not just ignored),
+ * then whatever arguments `execute` was called with:
+ *
+ *   const { data, loading, error, execute } = useAsyncData(
+ *     ({ signal }, id: number) => apiFetch(`/panel/api/tags/media/${id}`, { signal }),
+ *   )
+ *   await execute(mediaId)
+ *
+ * Errors are captured on `error` (and passed to `onError`) rather than thrown,
+ * so callers can branch on `error.value` without a try/catch at every site.
+ * An abort is not an error: it never touches `error` or `onError`.
+ */
+/** Per-request context handed to the fetcher. */
+export interface FetchContext {
+    /** Aborted when the request is superseded or the owning scope is disposed. */
+    signal: AbortSignal;
+}
+export declare function isAbortError(err: unknown): boolean;
+export interface UseAsyncDataOptions<T> {
+    /** Run the fetcher once on creation (with no arguments). Default false. */
+    immediate?: boolean;
+    /** Seed value for `data` before the first successful fetch. */
+    initialData?: T | null;
+    /** Refetch (re-running the last call) whenever any source changes. */
+    watch?: WatchSource | WatchSource[];
+    /** Called with the error when a fetch rejects. */
+    onError?: (error: unknown) => void;
+}
+export interface UseAsyncData<T, A extends unknown[]> {
+    data: Ref<T | null>;
+    error: Ref<unknown>;
+    loading: Ref<boolean>;
+    /** Run the fetcher with the given args; resolves with the data (or null on error). */
+    execute: (...args: A) => Promise<T | null>;
+    /** Re-run the fetcher with the arguments from the last `execute` call. */
+    refresh: () => Promise<T | null>;
+    /** Optimistically set `data` locally (value or updater), e.g. before a write. */
+    mutate: (updater: (T | null) | ((current: T | null) => T | null)) => void;
+}
+export declare function useAsyncData<T, A extends unknown[] = []>(fetcher: (ctx: FetchContext, ...args: A) => Promise<T>, options?: UseAsyncDataOptions<T>): UseAsyncData<T, A>;

package/dist/Composables/useDeleteConfirmation.d.ts

@@ -0,0 +1,86 @@
+/**
+ * One record's deletion, from "are you sure?" to done.
+ *
+ * A bare confirm() asks the user to guarantee something only the server knows.
+ * Given a `previewUrl`, this asks the server first and hands the answer to the
+ * dialog: what would go with the record, or what is protecting it. Without one
+ * it degrades to a plain confirmation — which is what a page with no preview
+ * endpoint had anyway, now at least consistent with the rest of the panel.
+ *
+ * Deliberately not tied to generated resources: most pages that delete things
+ * are hand-written, and they are the ones still calling confirm().
+ */
+export interface DeletionPlan {
+    blocked: boolean;
+    /** Human labels of the records standing in the way. */
+    protected?: string[];
+    /** Nested tree of what would be deleted. */
+    nested?: Array<{
+        label: string;
+        type?: string;
+        children?: any[];
+    }>;
+    counts?: Record<string, number>;
+    linkCounts?: Record<string, number>;
+    /** True when the record is only trashed, so nothing is at stake. */
+    soft?: boolean;
+}
+export interface DeleteConfirmationState<T = any> {
+    open: boolean;
+    record: T | null;
+    plan: DeletionPlan | null;
+    /** The preview is in flight. */
+    loading: boolean;
+    /** The delete itself is in flight. */
+    deleting: boolean;
+    error: string | null;
+}
+export interface UseDeleteConfirmationOptions<T = any> {
+    /**
+     * Where to ask what deleting `record` would do. Omit for a plain
+     * confirmation.
+     */
+    previewUrl?: (record: T) => string;
+    /**
+     * A plan stated up front, for a page whose server has no preview endpoint
+     * but whose behaviour is known anyway — most usefully `{ soft: true }` when
+     * the delete is reversible. Without it the dialog says "cannot be undone",
+     * which for a soft delete is a lie in the frightening direction.
+     *
+     * Ignored when `previewUrl` is given: the server's answer wins over a guess.
+     */
+    plan?: DeletionPlan | ((record: T) => DeletionPlan);
+    /** Performs the delete once confirmed. */
+    onConfirm: (record: T) => void | Promise<void>;
+    /** Shown when there is no preview to describe consequences with. */
+    message?: (record: T) => string;
+}
+export declare function useDeleteConfirmation<T = any>(options: UseDeleteConfirmationOptions<T>): {
+    state: {
+        open: boolean;
+        record: import('vue').UnwrapRef<T> | null;
+        plan: {
+            blocked: boolean;
+            protected?: string[]
+            /** Nested tree of what would be deleted. */
+             | undefined;
+            nested?: {
+                label: string;
+                type?: string | undefined;
+                children?: any[] | undefined;
+            }[] | undefined;
+            counts?: Record<string, number> | undefined;
+            linkCounts?: Record<string, number>
+            /** True when the record is only trashed, so nothing is at stake. */
+             | undefined;
+            soft?: boolean | undefined;
+        } | null;
+        loading: boolean;
+        deleting: boolean;
+        error: string | null;
+    };
+    request: (record: T) => Promise<void>;
+    confirm: () => Promise<void>;
+    close: () => void;
+    message: ((record: T) => string) | undefined;
+};

package/dist/Composables/useDragReorder.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+/**
+ * Composable for drag-and-drop reordering of items.
+ *
+ * @param itemsRef  - The reactive array of items to reorder
+ * @param onReorder - Callback when reorder happens, receives the new order
+ */
+export declare function useDragReorder<T>(itemsRef: Ref<T[]>, onReorder?: (items: T[]) => void): {
+    dragSourceIndex: Ref<number | null>;
+    dragOverIndex: Ref<number | null>;
+    handleDrop: (targetIndex: number) => void;
+};

package/dist/Composables/useFieldSaver.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+export type SaveStatus = null | 'saving' | 'saved' | 'error';
+export interface UseFieldSaver<A extends unknown[]> {
+    saveStatus: Ref<SaveStatus>;
+    save: (...args: A) => Promise<void>;
+    debouncedSave: (...args: A) => void;
+}
+/**
+ * Save a form field with debouncing and transient status tracking.
+ *
+ * The debounce timer and the "reset status to idle" timer are kept separate so
+ * they can't cancel each other, and both are cleared when the owning scope is
+ * disposed so a trailing save/reset can't run against an unmounted component.
+ */
+export declare function useFieldSaver<A extends unknown[] = unknown[]>(saveFunction: (...args: A) => Promise<unknown>, debounceMs?: number): UseFieldSaver<A>;

package/dist/Composables/useFocusTrap.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+export declare function useFocusTrap(containerRef: Ref<HTMLElement | null>): {
+    activate: () => void;
+    deactivate: () => void;
+};

package/dist/Composables/useLocalStoragePersistence.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+interface UseLocalStoragePersistenceOptions<T> {
+    key: string;
+    defaultValue: T;
+    serialize?: (value: T) => string;
+    deserialize?: (value: string) => T;
+    onError?: (error: Error) => void;
+}
+interface UseLocalStoragePersistenceReturn<T> {
+    value: Ref<T>;
+    setValue: (newValue: T) => void;
+    removeValue: () => void;
+}
+/**
+ * Generic composable for persisting reactive values to localStorage with error handling
+ */
+export declare function useLocalStoragePersistence<T>({ key, defaultValue, serialize, deserialize, onError, }: UseLocalStoragePersistenceOptions<T>): UseLocalStoragePersistenceReturn<T>;
+export {};

package/dist/Composables/useNestedDrawerForm.d.ts

@@ -0,0 +1,58 @@
+import { ComputedRef, Ref } from 'vue';
+export interface FieldConfig {
+    name: string;
+    label: string;
+    type: 'text' | 'email' | 'select' | 'textarea' | 'number' | 'hidden' | 'date' | 'time' | 'datetime' | 'checkbox';
+    placeholder?: string;
+    required?: boolean;
+    maxlength?: number;
+    /** Bounds for date/time/datetime inputs, in the input's own value format. */
+    min?: string;
+    max?: string;
+    options?: Array<{
+        value: string | number;
+        label: string;
+    }>;
+    grid?: 'full' | 'half';
+}
+export interface FormState {
+    visible: boolean;
+    saving: boolean;
+    mode: 'create' | 'edit';
+    /**
+     * Identifier of the record the form hangs off, and of the row being edited.
+     *
+     * Both accept strings: a parent is addressed by uuid in this panel, and only
+     * some children keep a numeric id. These were typed `number`, which every
+     * caller had always violated — the contact uuid is a string — and nothing
+     * caught it until the drawer's tab declaration made the call sites explicit.
+     */
+    parentId: string | number | null;
+    recordId: string | number | null;
+    [key: string]: unknown;
+}
+export interface UseNestedDrawerFormReturn {
+    state: FormState;
+    errors: Ref<Record<string, string>>;
+    serverError: Ref<string | null>;
+    isValid: () => boolean;
+    openForm: (parentId: string | number, recordId?: string | number, initialData?: Record<string, unknown>) => void;
+    closeForm: () => void;
+    resetForm: () => void;
+    getFormData: () => Record<string, unknown>;
+    /**
+     * True while the open form holds edits that have not been submitted —
+     * what an "unsaved changes" guard asks before letting a navigation
+     * (including Logout) discard them. False whenever the form is closed:
+     * a closed form's leftover state is not something the user can see or
+     * lose. Also false while a submit is in flight, for the same reason.
+     */
+    isDirty: ComputedRef<boolean>;
+    setFieldValue: (field: string, value: unknown) => void;
+    submit: (onSubmit: (data: Record<string, unknown>, mode: 'create' | 'edit') => Promise<void>) => Promise<void>;
+}
+/**
+ * Composable for managing nested drawer form state and submission
+ * Handles form visibility, validation, and data submission
+ */
+export declare function useNestedDrawerForm(fields: FieldConfig[], defaultValues?: Record<string, unknown>): UseNestedDrawerFormReturn;

package/dist/Composables/usePagination.d.ts

@@ -0,0 +1,23 @@
+import { Ref, ComputedRef } from 'vue';
+type PaginationItem = {
+    type: 'page';
+    key: string;
+    value: number;
+} | {
+    type: 'ellipsis';
+    key: string;
+};
+interface UsePaginationOptions {
+    pagination: Ref<{
+        total?: number;
+        totalPages?: number;
+    }>;
+    currentPage: Ref<number>;
+    onNavigate: (page: number) => void;
+}
+interface UsePaginationReturn {
+    paginationItems: ComputedRef<PaginationItem[]>;
+    goToPage: (page: number) => void;
+}
+export declare function usePagination(options: UsePaginationOptions): UsePaginationReturn;
+export {};

package/dist/Composables/usePendingKeys.d.ts

@@ -0,0 +1,30 @@
+import { ComputedRef } from 'vue';
+/**
+ * Keyed in-flight tracking: which records have a request running right now.
+ *
+ * One boolean per component answers "is anything saving"; a list needs "is
+ * *this row* saving", or every row shows the same spinner and a double-click
+ * on row A blocks row B. Keying the pending state is the difference —
+ * the same reason frappe-ui's write actions expose `isLoading(name)` rather
+ * than a bare flag.
+ *
+ *   const { isPending, run } = usePendingKeys()
+ *   const toggle = (file) => run(file.id, async () => { ... })
+ *   // template: <Spinner v-if="isPending(file.id)" />
+ *
+ * `run` also guards re-entry: a key with a request in flight refuses a
+ * second one, which is what a double-click should mean.
+ */
+export interface UsePendingKeys<K = string | number> {
+    /** True while `run` is executing for this key. */
+    isPending: (key: K) => boolean;
+    /** True while anything at all is in flight. */
+    anyPending: ComputedRef<boolean>;
+    /**
+     * Execute `fn` tracked under `key`. Resolves with its result, or with
+     * `undefined` when the key was already pending and the call was refused.
+     * Rejections propagate after the key is released.
+     */
+    run: <T>(key: K, fn: () => Promise<T>) => Promise<T | undefined>;
+}
+export declare function usePendingKeys<K = string | number>(): UsePendingKeys<K>;

package/dist/Composables/useQuery.d.ts

@@ -0,0 +1,61 @@
+import { Ref } from 'vue';
+import { FetchContext } from './useAsyncData';
+/**
+ * Keyed server-state cache — `useAsyncData` plus sharing. Components that ask
+ * for the same key share one `data` ref, one in-flight request and one cached
+ * result, with stale-while-revalidate semantics: a new subscriber gets the
+ * cached value instantly while a background refetch runs. Fresh payloads are
+ * `reconcile`d into the cached object in place, so identity survives
+ * revalidation and only effects reading changed fields re-run.
+ *
+ *   const counts = useQuery('library:counts',
+ *     ({ signal }) => apiFetch('/panel/api/library/counts', { signal }))
+ *
+ * Keys are hierarchical by convention (`'tags:search:cats'`);
+ * `invalidateQueries('tags')` marks `tags` and every `tags:*` entry stale and
+ * refetches the ones with live subscribers. Call it after a mutation that
+ * changes what a query would return.
+ */
+type Fetcher<T> = (ctx: FetchContext) => Promise<T>;
+export interface UseQueryOptions<T> {
+    /**
+     * How long (ms) a cached result is served without a background revalidation
+     * when a new subscriber appears. Default 0: always revalidate (SWR).
+     */
+    staleTime?: number;
+    /** Seed value for `data` before the first successful fetch. */
+    initialData?: T;
+}
+export interface UseQueryReturn<T> {
+    data: Ref<T | null>;
+    error: Ref<unknown>;
+    /** True only during the first fetch, before any data exists. */
+    loading: Ref<boolean>;
+    /** True whenever a fetch (including a background revalidation) is running. */
+    fetching: Ref<boolean>;
+    /** Fetch now (deduped against an already in-flight request). */
+    refresh: () => Promise<void>;
+    /** Optimistically set the shared cached data (value or updater). */
+    mutate: (updater: (T | null) | ((current: T | null) => T | null)) => void;
+}
+export declare function useQuery<T>(key: string, fetcher: Fetcher<T>, options?: UseQueryOptions<T>): UseQueryReturn<T>;
+/**
+ * Mark matching queries stale and refetch the ones that currently have
+ * subscribers. `key` matches itself and everything below it (`key` and
+ * `key:*`); omit it to invalidate everything.
+ *
+ * If a matching entry is already fetching, its in-flight request is left
+ * alone (not aborted) and exactly one follow-up fetch is queued for once it
+ * settles — so any number of invalidate calls arriving in a burst (e.g. one
+ * per file in a batch upload, each firing on its own network completion)
+ * coalesce into at most one extra request per entry, instead of each call
+ * aborting and restarting the previous one. The returned promise resolves
+ * once every matching entry's current fetch (in-flight or freshly started)
+ * settles — for an entry that gets coalesced, that's the in-flight fetch,
+ * not the queued follow-up; nothing in the app depends on finer-grained
+ * timing than that.
+ */
+export declare function invalidateQueries(key?: string): Promise<void>;
+/** Drop every cache entry. Intended for tests. */
+export declare function clearQueryCache(): void;
+export {};

package/dist/Composables/useReconciled.d.ts

@@ -0,0 +1,22 @@
+import { Ref } from 'vue';
+/**
+ * A locally-mutable reactive copy of server-provided data that stays in sync
+ * without losing identity.
+ *
+ * Replaces the `reactive({ ...props.media })` + `watch(() => props.media, …)`
+ * rebuild pattern: when `source` changes (Inertia re-sends the prop) the new
+ * data is reconciled into the existing copy in place, so unchanged rows keep
+ * their object identity and transient UI state survives navigation.
+ *
+ *   const media = useReconciled(() => props.media)
+ *   media.value.rating = 5            // local edits are fine
+ *   // …server re-sends props.media → reconciled in, local identity preserved
+ */
+export declare function useReconciled<T extends object>(source: () => T, key?: string): Ref<T>;
+/**
+ * Like {@link useReconciled} but returns a `reactive` object instead of a ref —
+ * a drop-in replacement for `reactive({ ...props.x })` that additionally stays
+ * in sync with the source. Access members directly (`state.title`) with no
+ * `.value`.
+ */
+export declare function useReconciledReactive<T extends object>(source: () => T, key?: string): T;