@modufolio/panel 0.1.0

package/dist/Components/Drawer/DrawerTabs.vue.d.ts

@@ -0,0 +1,42 @@
+import { DrawerTab } from './drawerTabs';
+type __VLS_Props = {
+    tabs: Array<DrawerTab | string>;
+    modelValue?: string;
+    ariaLabel?: string;
+    /** Keep visited panels mounted so their local state survives tab switches. */
+    keepAlive?: boolean;
+};
+declare var __VLS_2: `tab-${string}`, __VLS_3: {
+    tab: DrawerTab;
+    active: boolean;
+}, __VLS_10: {
+    activeKey: string;
+}, __VLS_13: string, __VLS_14: {
+    tab: DrawerTab;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_2>]?: (props: typeof __VLS_3) => any;
+} & {
+    [K in NonNullable<typeof __VLS_13>]?: (props: typeof __VLS_14) => any;
+} & {
+    actions?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (key: string) => any;
+    change: (key: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((key: string) => any) | undefined;
+    onChange?: ((key: string) => any) | undefined;
+}>, {
+    modelValue: string;
+    ariaLabel: string;
+    keepAlive: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/Drawer/NestedDrawerForm.vue.d.ts

@@ -0,0 +1,55 @@
+import { FieldConfig, FormState } from '../../Composables/useNestedDrawerForm';
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    fields: {
+        type: () => FieldConfig[];
+        required: true;
+    };
+    state: {
+        type: () => FormState;
+        required: true;
+    };
+    errors: {
+        type: () => Record<string, string>;
+        required: true;
+    };
+    serverError: {
+        type: () => string | null;
+        default: null;
+    };
+    saving: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: () => any;
+    "update:field": (field: string, value: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    fields: {
+        type: () => FieldConfig[];
+        required: true;
+    };
+    state: {
+        type: () => FormState;
+        required: true;
+    };
+    errors: {
+        type: () => Record<string, string>;
+        required: true;
+    };
+    serverError: {
+        type: () => string | null;
+        default: null;
+    };
+    saving: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSubmit?: (() => any) | undefined;
+    "onUpdate:field"?: ((field: string, value: unknown) => any) | undefined;
+}>, {
+    saving: boolean;
+    serverError: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Drawer/drawerFieldGrid.d.ts

@@ -0,0 +1,25 @@
+/**
+ * One entry in a {@link DrawerFieldGrid}.
+ *
+ * Declared here rather than inside the SFC so consumers can import the type
+ * (`<script setup>` cannot export type declarations).
+ */
+export interface DrawerField {
+    /** Stable identifier — also the per-field slot name (`#field-{key}`). */
+    key: string;
+    label: string;
+    /** Display text; already stringified, with blanks rendered as an em dash. */
+    value: string;
+    /** Claim the full row rather than one column. */
+    wide?: boolean;
+    /** The value before stringification, for slot consumers. */
+    raw?: unknown;
+    /**
+     * A thumbnail to render instead of `value` — recognised from a raw value
+     * shaped `{ thumbnail_url, url }` (the convention presenters already use
+     * for a media reference, e.g. a post's cover). Absent for every other
+     * field, including a plain URL string, which stays text: only a presenter
+     * that opted into the object shape gets the image treatment.
+     */
+    image?: string;
+}

package/dist/Components/Drawer/drawerTabs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A section in a {@link DrawerTabs} bar.
+ *
+ * Declared here rather than inside the SFC so consumers can import the type
+ * (`<script setup>` cannot export type declarations).
+ */
+export interface DrawerTab {
+    /** Stable identifier — also the panel slot name. */
+    key: string;
+    label: string;
+    /** Registered icon name, rendered before the label. */
+    icon?: string;
+    /** Count or short string shown in a pill after the label. Hidden when null/undefined/''. */
+    badge?: number | string | null;
+    disabled?: boolean;
+}

package/dist/Components/Drawer/useDrawerPage.d.ts

@@ -0,0 +1,34 @@
+import { ComputedRef } from 'vue';
+import { DrawerContext } from './useIsDrawer';
+/**
+ * Context-aware page data accessor for components that render
+ * in both full-page and drawer contexts.
+ *
+ * Inspired by Tofandel/inertia-vue3-modal's custom usePage():
+ * components call useDrawerPage() instead of usePage() and get
+ * the correct data regardless of context — no `if (isDrawer)` checks.
+ *
+ * When rendered as a full page:
+ *   - Returns the standard Inertia page props
+ *   - `isDrawer` is false
+ *   - `drawerContext` is null
+ *
+ * When rendered inside a drawer:
+ *   - `props` returns the drawer item's data
+ *   - `parentProps` gives access to the parent page's props
+ *   - `isDrawer` is true
+ *   - `drawerContext` has level, close, back
+ *
+ * Usage:
+ *   const { props, isDrawer, parentProps } = useDrawerPage()
+ */
+export declare function useDrawerPage(): {
+    /** The entity data: drawer item data when in a drawer, page props otherwise */
+    props: ComputedRef<Record<string, unknown>>;
+    /** Whether this component is inside a drawer */
+    isDrawer: ComputedRef<boolean>;
+    /** The Inertia page props (always the parent page, even inside a drawer) */
+    parentProps: ComputedRef<Record<string, unknown>>;
+    /** Drawer context (level, close, back) — null when not in a drawer */
+    drawerContext: DrawerContext | false;
+};

package/dist/Components/Drawer/useDrawerStack.d.ts

@@ -0,0 +1,93 @@
+import { ComputedRef } from 'vue';
+/**
+ * A section the server declared for this frame. Absent or empty means the
+ * frame renders as one undivided body, which is what every frame did before
+ * tabs existed.
+ */
+export interface StackItemTab {
+    key: string;
+    label: string;
+    /** 'custom' bodies are rendered by the page, not the shared components. */
+    type: 'details' | 'relation' | 'custom';
+    /** Details tabs only: the relation lists rendered inline beneath the grid. */
+    sections?: StackItemTab[];
+    /**
+     * Details tabs only: which record keys this grid shows and in what order,
+     * as `key => label override`. Absent means every eligible key.
+     */
+    fields?: Record<string, string | null>;
+    /** Relation tabs only: whether a row drills into a frame or visits a page. */
+    navigation?: 'drawer' | 'visit';
+    /** Row list styling: one bordered list, or a card per row. */
+    variant?: 'list' | 'cards';
+    deletable?: boolean;
+    /** Row drill-down pattern over `{parent}` and `{id}`. */
+    recordUrl?: string | null;
+    /** Relation tabs only: the key in `data` holding the rows. */
+    source?: string;
+    primary?: string | null;
+    secondary?: string | null;
+    /** Short classifying value shown before the primary, in its own column. */
+    category?: string | null;
+    empty?: string;
+    badge?: number | null;
+    addable?: boolean;
+    addLabel?: string;
+}
+/**
+ * One frame of the drawer stack, as the server builds it.
+ *
+ * The single definition: DrawerStack.vue used to declare its own copy, and the
+ * two had already drifted (only one knew about record navigation). Slot types
+ * come from here now, so a field the server adds is visible to every consumer.
+ */
+export interface StackItem {
+    type: string;
+    data: Record<string, any>;
+    title?: string;
+    description?: string;
+    width?: string;
+    key?: string;
+    href?: string;
+    nextRecordUrl?: string;
+    previousRecordUrl?: string;
+    tabs?: StackItemTab[];
+    /**
+     * Which frame renders this item: the side panel a record is read in, or a
+     * centred dialog for one decision or one short form.
+     *
+     * Absent means `drawer`, so every frame built before dialogs existed keeps
+     * rendering exactly as it did.
+     */
+    presentation?: 'drawer' | 'dialog';
+}
+/**
+ * Composable for URL-driven hierarchical drawer stack navigation.
+ *
+ * The stack is driven by the server via Inertia props — no client-side state management needed.
+ * The URL represents the full navigation state, so browser back/forward works natively.
+ *
+ * All visits include the X-Inertia-Drawer-Stack header so the server can detect
+ * drawer context for redirect interception (inspired by Tofandel/inertia-vue3-modal).
+ *
+ * Usage in a page component:
+ *
+ *   const props = defineProps({ stack: Array })
+ *   const { stack, isOpen, push, pop, closeAll } = useDrawerStack(props, '/contacts')
+ *
+ * The server controller builds the stack array and passes it as an Inertia prop.
+ * Each `push()` call navigates to a deeper URL; `pop()` goes back.
+ */
+export declare function useDrawerStack(props: {
+    stack?: StackItem[];
+}, baseUrl: string): {
+    stack: ComputedRef<StackItem[]>;
+    isOpen: ComputedRef<boolean>;
+    depth: ComputedRef<number>;
+    topItem: ComputedRef<StackItem | null>;
+    push: (href: string) => void;
+    pushWithParams: (id: number | string, params?: Record<string, string>) => void;
+    pop: () => void;
+    closeAll: () => void;
+    closeFrom: (index: number) => void;
+};

package/dist/Components/Drawer/useFocusedStackRow.d.ts

@@ -0,0 +1,22 @@
+import { ComputedRef } from 'vue';
+import { StackItem } from './useDrawerStack';
+/**
+ * Index of the table row the drawer stack is currently showing, for
+ * `<SchemaTable :external-focused-row-index>`.
+ *
+ * The drawer's record pagination (arrow keys) changes the stack without a
+ * click, so the highlighted row must be derived from the top stack item
+ * rather than from the row that opened the drawer.
+ *
+ * Returns -1 when no drawer is open, the top item is a different `type`
+ * (e.g. a nested drawer), or the record is not in the current page of rows.
+ * Omitting `type` matches any top item by id — safe with UUID ids, where a
+ * nested drawer's record can never collide with a row of the listing.
+ *
+ *   const focusedRow = useFocusedStackRow(props, 'submission', () => props.submissions.data)
+ */
+export declare function useFocusedStackRow(props: {
+    stack?: StackItem[];
+}, type: string | undefined, records: () => Array<{
+    id?: unknown;
+}> | undefined): ComputedRef<number>;

package/dist/Components/Drawer/useIsDrawer.d.ts

@@ -0,0 +1,66 @@
+import { Ref } from 'vue';
+import { StackItem } from './useDrawerStack';
+/**
+ * Injection keys for drawer context.
+ *
+ * Inspired by Tofandel/inertia-vue3-modal's provide/inject pattern:
+ * any component rendered inside a drawer can detect its context
+ * without prop drilling.
+ */
+export declare const DRAWER_CONTEXT_KEY = "DrawerContext";
+export declare const DRAWER_STACK_KEY = "DrawerStackContext";
+/**
+ * HTTP header sent with drawer navigation requests.
+ * Mirrors the PHP DrawerStack::HEADER constant.
+ * Used by DrawerLink and useDrawerStack to signal the server
+ * that this request originated from within a drawer.
+ */
+export declare const DRAWER_HEADER = "X-Inertia-Drawer-Stack";
+export interface DrawerContext {
+    /** The current stack item for this drawer */
+    item: StackItem;
+    /** Zero-based depth index of this drawer in the stack */
+    level: number;
+    /** Close this drawer (and all above it) */
+    close: () => void;
+    /** Go back one level */
+    back: () => void;
+}
+export interface DrawerStackContext {
+    /** Full stack array (shallow — avoids deep reactivity on large data) */
+    stack: Ref<StackItem[]>;
+    /** Base URL of the parent listing page */
+    baseUrl: string;
+    /** Push a new entity onto the stack */
+    push: (href: string) => void;
+    /** Pop the top drawer */
+    pop: () => void;
+    /** Close the entire stack */
+    closeAll: () => void;
+}
+/**
+ * Detect if the current component is rendered inside a drawer.
+ *
+ * Returns the DrawerContext for the nearest ancestor drawer,
+ * or `false` if not inside a drawer.
+ *
+ * Usage:
+ *   const drawer = useIsDrawer()
+ *   if (drawer) {
+ *     console.log(drawer.item.type, drawer.level)
+ *   }
+ */
+export declare function useIsDrawer(): DrawerContext | false;
+/**
+ * Access the drawer stack context from any descendant component.
+ *
+ * Returns the DrawerStackContext with push/pop/closeAll methods,
+ * or `null` if not inside a DrawerStack.
+ *
+ * Usage:
+ *   const stackCtx = useDrawerStackContext()
+ *   if (stackCtx) {
+ *     stackCtx.push('/contacts/12/organization/4')
+ *   }
+ */
+export declare function useDrawerStackContext(): DrawerStackContext | null;

package/dist/Components/Drawer/visitDrawer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * One way to navigate the drawer stack.
+ *
+ * The drawer protocol is a convention held in three places at once — a header
+ * string, an `only: ['stack']` partial reload, and the preserve flags that
+ * keep the page underneath mounted. Every caller that re-typed that trio was
+ * a chance to get one third of it wrong, and one did: a hand-written
+ * `X-Drawer` header meant the server never took the drawer path, while
+ * `only: ['stack']` still fetched enough for the drawer to *look* right.
+ *
+ * So this is the only place the trio is written. Anything that opens, drills
+ * into, or closes a drawer goes through here.
+ */
+export interface VisitDrawerOptions {
+    /**
+     * Appended to the URL — the listing's filter/sort state, so a drawer's
+     * record pagination stays inside the set the reader was looking at.
+     */
+    queryParams?: Record<string, unknown>;
+    /** Inertia partial-reload keys. Defaults to the stack alone. */
+    only?: string[];
+    preserveState?: boolean;
+    preserveScroll?: boolean;
+    replace?: boolean;
+}
+/**
+ * The visit options a drawer navigation needs, for the rare caller that must
+ * hand them to Inertia itself (a form submission, say) rather than navigate.
+ */
+export declare function drawerVisitOptions(options?: VisitDrawerOptions): {
+    headers: {
+        "X-Inertia-Drawer-Stack": string;
+    };
+    replace?: boolean | undefined;
+    only: string[];
+    preserveState: boolean;
+    preserveScroll: boolean;
+};
+/**
+ * Append query parameters to a URL.
+ *
+ * Empty strings are kept: the server distinguishes "this filter is set to
+ * nothing" from "this filter was not sent", and dropping them silently reset
+ * filters when a drawer opened.
+ */
+export declare function withDrawerParams(url: string, params?: Record<string, unknown>): string;
+/** Navigate the drawer stack: open, drill into, go back, or close. */
+export declare function visitDrawer(url: string, options?: VisitDrawerOptions): void;

package/dist/Components/Fields/BelongsToSelect.vue.d.ts

@@ -0,0 +1,247 @@
+import { PropType } from 'vue';
+declare var __VLS_1: {
+    option: any;
+};
+type __VLS_Slots = {} & {
+    option?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor | null)[];
+        default: null;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    helperText: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Options array or endpoint for fetching options
+     */
+    options: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    endpoint: {
+        type: StringConstructor;
+        default: null;
+    };
+    /**
+     * Server-side search endpoint for a relation too large to preload.
+     *
+     * Answers `?q=` with matches and `?values=` with the labels for identifiers
+     * the field already holds — the second is what lets an edit form show its
+     * current selection when the list it came from was never sent.
+     */
+    searchUrl: {
+        type: StringConstructor;
+        default: null;
+    };
+    /**
+     * Offer an explicit way back to "no selection".
+     *
+     * A lookup can otherwise only ever tighten: once a value is chosen, the
+     * input shows its label and there is nothing to press to mean "none". Set
+     * for optional relations.
+     */
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    relationship: {
+        type: StringConstructor;
+        default: null;
+    };
+    /**
+     * Keys for option object
+     */
+    valueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    labelKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Search configuration
+     */
+    searchable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Allow creating new records
+     */
+    allowCreate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Minimum characters before searching
+     */
+    minSearchLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+    create: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor | null)[];
+        default: null;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    helperText: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Options array or endpoint for fetching options
+     */
+    options: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    endpoint: {
+        type: StringConstructor;
+        default: null;
+    };
+    /**
+     * Server-side search endpoint for a relation too large to preload.
+     *
+     * Answers `?q=` with matches and `?values=` with the labels for identifiers
+     * the field already holds — the second is what lets an edit form show its
+     * current selection when the list it came from was never sent.
+     */
+    searchUrl: {
+        type: StringConstructor;
+        default: null;
+    };
+    /**
+     * Offer an explicit way back to "no selection".
+     *
+     * A lookup can otherwise only ever tighten: once a value is chosen, the
+     * input shows its label and there is nothing to press to mean "none". Set
+     * for optional relations.
+     */
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    relationship: {
+        type: StringConstructor;
+        default: null;
+    };
+    /**
+     * Keys for option object
+     */
+    valueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    labelKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Search configuration
+     */
+    searchable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Allow creating new records
+     */
+    allowCreate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Minimum characters before searching
+     */
+    minSearchLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    width: {
+        readonly type: StringConstructor;
+        readonly default: "full";
+        readonly validator: (v: string) => boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onCreate?: ((...args: any[]) => any) | undefined;
+}>, {
+    required: boolean;
+    modelValue: string | number | null;
+    label: string;
+    placeholder: string;
+    error: string;
+    disabled: boolean;
+    width: string;
+    options: any[];
+    searchable: boolean;
+    searchUrl: string;
+    endpoint: string;
+    relationship: string;
+    helperText: string;
+    clearable: boolean;
+    valueKey: string;
+    labelKey: string;
+    allowCreate: boolean;
+    minSearchLength: 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;
+    };
+};