@knitify/vue 2.1.0 → 2.2.0

package/dist/types/components/ArticleList/types.d.ts

@@ -15,10 +15,10 @@ export type KArticleListItemProps = {
     disabled?: boolean;
     /** Excerpt, clamped to three lines by core. The default slot overrides it. */
     excerpt?: string;
-    /** Forces the hover fill, for previews. */
+    /** Forces the hover fill and the actions slot open, for previews. */
     hovered?: boolean;
     href?: string;
-    /** Sprite id of the trailing icon. */
+    /** Sprite id of the trailing chevron, shown when there is no actions slot. */
     icon?: string;
     /** Article title. The `title` slot overrides it. */
     title?: string;
@@ -32,9 +32,16 @@ export type KArticleListSlots = {
     default?(): any;
 };
 export type KArticleListItemSlots = {
+    /**
+     * The overflow trigger, typically a `KDropdown` around a meatball
+     * `KButton`. Replaces the chevron. Core fades it in on hover or focus, and
+     * keeps it shown while the dropdown is open. Not rendered on a disabled row.
+     */
+    actions?(): any;
     date?(): any;
     /** The excerpt. */
     default?(): any;
+    /** The trailing chevron. Ignored when the actions slot is filled. */
     icon?(): any;
     title?(): any;
 };

package/dist/types/components/ButtonGroup/KButtonGroup.vue.d.ts

@@ -0,0 +1,11 @@
+import type { KButtonGroupSlots } from './types';
+type __VLS_Slots = KButtonGroupSlots;
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, 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/types/components/ButtonGroup/types.d.ts

@@ -0,0 +1,7 @@
+export type KButtonGroupSlots = {
+    /**
+     * `KButton`s, or wrappers around one — a `KDropdown` whose toggle is a
+     * `KButton` makes a split button.
+     */
+    default?(): any;
+};

package/dist/types/components/Chat/KChatPrompt.vue.d.ts

@@ -6,12 +6,12 @@ type __VLS_ModelProps = {
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    stop: () => any;
     submit: (value: string) => any;
+    stop: () => any;
     "update:modelValue": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    onStop?: (() => any) | undefined;
     onSubmit?: ((value: string) => any) | undefined;
+    onStop?: (() => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
     disabled: boolean;

package/dist/types/components/ChatDock/KChatDock.vue.d.ts

@@ -21,16 +21,16 @@ declare const __VLS_base: import("vue").DefineComponent<KChatDockProps, {
     togglePanel: typeof togglePanel;
     refilter: typeof refilter;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    select: (id: string, opened: boolean) => any;
     search: (query: string) => any;
+    select: (id: string, opened: boolean) => any;
     reflow: () => any;
     launcher: () => any;
     compose: () => any;
     panel: (open: boolean) => any;
     activate: (id: string) => any;
 }, string, import("vue").PublicProps, Readonly<KChatDockProps> & Readonly<{
-    onSelect?: ((id: string, opened: boolean) => any) | undefined;
     onSearch?: ((query: string) => any) | undefined;
+    onSelect?: ((id: string, opened: boolean) => any) | undefined;
     onReflow?: (() => any) | undefined;
     onLauncher?: (() => any) | undefined;
     onCompose?: (() => any) | undefined;

package/dist/types/components/DataTable/KDataTable.vue.d.ts

@@ -0,0 +1,71 @@
+import type { KTableSize } from '../Table/types';
+import type { KDataTableActionLabels, KDataTableColumn, KDataTableEmits, KDataTableRowKey, KDataTableSettingsLabels, KDataTableSlots, KDataTableSortLabels, KDataTableSortRule } from './types';
+declare const __VLS_export: <T extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(Omit<import("../types.js").KTableProps, "size" | "striped"> & {
+        actionLabels?: Partial<KDataTableActionLabels>;
+        columns?: KDataTableColumn<T>[] | undefined;
+        emptyLabel?: string;
+        filterLabel?: string;
+        loading?: boolean;
+        maxHeight?: string;
+        nextLabel?: string;
+        pageSize?: number;
+        pinStart?: number;
+        prevLabel?: string;
+        rowKey?: string | ((row: T) => KDataTableRowKey) | undefined;
+        rows?: T[] | undefined;
+        searchPlaceholder?: string;
+        selectable?: boolean;
+        settingsLabel?: string;
+        settingsLabels?: Partial<KDataTableSettingsLabels>;
+        sortLabel?: string;
+        sortLabels?: Partial<KDataTableSortLabels>;
+        sortOptions?: import("../types.js").KSelectOption[];
+        total: number;
+    } & {
+        page?: number;
+        search?: string;
+        selected?: KDataTableRowKey[];
+        sort?: KDataTableSortRule[];
+        hiddenColumns?: string[];
+        size?: KTableSize;
+        striped?: boolean;
+    }) & {
+        onResize?: ((widths: number[]) => any) | undefined;
+        onAction?: ((action: string, row: T, column: {
+            key: string;
+            label: string;
+            resizable?: boolean;
+            sortable?: boolean;
+        } & {
+            type: "link";
+        } & {
+            to: (row: T) => import("vue-router").RouteLocationRaw;
+        }, payload?: unknown) => any) | undefined;
+        "onUpdate:page"?: ((value: number) => any) | undefined;
+        "onUpdate:hiddenColumns"?: ((value: string[]) => any) | undefined;
+        "onUpdate:size"?: ((value: KTableSize) => any) | undefined;
+        "onUpdate:striped"?: ((value: boolean) => any) | undefined;
+        "onUpdate:search"?: ((value: string) => any) | undefined;
+        "onUpdate:selected"?: ((value: KDataTableRowKey[]) => any) | undefined;
+        "onUpdate:sort"?: ((value: KDataTableSortRule[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        /** Hands every column back to automatic layout. */
+        reset: () => void | undefined;
+    }>) => void;
+    attrs: any;
+    slots: KDataTableSlots<T>;
+    emit: KDataTableEmits<T> & (((event: "update:page", value: number) => void) & ((event: "update:hiddenColumns", value: string[]) => void) & ((event: "update:size", value: KTableSize) => void) & ((event: "update:striped", value: boolean) => void) & ((event: "update:search", value: string) => void) & ((event: "update:selected", value: KDataTableRowKey[]) => void) & ((event: "update:sort", value: KDataTableSortRule[]) => void));
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/DataTable/KDataTableLinkCell.vue.d.ts

@@ -0,0 +1,21 @@
+import type { KDataTableCellComponentProps } from './types';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<KDataTableCellComponentProps<T, "link"> & {
+        onAction?: ((action: string, payload?: unknown) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "action", action: string, payload?: unknown) => void;
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/DataTable/KDataTableSettings.vue.d.ts

@@ -0,0 +1,32 @@
+import type { KTableSize } from '../Table/types';
+import type { KDataTableColumn, KDataTableSettingsLabels } from './types';
+type __VLS_Props = {
+    columns: KDataTableColumn[];
+    labels: KDataTableSettingsLabels;
+};
+type __VLS_Slots = {
+    default?(): any;
+};
+type __VLS_ModelProps = {
+    'hiddenColumns'?: string[];
+    'size'?: KTableSize;
+    'striped'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:hiddenColumns": (value: string[]) => any;
+    "update:size": (value: KTableSize) => any;
+    "update:striped": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:hiddenColumns"?: ((value: string[]) => any) | undefined;
+    "onUpdate:size"?: ((value: KTableSize) => any) | undefined;
+    "onUpdate:striped"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, 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/types/components/DataTable/KDataTableSort.vue.d.ts

@@ -0,0 +1,17 @@
+import type { KSelectOption } from '../Select/types';
+import type { KDataTableSortLabels, KDataTableSortRule } from './types';
+type __VLS_Props = {
+    labels: KDataTableSortLabels;
+    options: KSelectOption[];
+};
+type __VLS_ModelProps = {
+    modelValue?: KDataTableSortRule[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: KDataTableSortRule[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: KDataTableSortRule[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/DataTable/columnTypes.d.ts

@@ -0,0 +1,19 @@
+import { type Component } from 'vue';
+import type { KDataTableColumnType } from './types';
+/**
+ * Makes `component` render the cells of every column whose `type` is `type`,
+ * in every KDataTable. Register before the app mounts — tables already on
+ * screen don't pick up a type registered later. Registering a name again
+ * replaces its component, built-in `link` included.
+ *
+ * Declare the type in `KDataTableColumnTypes` first; `type` only accepts the
+ * names declared there.
+ */
+export declare function registerColumnType(type: KDataTableColumnType, component: Component): void;
+/**
+ * The component registered for `type`. With none, its cells fall back to
+ * plain text, and the first lookup warns so a missing `registerColumnType`
+ * call is noticed. Not gated on a dev flag: the library is prebuilt, so its
+ * own build would decide that, not the consumer's.
+ */
+export declare function resolveColumnType(type: string): Component | undefined;

package/dist/types/components/DataTable/keys.d.ts

@@ -0,0 +1,9 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+import type { KDataTableActionLabels } from './types';
+/** The `link` column type's menu text when `actionLabels` leaves an entry out. */
+export declare const DEFAULT_ACTION_LABELS: KDataTableActionLabels;
+export interface DataTableContext {
+    /** The resolved menu text for `link` cells, defaults filled in. */
+    actionLabels: ComputedRef<KDataTableActionLabels>;
+}
+export declare const dataTableKey: InjectionKey<DataTableContext>;

package/dist/types/components/DataTable/types.d.ts

@@ -0,0 +1,269 @@
+import type { RouteLocationRaw } from 'vue-router';
+import type { KSelectOption } from '../Select/types';
+import type { KTableProps } from '../Table/types';
+type KDataTableColumnBase = {
+    /** The row field shown in this column, and the `cell-{key}` slot's name. */
+    key: string;
+    /** Header text. */
+    label: string;
+    /** Gives the header a drag handle for resizing the column. */
+    resizable?: boolean;
+    /** Offered in the sort popover's "Sort by". Defaults to `true`. */
+    sortable?: boolean;
+};
+/**
+ * Every column type, keyed by the name a column's `type` takes, mapped to the
+ * extra options a column of that type requires. Add your own by augmenting it
+ * — with the same `<T>` — and registering a component for each:
+ *
+ * ```ts
+ * declare module '@knitify/vue' {
+ *   interface KDataTableColumnTypes<T> {
+ *     rating: { max: number }     // a column of this type requires `max`
+ *     currency: {}                // no options of its own
+ *   }
+ * }
+ * registerColumnType('rating', RatingCell)
+ * ```
+ *
+ * `T` is the row type, for options that take the row, like `link`'s `to`.
+ */
+export interface KDataTableColumnTypes<T = any> {
+    /**
+     * The value links to a route. The cell also gets a meatball button, shown
+     * on hover (always, on touch screens), opening a menu with View (which
+     * follows the same route) and Delete. The link and View emit `view` through
+     * `action`; Delete emits `delete`.
+     */
+    link: {
+        /** Where the cell links to, and where View goes. */
+        to: (row: T) => RouteLocationRaw;
+    };
+}
+/** Every value `type` takes — the built-in types and any you declare. */
+export type KDataTableColumnType = keyof KDataTableColumnTypes;
+/** A column that shows the value as plain text. */
+export type KDataTableTextColumn = KDataTableColumnBase & {
+    type?: undefined;
+};
+/** A column of one type, carrying that type's options. */
+export type KDataTableTypedColumn<T = any, K extends KDataTableColumnType = KDataTableColumnType> = {
+    [Type in K]: KDataTableColumnBase & {
+        type: Type;
+    } & KDataTableColumnTypes<T>[Type];
+}[K];
+export type KDataTableLinkColumn<T = any> = KDataTableTypedColumn<T, 'link'>;
+/**
+ * One column. `type` picks the component its cells render with; leave it out
+ * for plain text. A `cell-{key}` slot still overrides any type.
+ */
+export type KDataTableColumn<T = any> = KDataTableTextColumn | KDataTableTypedColumn<T>;
+/**
+ * What a column type's component receives as props. Type its own with the
+ * column type it renders, e.g. `KDataTableCellComponentProps<Task, 'rating'>`,
+ * and `column` carries that type's options.
+ */
+export type KDataTableCellComponentProps<T = any, K extends KDataTableColumnType = KDataTableColumnType> = {
+    row: T;
+    /** `row[column.key]`. */
+    value: any;
+    column: KDataTableTypedColumn<T, K>;
+    /** The row's position on the current page. */
+    index: number;
+};
+/**
+ * What a column type's component may emit. An `action` comes out of the table
+ * as its own `action` event, with the row and column added.
+ */
+export type KDataTableCellComponentEmits = {
+    action: [action: string, payload?: unknown];
+};
+/** `link`'s actions are `view` and `delete`; your column types add their own. */
+export type KDataTableRowAction = string;
+export type KDataTableActionLabels = {
+    /** Accessible name of the meatball button. */
+    menu: string;
+    view: string;
+    delete: string;
+};
+export type KDataTableRowKey = string | number;
+export type KDataTableSortOrder = 'asc' | 'desc';
+/** One "Sort by … Order by …" line of the sort popover. */
+export type KDataTableSortRule = {
+    key: string;
+    order: KDataTableSortOrder;
+};
+export type KDataTableSortLabels = {
+    sortBy: string;
+    orderBy: string;
+    ascending: string;
+    descending: string;
+    add: string;
+    remove: string;
+};
+export type KDataTableSettingsLabels = {
+    columns: string;
+    columnsTitle: string;
+    rowHeight: string;
+    single: string;
+    double: string;
+    triple: string;
+    rowStyle: string;
+    striped: string;
+};
+/**
+ * A `KTable` framed by a toolbar (search; filter, sort and settings popovers;
+ * and a pager) and a footer (pagination). It renders controls, not data
+ * operations: the rows are shown as given, so slice, search and sort them —
+ * client- or server-side — from `page`, `pageSize`, `search` and `sort`.
+ */
+export type KDataTableProps<T = any> = Omit<KTableProps, 'size' | 'striped'> & {
+    /** Overrides any of a `link` column's menu text. */
+    actionLabels?: Partial<KDataTableActionLabels>;
+    /**
+     * Generates the header and a row per entry of `rows`. Leave it out and put
+     * your own `<thead>`/`<tbody>` in the default slot instead — that markup
+     * gets no checkbox column.
+     */
+    columns?: KDataTableColumn<T>[];
+    /** Shown in place of the rows when `rows` is empty. */
+    emptyLabel?: string;
+    /** Text of the filter button. Defaults to `Filter`. */
+    filterLabel?: string;
+    /**
+     * Shows a skeleton in every cell in place of the rows — as many rows as
+     * are currently shown, or a full page when there are none. Applies to
+     * `columns` and `rows`; custom markup in the default slot is left as is.
+     */
+    loading?: boolean;
+    /**
+     * Caps the table's height and scrolls it inside the frame — what a
+     * `stickyHeader` sticks to. Any CSS length, e.g. `480px`.
+     */
+    maxHeight?: string;
+    /** Accessible name of the next-page buttons. */
+    nextLabel?: string;
+    /** Rows per page. Defaults to 10. */
+    pageSize?: number;
+    /**
+     * How many leading data columns stay put while the table scrolls sideways,
+     * up to 4. The checkbox column is pinned along with them and isn't counted.
+     */
+    pinStart?: number;
+    /** Accessible name of the previous-page buttons. */
+    prevLabel?: string;
+    /** The field — or a function — giving each row a unique key. Defaults to `id`. */
+    rowKey?: string | ((row: T) => KDataTableRowKey);
+    /** The current page's rows, shown as given. */
+    rows?: T[];
+    /** Defaults to `Search`. */
+    searchPlaceholder?: string;
+    /**
+     * Leads each generated row with a checkbox, plus a select-all in the
+     * header, bound to `v-model:selected`. Defaults to `true`.
+     */
+    selectable?: boolean;
+    /** Text of the settings button. Defaults to `Settings`. */
+    settingsLabel?: string;
+    /** Overrides any of the settings menu's text. */
+    settingsLabels?: Partial<KDataTableSettingsLabels>;
+    /** Text of the sort button. Defaults to `Sort`. */
+    sortLabel?: string;
+    /** Overrides any of the sort popover's text. */
+    sortLabels?: Partial<KDataTableSortLabels>;
+    /**
+     * What "Sort by" offers. Defaults to the sortable `columns`; pass it to
+     * offer fields that aren't shown, e.g. "Updated at".
+     */
+    sortOptions?: KSelectOption[];
+    /** Number of rows across every page. Drives the pager and pagination. */
+    total: number;
+};
+export type KDataTableEmits<T = any> = {
+    /** A column was resized. Carries every column's width in px. */
+    (event: 'resize', widths: number[]): void;
+    /**
+     * A column type's component reported an action on its row. For `link`,
+     * `view` fires once the router has moved — from the link itself or the
+     * menu's View — and not when a guard cancels it, nor for a click that
+     * opens a new tab or window instead; `delete` does nothing
+     * else, so confirm and remove the row here. `payload` is whatever the cell
+     * sent along, if anything.
+     */
+    (event: 'action', action: KDataTableRowAction, row: T, column: KDataTableTypedColumn<T>, payload?: unknown): void;
+};
+/** What the pager and pagination slots get to build their own controls. */
+export type KDataTablePageState = {
+    /** The current page, kept within range. */
+    page: number;
+    pageCount: number;
+    pageSize: number;
+    /** 1-based position of the page's first row, or 0 with no rows. */
+    from: number;
+    /** 1-based position of the page's last row. */
+    to: number;
+    total: number;
+    /** Moves to a page; out-of-range targets are ignored. */
+    go: (page: number) => void;
+};
+export type KDataTableCellProps<T = any> = {
+    row: T;
+    /** `row[column.key]`. */
+    value: any;
+    /** The row's position on the current page. */
+    index: number;
+};
+/**
+ * Every built-in control sits in its own slot, so any one can be replaced or
+ * — with an empty `<template #filter />` — removed. The `*-start` and
+ * `*-end` slots add components beside them without replacing anything.
+ */
+export type KDataTableSlots<T = any> = {
+    /**
+     * Your own `<thead>`/`<tbody>`, used instead of `columns` and `rows`.
+     */
+    default?(): any;
+    /** A column's cells, e.g. `#cell-status` for a badge. Defaults to the value. */
+    [cell: `cell-${string}`]: ((props: KDataTableCellProps<T>) => any) | undefined;
+    /** A column's header content, e.g. `#header-title`. */
+    [header: `header-${string}`]: ((props: {
+        column: KDataTableColumn;
+    }) => any) | undefined;
+    /** Replaces the `emptyLabel` text. */
+    empty?(): any;
+    /** Leads the toolbar, e.g. an "Add Task" `KButtonGroup`. */
+    'toolbar-start'?(): any;
+    /** Replaces the search field. */
+    search?(props: {
+        search: string;
+        update: (value: string) => void;
+    }): any;
+    /** The filter button's popover panel. */
+    'filter-content'?(): any;
+    /** Replaces the filter button and its popover. */
+    filter?(): any;
+    /** Replaces the sort popover's panel. Defaults to the sort rules. */
+    'sort-content'?(): any;
+    /** Replaces the sort button and its popover. */
+    sort?(): any;
+    /**
+     * Replaces the settings menu — columns, row height and row style. Pass a
+     * `KDropdownMenu`.
+     */
+    'settings-content'?(): any;
+    /** `KDropdownItem`s added below the settings menu's own. */
+    'settings-items'?(): any;
+    /** Replaces the settings button and its menu. */
+    settings?(): any;
+    /** Follows the settings button. */
+    'toolbar-end'?(): any;
+    /** Replaces the "1–10 of 325" pager on the toolbar's right. */
+    pager?(props: KDataTablePageState): any;
+    /** `<tr>`s placed in the `<tfoot>` above the pagination row. */
+    summary?(): any;
+    /** The footer's left side, e.g. an "Add Task" button. */
+    'footer-start'?(): any;
+    /** Replaces the pagination on the footer's right. */
+    pagination?(props: KDataTablePageState): any;
+};
+export {};

package/dist/types/components/Dialog/KDialogHost.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/Dialog/KDialogItem.vue.d.ts

@@ -0,0 +1,16 @@
+import type { KDialogRequest } from './types';
+/**
+ * One dialog raised through `useDialog()`. Internal to KDialogHost, which
+ * mounts one per request it shows and unmounts it on `done` — once the request
+ * is answered and the exit transition has finished.
+ */
+type __VLS_Props = {
+    request: KDialogRequest;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    done: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDone?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/Dialog/types.d.ts

@@ -0,0 +1,61 @@
+import type { VNodeChild } from 'vue';
+import type { Intent } from '../../types';
+/**
+ * Body text. A render function rather than an HTML string, so markup such as a
+ * bold item name never passes user content through `innerHTML`.
+ */
+export type KDialogMessage = string | (() => VNodeChild);
+export type KDialogBaseOptions = {
+    title: string;
+    message?: KDialogMessage;
+    /**
+     * Colours the primary button. Leave it unset for a positive action — the
+     * brand button — and use `critical` for a destructive one, which also moves
+     * the initial focus to Cancel.
+     */
+    variant?: Intent;
+    /** Escape, a backdrop click and the × all cancel. Default `true`. */
+    dismissible?: boolean;
+    size?: 'xs' | 'sm';
+};
+export type KAlertDialogOptions = KDialogBaseOptions & {
+    /** Default `'OK'`. */
+    okText?: string;
+};
+export type KConfirmDialogOptions = KDialogBaseOptions & {
+    /** Default `'Confirm'`, or `'Delete'` for the `critical` variant. */
+    confirmText?: string;
+    /** Default `'Cancel'`. */
+    cancelText?: string;
+    /**
+     * Runs on confirm with the dialog held open and both buttons disabled. The
+     * dialog resolves once it settles; if it throws, the dialog stays open.
+     */
+    onConfirm?: () => unknown;
+};
+export type KPromptDialogOptions = Omit<KConfirmDialogOptions, 'onConfirm'> & {
+    defaultValue?: string;
+    placeholder?: string;
+    inputType?: 'text' | 'email' | 'number' | 'password';
+    /** Return `true` to accept the value, or a string to show as the error. */
+    validate?: (value: string) => string | true;
+    /** As on confirm, but handed the entered value. */
+    onConfirm?: (value: string) => unknown;
+};
+export type KDialogKind = 'alert' | 'confirm' | 'prompt';
+/** One queued call to `useDialog()`, as the host renders it. */
+export type KDialogRequest = {
+    id: number;
+} & ({
+    kind: 'alert';
+    options: KAlertDialogOptions;
+    resolve: (value: void) => void;
+} | {
+    kind: 'confirm';
+    options: KConfirmDialogOptions;
+    resolve: (value: boolean) => void;
+} | {
+    kind: 'prompt';
+    options: KPromptDialogOptions;
+    resolve: (value: string | null) => void;
+});

package/dist/types/components/Dialog/useDialog.d.ts

@@ -0,0 +1,41 @@
+import type { KAlertDialogOptions, KConfirmDialogOptions, KDialogKind, KDialogRequest, KPromptDialogOptions } from './types';
+/**
+ * Every pending dialog, oldest first. Module-level so any caller — a setup
+ * function, a store, a plain module — feeds the one `<KDialogHost />`, which
+ * shows the head of the queue and takes it off once it has closed.
+ */
+export declare const dialogQueue: import("vue").ShallowReactive<KDialogRequest[]>;
+/**
+ * Dialogs raised while another dialog's `onConfirm` is running. They open at
+ * once, over it, instead of joining the queue: the running dialog cannot
+ * finish until they are answered, so queueing them behind it would deadlock.
+ */
+export declare const nestedDialogs: import("vue").ShallowReactive<KDialogRequest[]>;
+/** How many dialogs are running an `onConfirm` handler right now. */
+export declare const busyDialogs: import("vue").Ref<number, number>;
+/** What a dialog resolves with when it is cancelled or dismissed. */
+export declare const cancelValue: (kind: KDialogKind) => false | null | undefined;
+/** Settles every pending dialog as cancelled and empties both lists. */
+export declare function cancelAllDialogs(): void;
+/**
+ * Promise-based alert, confirm and prompt, rendered by `<KDialogHost />` —
+ * mount it once, near the root of the app.
+ *
+ * ```ts
+ * const dialog = useDialog()
+ *
+ * if (await dialog.confirm({ title: 'Delete file?', variant: 'critical' })) {
+ *   // …
+ * }
+ * ```
+ *
+ * Calls made while a dialog is open wait their turn rather than stacking — except
+ * from inside an `onConfirm` handler, where the new dialog opens over the busy one.
+ */
+export declare function useDialog(): {
+    alert(options: KAlertDialogOptions): Promise<void>;
+    /** Resolves `true` on confirm, `false` on cancel or dismissal. */
+    confirm(options: KConfirmDialogOptions): Promise<boolean>;
+    /** Resolves the entered value, or `null` on cancel or dismissal. */
+    prompt(options: KPromptDialogOptions): Promise<string | null>;
+};