@omnitend/dashboard-for-laravel 0.27.0 → 0.29.0

package/dist/components/extended/DXTablePagination.vue.d.ts

@@ -0,0 +1,27 @@
+import type { PaginationData } from "./DXTable.vue";
+interface Props {
+    /** The active pagination metadata (client-side / inertia / provider). */
+    pagination: PaginationData;
+    /** The effective page size, shown in the selector. */
+    perPage: number;
+    /** Page sizes offered by the selector. */
+    perPageOptions: number[];
+    /** Whether to render the pager (still hidden when there is only one page). */
+    showPagination: boolean;
+    /** Whether to render the per-page selector. */
+    showPerPageSelector: boolean;
+    /** Singular item noun for the info line (e.g. "product"). */
+    singularItemName: string;
+    /** Plural item noun for the info line (e.g. "products"). */
+    pluralItemName: string;
+    /** Whether a column filter is active — gates the "Filtered from N" note. */
+    hasActiveFilters: boolean;
+}
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "page-change": (page: number) => any;
+    "per-page-change": (value: string | number | (string | number)[] | null) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onPage-change"?: ((page: number) => any) | undefined;
+    "onPer-page-change"?: ((value: string | number | (string | number)[] | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/composables/useResourceEditor.d.ts

@@ -0,0 +1,74 @@
+import { type Ref } from "vue";
+/**
+ * The subset of `DXTable`'s props the resource editor reads. Declared
+ * structurally (not imported from DXTable.vue) so the composable stays a
+ * lower-level dependency — DXTable imports the composable, not the reverse.
+ * DXTable's full `Props` is structurally assignable to this.
+ */
+export interface ResourceEditorProps<T = any> {
+    /** Field definitions for the edit/create modal (enables edit-on-row-click). */
+    editFields?: any[];
+    /** Tab definitions — only their `key` is read here (DXForm consumes the rest). */
+    editTabs?: Array<{
+        key: string;
+    }>;
+    /** Modal title, or a function of the edited row. */
+    editModalTitle?: string | ((item: any) => string);
+    /** `PUT` endpoint pattern for updates, e.g. `/api/products/:id`. */
+    editUrl?: string;
+    /** `GET` endpoint pattern to fetch the full record on open, e.g. `/api/products/:id`. */
+    showUrl?: string;
+    /** `DELETE` endpoint pattern, e.g. `/api/products/:id`. */
+    deleteUrl?: string;
+    /** `POST` endpoint for creating new items, e.g. `/api/products`. */
+    createUrl?: string;
+    /** Guard run before delete — a message short-circuits with a toast. */
+    deleteGuard?: (item: T) => string | null | undefined;
+}
+/**
+ * The events the editor emits back through DXTable's `emit`. Declared as the
+ * exact call signatures it uses (a subset of DXTable's emits) so DXTable's typed
+ * `emit` is structurally assignable here.
+ */
+export interface ResourceEditorEmit<T = any> {
+    (event: 'rowCreated', item: any, response: any): void;
+    (event: 'createError', error: any): void;
+    (event: 'rowUpdated', item: T, response: any): void;
+    (event: 'editError', item: T, error: any): void;
+    (event: 'rowDeleted', item: T, response: any): void;
+    (event: 'deleteError', item: T, error: any): void;
+}
+export interface UseResourceEditorOptions {
+    /** Invalidate whichever data source is active, after a successful CRUD op. */
+    refresh: () => void;
+    /** Singular item noun (e.g. "product") — for toasts and the modal title. */
+    singularItemName: Ref<string>;
+}
+/**
+ * The resource editor for `DXTable` — the create/edit/delete concern lifted out
+ * of the god-component (#129). Owns the edit-modal state, form seeding and
+ * visibility rules, the `showUrl` full-record fetch, submission (create `POST` /
+ * edit `PUT` / delete), the success/error toasts, and the edit-modal slot-key
+ * computeds. It never touches the table's data source, sort, filter, per-page
+ * or pagination state — the only coupling back to the table is the `refresh`
+ * callback it calls after a successful op.
+ *
+ * DXTable keeps `handleRowClick` (which emits `rowClicked` regardless) and calls
+ * `openEdit` from it; `openEdit` is a no-op unless `editFields` are set.
+ */
+export declare function useResourceEditor<T = any>(props: ResourceEditorProps<T>, emit: ResourceEditorEmit<T>, options: UseResourceEditorOptions): {
+    showEditModal: Ref<boolean, boolean>;
+    editForm: Ref<any, any>;
+    editFormInstanceKey: Ref<number, number>;
+    activeTabIndex: Ref<number, number>;
+    selectedItem: [T | null] extends [Ref<any, any>] ? import("@vue/shared").IfAny<Ref<any, any> & T, Ref<Ref<any, any> & T, Ref<any, any> & T>, Ref<any, any> & T> : Ref<import("vue").UnwrapRef<T> | null, T | import("vue").UnwrapRef<T> | null>;
+    isCreateMode: Ref<boolean, boolean>;
+    pendingAction: Ref<"delete" | "save" | null, "delete" | "save" | null>;
+    editLoading: Ref<boolean, boolean>;
+    computedModalTitle: import("vue").ComputedRef<string>;
+    openEdit: (item: T) => void;
+    openCreate: () => void;
+    save: () => Promise<void>;
+    cancel: () => void;
+    remove: () => Promise<void>;
+};