@omnitend/dashboard-for-laravel 0.4.7

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

@@ -0,0 +1,37 @@
+import type { Navigation } from '../../types/navigation';
+type __VLS_Props = {
+    navigation: Navigation;
+    currentUrl: string;
+    collapsed?: boolean;
+    hidden?: boolean;
+    title?: string;
+};
+declare var __VLS_1: {
+    collapsed: boolean;
+    title: string;
+}, __VLS_3: {
+    item: import("../..").NavigationItem;
+    isActive: boolean;
+    collapsed: boolean;
+};
+type __VLS_Slots = {} & {
+    brand?: (props: typeof __VLS_1) => any;
+} & {
+    link?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    toggle: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: (() => any) | undefined;
+}>, {
+    collapsed: boolean;
+    hidden: boolean;
+    title: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,31 @@
+import type { DefineFormReturn } from "../../composables/defineForm";
+interface Props {
+    /** Form object from defineForm */
+    form: DefineFormReturn<any>;
+    /** Submit button text */
+    submitText?: string;
+    /** Submit button loading text */
+    submitLoadingText?: string;
+    /** Show submit button */
+    showSubmit?: boolean;
+}
+declare var __VLS_10: string | number, __VLS_11: any;
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_10>]?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submit: () => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onSubmit?: (() => any) | undefined;
+}>, {
+    submitText: string;
+    submitLoadingText: string;
+    showSubmit: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,190 @@
+export type FilterType = 'text' | 'select' | 'number' | 'date' | false;
+export interface FilterOption {
+    value: string;
+    text: string;
+}
+export interface TableField {
+    key: string;
+    label?: string;
+    sortable?: boolean;
+    hint?: string;
+    filter?: FilterType;
+    filterOptions?: FilterOption[];
+    filterPlaceholder?: string;
+    [key: string]: any;
+}
+export interface PaginationData {
+    current_page: number;
+    per_page: number;
+    total: number;
+    from: number;
+    to: number;
+    last_page?: number;
+    total_unfiltered?: number;
+}
+export interface BTableSortBy {
+    key: string;
+    order?: 'asc' | 'desc';
+}
+export interface BTableProviderContext {
+    sortBy?: BTableSortBy[];
+    filter?: string;
+    currentPage: number;
+    perPage: number;
+}
+export type BTableProvider<T = any> = (context: Readonly<BTableProviderContext>) => Promise<T[] | undefined> | T[] | undefined;
+export interface EditTab {
+    /** Unique key for this tab */
+    key: string;
+    /** Display label (optional, auto-derived from key if omitted) */
+    label?: string;
+    /** Field keys to display in this tab (from editFields) */
+    fieldKeys: string[];
+    /** Conditional display (optional) */
+    when?: boolean | ((item: any) => boolean);
+    /** Lazy load tab content (optional, default false) */
+    lazy?: boolean;
+}
+export interface Props<TItem = any> {
+    /** Table title */
+    title?: string;
+    /** Name for item (singular) - automatically pluralized (e.g., "product" → "products") */
+    itemName?: string;
+    /** Table data items (Inertia mode) */
+    items?: TItem[];
+    /** Provider function for API mode (alternative to items/apiUrl) */
+    provider?: BTableProvider<TItem>;
+    /** API endpoint URL for auto-provider mode (alternative to provider function) */
+    apiUrl?: string;
+    /** Table field definitions */
+    fields: TableField[];
+    /** Sort configuration (v-model support) */
+    sortBy?: BTableSortBy[];
+    /** Filter values (v-model support) - key is field key, value is filter string */
+    filters?: Record<string, string>;
+    /** Dynamic filter options from server - key is field key, value is array of values */
+    filterValues?: Record<string, string[]>;
+    /** Inertia route URL (if provided, handles navigation automatically) */
+    inertiaUrl?: string;
+    /** Loading/busy state (v-model support) */
+    busy?: boolean;
+    /** Loading state (deprecated, use busy instead) */
+    loading?: boolean;
+    /** Loading text */
+    loadingText?: string;
+    /** Error message */
+    error?: string | null;
+    /** Pagination data (Inertia mode) */
+    pagination?: PaginationData;
+    /** Show pagination controls */
+    showPagination?: boolean;
+    /** Show per-page selector */
+    showPerPageSelector?: boolean;
+    /** Per-page options for selector */
+    perPageOptions?: number[];
+    /** Current page (for provider mode) */
+    currentPage?: number;
+    /** Items per page (for provider mode, v-model support) */
+    perPage?: number;
+    /** Striped rows */
+    striped?: boolean;
+    /** Hover effect on rows */
+    hover?: boolean;
+    /** Responsive table */
+    responsive?: boolean;
+    /** Fluid container */
+    fluid?: boolean;
+    /** Container CSS class */
+    containerClass?: string;
+    /** Column size (Bootstrap grid) */
+    columnSize?: string | number;
+    /** Form field definitions for edit modal (if provided, enables edit on row click) */
+    editFields?: any[];
+    /** Tab definitions for organizing edit modal content */
+    editTabs?: EditTab[];
+    /** Edit modal title (can be function for dynamic titles) */
+    editModalTitle?: string | ((item: any) => string);
+    /** Edit modal size */
+    editModalSize?: 'sm' | 'md' | 'lg' | 'xl';
+    /** API endpoint pattern for updates (e.g., "/api/products/:id") */
+    editUrl?: string;
+    /** API endpoint pattern for deletions (e.g., "/api/products/:id") */
+    deleteUrl?: string;
+}
+declare const _default: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:sortBy"?: ((sortBy: BTableSortBy[]) => any) | undefined;
+        readonly "onUpdate:busy"?: ((busy: boolean) => any) | undefined;
+        readonly onRowClicked?: ((item: T, index: number, event: MouseEvent) => any) | undefined;
+        readonly onPageChange?: ((page: number) => any) | undefined;
+        readonly onSortChange?: ((sort: {
+            key: string;
+            order: "asc" | "desc";
+        }) => any) | undefined;
+        readonly onFilterChange?: ((filters: Record<string, string>) => any) | undefined;
+        readonly onPerPageChange?: ((perPage: number) => any) | undefined;
+        readonly onRowUpdated?: ((item: T, response: any) => any) | undefined;
+        readonly onEditError?: ((item: T, error: any) => any) | undefined;
+        readonly onRowDeleted?: ((item: T, response: any) => any) | undefined;
+        readonly onDeleteError?: ((item: T, error: any) => any) | undefined;
+        readonly "onUpdate:filters"?: ((filters: Record<string, string>) => any) | undefined;
+        readonly "onUpdate:perPage"?: ((perPage: number) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:sortBy" | "onUpdate:busy" | "onRowClicked" | "onPageChange" | "onSortChange" | "onFilterChange" | "onPerPageChange" | "onRowUpdated" | "onEditError" | "onRowDeleted" | "onDeleteError" | "onUpdate:filters" | "onUpdate:perPage"> & Props<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        refresh: () => void;
+    }>): void;
+    attrs: any;
+    slots: {
+        [x: string]: ((props: any) => any) | undefined;
+    } & {
+        [x: string]: ((props: any) => any) | undefined;
+    } & {
+        [x: `tab-content(${string})`]: ((props: {
+            item: import("@vue/reactivity").DistributeRef<[T | null] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & T, import("vue").Ref<import("vue").Ref<any, any> & T, import("vue").Ref<any, any> & T>, import("vue").Ref<any, any> & T> : import("vue").Ref<import("vue").UnwrapRef<T> | null, T | import("vue").UnwrapRef<T> | null>>;
+            tab: EditTab;
+        }) => any) | undefined;
+    } & {
+        [x: `tab-before(${string})`]: ((props: {
+            item: import("@vue/reactivity").DistributeRef<[T | null] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & T, import("vue").Ref<import("vue").Ref<any, any> & T, import("vue").Ref<any, any> & T>, import("vue").Ref<any, any> & T> : import("vue").Ref<import("vue").UnwrapRef<T> | null, T | import("vue").UnwrapRef<T> | null>>;
+            tab: EditTab;
+        }) => any) | undefined;
+    } & {
+        [x: `edit-span(${string})`]: ((props: {
+            item: import("@vue/reactivity").DistributeRef<[T | null] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & T, import("vue").Ref<import("vue").Ref<any, any> & T, import("vue").Ref<any, any> & T>, import("vue").Ref<any, any> & T> : import("vue").Ref<import("vue").UnwrapRef<T> | null, T | import("vue").UnwrapRef<T> | null>>;
+            value: any;
+            update: (v: any) => any;
+            close: () => void;
+        }) => any) | undefined;
+    } & {
+        [x: `edit-value(${string})`]: ((props: {
+            item: import("@vue/reactivity").DistributeRef<[T | null] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & T, import("vue").Ref<import("vue").Ref<any, any> & T, import("vue").Ref<any, any> & T>, import("vue").Ref<any, any> & T> : import("vue").Ref<import("vue").UnwrapRef<T> | null, T | import("vue").UnwrapRef<T> | null>>;
+            value: any;
+            update: (v: any) => any;
+            field: any;
+        }) => any) | undefined;
+    } & {
+        [x: `edit-value(${string})`]: ((props: {
+            item: import("@vue/reactivity").DistributeRef<[T | null] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & T, import("vue").Ref<import("vue").Ref<any, any> & T, import("vue").Ref<any, any> & T>, import("vue").Ref<any, any> & T> : import("vue").Ref<import("vue").UnwrapRef<T> | null, T | import("vue").UnwrapRef<T> | null>>;
+            value: any;
+            update: (v: any) => any;
+            field: any;
+        }) => any) | undefined;
+    } & {
+        [x: `tab-after(${string})`]: ((props: {
+            item: import("@vue/reactivity").DistributeRef<[T | null] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & T, import("vue").Ref<import("vue").Ref<any, any> & T, import("vue").Ref<any, any> & T>, import("vue").Ref<any, any> & T> : import("vue").Ref<import("vue").UnwrapRef<T> | null, T | import("vue").UnwrapRef<T> | null>>;
+            tab: EditTab;
+        }) => any) | undefined;
+    } & {
+        header?: (props: {}) => any;
+    };
+    emit: ((evt: "update:sortBy", sortBy: BTableSortBy[]) => void) & ((evt: "update:busy", busy: boolean) => void) & ((evt: "rowClicked", item: T, index: number, event: MouseEvent) => void) & ((evt: "pageChange", page: number) => void) & ((evt: "sortChange", sort: {
+        key: string;
+        order: "asc" | "desc";
+    }) => void) & ((evt: "filterChange", filters: Record<string, string>) => void) & ((evt: "perPageChange", perPage: number) => void) & ((evt: "rowUpdated", item: T, response: any) => void) & ((evt: "editError", item: T, error: any) => void) & ((evt: "rowDeleted", item: T, response: any) => void) & ((evt: "deleteError", item: T, error: any) => void) & ((evt: "update:filters", filters: Record<string, string>) => void) & ((evt: "update:perPage", perPage: number) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/composables/defineForm.d.ts

@@ -0,0 +1,35 @@
+import { type UseFormReturn } from "./useForm";
+import type { FieldDefinition } from "../types";
+/**
+ * Extended field definition that includes default value
+ */
+export interface FormFieldDefinition<TValue = any> extends FieldDefinition {
+    /** Default/initial value for the field */
+    default: TValue;
+}
+/**
+ * Infer data type from field definitions
+ */
+type InferFormData<TFields extends readonly FormFieldDefinition[]> = {
+    [K in TFields[number] as K["key"]]: K["default"];
+};
+/**
+ * Return type for defineForm
+ */
+export interface DefineFormReturn<TData extends Record<string, any>> {
+    form: UseFormReturn<TData>;
+    fields: FieldDefinition[];
+}
+/**
+ * Define a form with type-safe field definitions.
+ * Reduces duplication by inferring initial values from field definitions.
+ *
+ * @example
+ * const { form, fields } = defineForm([
+ *   { key: "email", type: "email", label: "Email", default: "", required: true },
+ *   { key: "password", type: "password", label: "Password", default: "", required: true },
+ *   { key: "remember", type: "checkbox", label: "Remember me", default: false },
+ * ] as const);
+ */
+export declare function defineForm<const TFields extends readonly FormFieldDefinition[]>(fieldDefinitions: TFields): DefineFormReturn<InferFormData<TFields>>;
+export {};

package/dist/composables/useForm.d.ts

@@ -0,0 +1,46 @@
+import { type ComputedRef, type WritableComputedRef } from "vue";
+import { type ApiError } from "../utils/api";
+export interface ValidationErrors {
+    [key: string]: string[];
+}
+export type FormError = ApiError;
+export interface FormSubmitOptions<TPayload = unknown, TResponse = unknown> {
+    onSuccess?: (data: TResponse) => void;
+    onError?: (error: FormError) => void;
+    onBefore?: (payload: TPayload) => void;
+    onFinish?: () => void;
+    transform?: (payload: TPayload) => unknown;
+    preserveErrors?: boolean;
+    resetOnSuccess?: boolean;
+    signal?: AbortSignal;
+}
+export interface FormState<TData extends Record<string, any>> {
+    data: TData;
+    errors: ValidationErrors;
+    processing: boolean;
+    message: string;
+    touched: Record<string, boolean>;
+    recentlySuccessful: boolean;
+    shouldShowMessage: boolean;
+}
+export interface UseFormReturn<TData extends Record<string, any>> extends FormState<TData> {
+    hasErrors: ComputedRef<boolean>;
+    hasError: (field: keyof TData | string) => boolean;
+    getError: (field: keyof TData | string) => string;
+    getState: (field: keyof TData | string) => true | false | null;
+    setErrors: (errors?: ValidationErrors) => void;
+    setMessage: (message: string) => void;
+    clearErrors: () => void;
+    clearError: (field: keyof TData | string) => void;
+    reset: (only?: Array<keyof TData>) => void;
+    field: <K extends keyof TData>(key: K) => WritableComputedRef<TData[K]>;
+    fields: {
+        [K in keyof TData]: WritableComputedRef<TData[K]>;
+    };
+    submit: <TResponse = unknown>(method: "get" | "post" | "put" | "patch" | "delete", url: string, options?: FormSubmitOptions<TData, TResponse>) => Promise<TResponse>;
+    post: <TResponse = unknown>(url: string, options?: FormSubmitOptions<TData, TResponse>) => Promise<TResponse>;
+    put: <TResponse = unknown>(url: string, options?: FormSubmitOptions<TData, TResponse>) => Promise<TResponse>;
+    patch: <TResponse = unknown>(url: string, options?: FormSubmitOptions<TData, TResponse>) => Promise<TResponse>;
+    delete: <TResponse = unknown>(url: string, options?: FormSubmitOptions<TData, TResponse>) => Promise<TResponse>;
+}
+export declare function useForm<TData extends Record<string, any>>(initialData?: TData): UseFormReturn<TData>;

package/dist/composables/useToast.d.ts

@@ -0,0 +1 @@
+export { useToast } from 'bootstrap-vue-next';