@dou-ui/dashboard 0.0.0-stage → 0.1.0-alpha.0

package/dist/types/index.d.ts

@@ -0,0 +1,295 @@
+export declare const DouGridLayout: import("dou-ui").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+        resize?: boolean | import("./index.js").GridResizeHandle[] | undefined;
+        columns?: (number | Record<string, number>) | undefined;
+        editable?: boolean | undefined;
+        label?: string | undefined;
+        breakpoints?: Record<string, number> | undefined;
+        rowHeight?: number | undefined;
+        gap?: number | [number, number] | undefined;
+        compact?: import("./layout").GridCompact | undefined;
+        handle?: boolean | undefined;
+        itemLabel?: ((item: import("./layout").GridItem) => string) | undefined;
+        messages?: import("./locale").DashboardMessagesOverride | undefined;
+    } & {
+        modelValue?: import("./layout").GridItem[];
+        layouts?: Partial<Record<string, import("./index.js").GridPlace[]>>;
+    }> & Readonly<{
+        onDrop?: ((event: import("./index.js").GridDropEvent) => any) | undefined;
+        onChange?: ((event: import("./index.js").GridChangeEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import("./layout").GridItem[]) => any) | undefined;
+        "onUpdate:layouts"?: ((value: Partial<Record<string, import("./index.js").GridPlace[]>>) => any) | undefined;
+        onDragStart?: ((event: import("./index.js").GridDragEvent) => any) | undefined;
+        onDragEnd?: ((event: import("./index.js").GridDragEndEvent) => any) | undefined;
+        onBreakpointChange?: ((breakpoint: string) => any) | undefined;
+    }>, import("./index.js").GridLayoutExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        drop: (event: import("./index.js").GridDropEvent) => any;
+        change: (event: import("./index.js").GridChangeEvent) => any;
+        "update:modelValue": (value: import("./layout").GridItem[]) => any;
+        "update:layouts": (value: Partial<Record<string, import("./index.js").GridPlace[]>>) => any;
+        dragStart: (event: import("./index.js").GridDragEvent) => any;
+        dragEnd: (event: import("./index.js").GridDragEndEvent) => any;
+        breakpointChange: (breakpoint: string) => any;
+    }, import("vue").PublicProps, {
+        resize: boolean | import("./index.js").GridResizeHandle[];
+        columns: number | Record<string, number>;
+        breakpoints: Record<string, number>;
+        rowHeight: number;
+        gap: number | [number, number];
+        compact: import("./layout").GridCompact;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        resize?: boolean | import("./index.js").GridResizeHandle[] | undefined;
+        columns?: (number | Record<string, number>) | undefined;
+        editable?: boolean | undefined;
+        label?: string | undefined;
+        breakpoints?: Record<string, number> | undefined;
+        rowHeight?: number | undefined;
+        gap?: number | [number, number] | undefined;
+        compact?: import("./layout").GridCompact | undefined;
+        handle?: boolean | undefined;
+        itemLabel?: ((item: import("./layout").GridItem) => string) | undefined;
+        messages?: import("./locale").DashboardMessagesOverride | undefined;
+    } & {
+        modelValue?: import("./layout").GridItem[];
+        layouts?: Partial<Record<string, import("./index.js").GridPlace[]>>;
+    }> & Readonly<{
+        onDrop?: ((event: import("./index.js").GridDropEvent) => any) | undefined;
+        onChange?: ((event: import("./index.js").GridChangeEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import("./layout").GridItem[]) => any) | undefined;
+        "onUpdate:layouts"?: ((value: Partial<Record<string, import("./index.js").GridPlace[]>>) => any) | undefined;
+        onDragStart?: ((event: import("./index.js").GridDragEvent) => any) | undefined;
+        onDragEnd?: ((event: import("./index.js").GridDragEndEvent) => any) | undefined;
+        onBreakpointChange?: ((breakpoint: string) => any) | undefined;
+    }>, import("./index.js").GridLayoutExpose, {}, {}, {}, {
+        resize: boolean | import("./index.js").GridResizeHandle[];
+        columns: number | Record<string, number>;
+        breakpoints: Record<string, number>;
+        rowHeight: number;
+        gap: number | [number, number];
+        compact: import("./layout").GridCompact;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<{
+    resize?: boolean | import("./index.js").GridResizeHandle[] | undefined;
+    columns?: (number | Record<string, number>) | undefined;
+    editable?: boolean | undefined;
+    label?: string | undefined;
+    breakpoints?: Record<string, number> | undefined;
+    rowHeight?: number | undefined;
+    gap?: number | [number, number] | undefined;
+    compact?: import("./layout").GridCompact | undefined;
+    handle?: boolean | undefined;
+    itemLabel?: ((item: import("./layout").GridItem) => string) | undefined;
+    messages?: import("./locale").DashboardMessagesOverride | undefined;
+} & {
+    modelValue?: import("./layout").GridItem[];
+    layouts?: import("./index.js").GridLayouts;
+}> & Readonly<{
+    onDrop?: ((event: import("./index.js").GridDropEvent) => any) | undefined;
+    onChange?: ((event: import("./index.js").GridChangeEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import("./layout").GridItem[]) => any) | undefined;
+    "onUpdate:layouts"?: ((value: Partial<Record<string, import("./index.js").GridPlace[]>>) => any) | undefined;
+    onDragStart?: ((event: import("./index.js").GridDragEvent) => any) | undefined;
+    onDragEnd?: ((event: import("./index.js").GridDragEndEvent) => any) | undefined;
+    onBreakpointChange?: ((breakpoint: string) => any) | undefined;
+}>, import("./index.js").GridLayoutExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    drop: (event: import("./index.js").GridDropEvent) => any;
+    change: (event: import("./index.js").GridChangeEvent) => any;
+    "update:modelValue": (value: import("./layout").GridItem[]) => any;
+    "update:layouts": (value: Partial<Record<string, import("./index.js").GridPlace[]>>) => any;
+    dragStart: (event: import("./index.js").GridDragEvent) => any;
+    dragEnd: (event: import("./index.js").GridDragEndEvent) => any;
+    breakpointChange: (breakpoint: string) => any;
+}, string, {
+    resize: boolean | import("./index.js").GridResizeHandle[];
+    columns: number | Record<string, number>;
+    breakpoints: Record<string, number>;
+    rowHeight: number;
+    gap: number | [number, number];
+    compact: import("./layout").GridCompact;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        item?: (props: import("./index.js").GridItemSlotProps) => unknown;
+        placeholder?: (props: {
+            item: import("./layout").GridItem;
+        }) => unknown;
+    };
+}), import("vue").HTMLAttributes>;
+export declare const DouGridLayoutHandle: import("dou-ui").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+        as?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        as: string;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        as?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, {
+        as: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<{
+    as?: string;
+}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    as: string;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: () => unknown;
+    };
+}), import("vue").HTMLAttributes>;
+export declare const DouDashboard: import("dou-ui").WithInstall<import("vue").DefineComponent<{
+    columns?: (number | Record<string, number>) | undefined;
+    editable?: boolean | undefined;
+    label?: string | undefined;
+    breakpoints?: Record<string, number> | undefined;
+    rowHeight?: number | undefined;
+    gap?: number | [number, number] | undefined;
+    compact?: import("./layout").GridCompact | undefined;
+    messages?: import("./locale").DashboardMessagesOverride | undefined;
+    widgets?: import("./index.js").DashboardWidgetType<any>[] | undefined;
+    sources?: import("./index.js").DashboardSources | undefined;
+    createId?: ((type: string) => string) | undefined;
+    collaboration?: import("./index.js").DashboardCollaboration | undefined;
+    exporters?: readonly import("@dou-ui/sheet").SheetExporter[] | undefined;
+} & {
+    modelValue?: import("./index.js").DashboardDocument;
+    filters?: import("./index.js").DashboardFilters;
+}, import("./index.js").DashboardExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (transaction: import("./index.js").DashboardTransaction) => any;
+    "update:modelValue": (value: import("./index.js").DashboardDocument) => any;
+    breakpointChange: (breakpoint: string) => any;
+    "update:filters": (value: import("./index.js").DashboardFilters) => any;
+    exportError: (event: import("./index.js").DashboardExportErrorEvent) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    columns?: (number | Record<string, number>) | undefined;
+    editable?: boolean | undefined;
+    label?: string | undefined;
+    breakpoints?: Record<string, number> | undefined;
+    rowHeight?: number | undefined;
+    gap?: number | [number, number] | undefined;
+    compact?: import("./layout").GridCompact | undefined;
+    messages?: import("./locale").DashboardMessagesOverride | undefined;
+    widgets?: import("./index.js").DashboardWidgetType<any>[] | undefined;
+    sources?: import("./index.js").DashboardSources | undefined;
+    createId?: ((type: string) => string) | undefined;
+    collaboration?: import("./index.js").DashboardCollaboration | undefined;
+    exporters?: readonly import("@dou-ui/sheet").SheetExporter[] | undefined;
+} & {
+    modelValue?: import("./index.js").DashboardDocument;
+    filters?: import("./index.js").DashboardFilters;
+}> & Readonly<{
+    onChange?: ((transaction: import("./index.js").DashboardTransaction) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import("./index.js").DashboardDocument) => any) | undefined;
+    onBreakpointChange?: ((breakpoint: string) => any) | undefined;
+    "onUpdate:filters"?: ((value: import("./index.js").DashboardFilters) => any) | undefined;
+    onExportError?: ((event: import("./index.js").DashboardExportErrorEvent) => any) | undefined;
+}>, {
+    columns: number | Record<string, number>;
+    breakpoints: Record<string, number>;
+    rowHeight: number;
+    gap: number | [number, number];
+    compact: import("./layout").GridCompact;
+    widgets: import("./index.js").DashboardWidgetType<any>[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, import("vue").HTMLAttributes>;
+export declare const DouDashboardPalette: import("dou-ui").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./index.js").DashboardPaletteProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        direction: "vertical" | "horizontal";
+        for: import("./index.js").DashboardExpose | null;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./index.js").DashboardPaletteProps> & Readonly<{}>, {}, {}, {}, {}, {
+        direction: "vertical" | "horizontal";
+        for: import("./index.js").DashboardExpose | null;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./index.js").DashboardPaletteProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    direction: "vertical" | "horizontal";
+    for: import("./index.js").DashboardExpose | null;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {
+            type: import("./index.js").DashboardWidgetType<any>;
+        }) => unknown;
+    };
+}), import("vue").HTMLAttributes>;
+export declare const DouDashboardFilterBar: import("dou-ui").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./index.js").DashboardFilterBarProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        clearable: boolean;
+        for: import("./index.js").DashboardExpose | null;
+        fields: import("./index.js").DashboardFilterField[];
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./index.js").DashboardFilterBarProps> & Readonly<{}>, {}, {}, {}, {}, {
+        clearable: boolean;
+        for: import("./index.js").DashboardExpose | null;
+        fields: import("./index.js").DashboardFilterField[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./index.js").DashboardFilterBarProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    clearable: boolean;
+    for: import("./index.js").DashboardExpose | null;
+    fields: import("./index.js").DashboardFilterField[];
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: () => unknown;
+    };
+}), import("vue").HTMLAttributes>;
+export type { DashboardAddOptions, DashboardEmits, DashboardExportErrorEvent, DashboardExportOptions, DashboardSaveOptions, DashboardExpose, DashboardFilterBarProps, DashboardPaletteProps, DashboardProps, } from './dashboard/types';
+export type { DashboardDocument, DashboardPlace, DashboardWidget } from './core/types';
+export { checkDocument, emptyDocument, isDashboardPlace, migrateDocument } from './core/document';
+export type { CheckDocumentOptions, DocumentProblem } from './core/document';
+export { applySteps, DashboardTransaction, replaceWidgets, sameValue } from './core/transaction';
+export type { DashboardCollaboration, DashboardCollaborationHost, DashboardPeer, DashboardPresence, DashboardPresenceAction, } from './core/collaboration';
+export type { DashboardStep, DashboardTransactionMeta, DashboardWidgetPatch, } from './core/transaction';
+export { DashboardHistory } from './core/history';
+export { defineDashboardWidget } from './widget/define';
+export type { DashboardWidgetSize, DashboardWidgetType } from './widget/define';
+export { useDashboardWidget } from './widget/context';
+export { isEmptyFilter } from './data/filters';
+export type { DashboardImageOptions } from './dashboard/export';
+export type { DashboardDateRangeFilterField, DashboardFilterField, DashboardFilters, DashboardLinkedFilter, DashboardSearchFilterField, DashboardSelectFilterField, DashboardSetFilterOptions, DashboardSourceContext, DashboardSourceLoad, DashboardSourceOptions, DashboardSources, } from './data/types';
+export type { DashboardWidgetContext, DashboardWidgetState, DashboardWidgetStatus, } from './widget/context';
+export type { GridChangeEvent, GridChangeReason, GridDragEndEvent, GridDragEvent, GridDropEvent, GridDropItem, GridItemSlotProps, GridLayoutEmits, GridLayoutExpose, GridLayoutProps, GridLayouts, GridPlace, GridResizeHandle, } from './grid/types';
+export { compactLayout, deriveLayout, findPlace, fitItem, layoutHeight, moveItem, moveItemBy, normalizeLayout, overlaps, resizeItem, resizeItemBy, } from './layout';
+export type { GridCompact, GridItem, GridLayoutOptions, GridPosition, GridSize } from './layout';
+export { dashboardLocales, useDashboardMessages } from './locale';
+export type { DashboardMessages, DashboardMessagesOverride } from './locale';
+declare module 'vue' {
+    interface GlobalComponents {
+        DouGridLayout: typeof DouGridLayout;
+        DouGridLayoutHandle: typeof DouGridLayoutHandle;
+        DouDashboard: typeof DouDashboard;
+        DouDashboardPalette: typeof DouDashboardPalette;
+        DouDashboardFilterBar: typeof DouDashboardFilterBar;
+    }
+}

package/dist/types/layout/engine.d.ts

@@ -0,0 +1,50 @@
+import type { GridItem, GridLayoutOptions, GridPosition, GridSize } from './types';
+type Box = Pick<GridItem, 'x' | 'y' | 'w' | 'h'>;
+/** Whether two boxes share at least one cell. */
+export declare function overlaps(a: Box, b: Box): boolean;
+/** The row just below the lowest item: how many rows the layout takes up. */
+export declare function layoutHeight(items: readonly Box[]): number;
+/**
+ * The item with its size inside its limits and the grid's width, and its
+ * position on the grid, in whole cells. Returns the item itself when it fits.
+ */
+export declare function fitItem(item: GridItem, columns: number): GridItem;
+/**
+ * The layout fitted to the grid: sizes inside their limits, nothing past
+ * the last column, no two items on the same cell and, when compacting,
+ * no gaps above items. Returns `items` itself when it is already settled.
+ */
+export declare function normalizeLayout(items: readonly GridItem[], options: GridLayoutOptions): readonly GridItem[];
+/** Floats every item up as far as it goes (ignores `compact`). */
+export declare function compactLayout(items: readonly GridItem[], columns: number): GridItem[];
+/**
+ * Moves an item to a cell; the items it lands on make way. Locked items
+ * and unknown ids leave the layout as it is.
+ */
+export declare function moveItem(items: readonly GridItem[], id: string, to: GridPosition, options: GridLayoutOptions): readonly GridItem[];
+/**
+ * Gives an item a new size, keeping its top-left corner; the items it now
+ * covers make way. A size that would cover a locked item is refused.
+ */
+export declare function resizeItem(items: readonly GridItem[], id: string, to: GridSize, options: GridLayoutOptions): readonly GridItem[];
+/**
+ * Moves an item by whole cells, as the arrow keys do. Moving up or down
+ * goes on past rows where the item would only settle back where it was,
+ * so one press always moves it, to the next place it can take.
+ */
+export declare function moveItemBy(items: readonly GridItem[], id: string, dx: number, dy: number, options: GridLayoutOptions): readonly GridItem[];
+/** Resizes an item by whole cells, as Shift and the arrow keys do. */
+export declare function resizeItemBy(items: readonly GridItem[], id: string, dw: number, dh: number, options: GridLayoutOptions): readonly GridItem[];
+/**
+ * Where a new item of `size` fits: the first free spot reading from the top
+ * left, or below everything when no row has room.
+ */
+export declare function findPlace(items: readonly GridItem[], size: GridSize, options: GridLayoutOptions): GridPosition;
+/**
+ * The layout worked out for a grid of another width: positions and widths
+ * scaled by the ratio of the columns, then settled. On a single column the
+ * items are stacked in reading order (top to bottom, then left to right),
+ * each keeping its height.
+ */
+export declare function deriveLayout(items: readonly GridItem[], from: number, options: GridLayoutOptions): readonly GridItem[];
+export {};

package/dist/types/layout/index.d.ts

@@ -0,0 +1,2 @@
+export { compactLayout, deriveLayout, findPlace, fitItem, layoutHeight, moveItem, moveItemBy, normalizeLayout, overlaps, resizeItem, resizeItemBy, } from './engine';
+export type { GridCompact, GridItem, GridLayoutOptions, GridPosition, GridSize } from './types';

package/dist/types/layout/types.d.ts

@@ -0,0 +1,39 @@
+/** One item on the grid, placed in whole columns and rows. */
+export interface GridItem {
+    id: string;
+    /** The column of its left edge, from 0. */
+    x: number;
+    /** The row of its top edge, from 0. */
+    y: number;
+    /** Its width in columns. */
+    w: number;
+    /** Its height in rows. */
+    h: number;
+    minW?: number;
+    maxW?: number;
+    minH?: number;
+    maxH?: number;
+    /** Can't be moved or resized, and stays where it is: the other items go around it. */
+    locked?: boolean;
+}
+/**
+ * How items settle after a change:
+ *
+ * - `'vertical'`: every item floats up as far as it can, so there are no gaps above it;
+ * - `false`: items stay where they are put, and only move down out of each other's way.
+ */
+export type GridCompact = 'vertical' | false;
+export interface GridLayoutOptions {
+    /** How many columns the grid has. */
+    columns: number;
+    /** Defaults to `'vertical'`. */
+    compact?: GridCompact;
+}
+export interface GridPosition {
+    x: number;
+    y: number;
+}
+export interface GridSize {
+    w: number;
+    h: number;
+}

package/dist/types/locale.d.ts

@@ -0,0 +1,117 @@
+import { type MaybeRefOrGetter } from 'vue';
+export interface DashboardMessages {
+    /** The grid layout's accessible name. */
+    layout: string;
+    /** What an item of the grid is called by a screen reader. */
+    item: string;
+    /** Read after an item's name while the layout can be edited. */
+    itemHint: string;
+    /** An item that can't be moved: `{item}`. */
+    locked: string;
+    /** An item's place: `{x}` `{y}` (from 1), `{w}` `{h}` (in columns and rows). */
+    position: string;
+    /** An item's place when the grid has one column: `{n}` of `{count}` (from 1). */
+    order: string;
+    /** An item picked up with the keyboard: `{item}` and `{position}`. */
+    grabbed: string;
+    /** An item put down, with the keyboard or the pointer: `{item}` and `{position}`. */
+    dropped: string;
+    /** A move or resize undone with Escape (or a drop outside the grid): `{item}`. */
+    cancelled: string;
+    /** The handle in an item's corner. */
+    resize: string;
+    /** The dashboard's accessible name. */
+    dashboard: string;
+    /** The menu button in a widget's title bar. */
+    widgetMenu: string;
+    /** Menu items. */
+    settings: string;
+    fullscreen: string;
+    /** The menu of file types a widget's content can be exported as. */
+    export: string;
+    /** A failed export, over the widget's content: `{name}` (the file), `{reason}`. */
+    exportFailed: string;
+    /** Read out once the file is saved: `{name}`. */
+    exported: string;
+    /** Why a widget can't be exported: it has no data, such as a chart without its fields. */
+    nothingToExport: string;
+    duplicate: string;
+    remove: string;
+    /** The settings drawer's title: `{title}`. */
+    settingsTitle: string;
+    /** The title field in the settings drawer. */
+    titleField: string;
+    /** Read when a widget is added, copied or removed: `{item}`. */
+    added: string;
+    removed: string;
+    /** A widget whose type isn't registered: `{type}`. */
+    unknownType: string;
+    /** A widget's status. */
+    loading: string;
+    error: string;
+    empty: string;
+    retry: string;
+    /** A dashboard without widgets, while editing. */
+    emptyTitle: string;
+    emptyHint: string;
+    /** The list of widgets to add. */
+    palette: string;
+    /** A widget in that list: `{label}`. */
+    paletteItem: string;
+    /** In the title bar of a widget that set a filter: `{value}`. */
+    filteredBy: string;
+    peerMoving: string;
+    peerResizing: string;
+    peerSettings: string;
+    /** The button clearing that filter: `{value}`. */
+    clearFilter: string;
+    /** The filter bar's accessible name. */
+    filterBar: string;
+    /** A filter set by a widget, in the filter bar: `{title}` and `{value}`. */
+    linkedFilter: string;
+    /** Clears every filter. */
+    clearFilters: string;
+    /** Settings of the built-in widgets. */
+    source: string;
+    noSource: string;
+    field: string;
+    value: string;
+    prefix: string;
+    suffix: string;
+    precision: string;
+    trend: string;
+    delta: string;
+    /** The change under a number: `{value}`, e.g. `+12.5%`. */
+    deltaText: string;
+    text: string;
+    textSize: string;
+    sizeSmall: string;
+    sizeMedium: string;
+    sizeLarge: string;
+    columns: string;
+    /** The title of a table column, while it has none: `{field}`. */
+    columnTitle: string;
+    chartKind: string;
+    chartLine: string;
+    chartArea: string;
+    chartBar: string;
+    chartPie: string;
+    xField: string;
+    yFields: string;
+    stacked: string;
+    horizontal: string;
+    /** The filter set by clicking a chart. */
+    chartFilter: string;
+    chartFilterHint: string;
+    /** Whether clicking a pivot table's cell filters the other widgets. */
+    pivotFilter: string;
+}
+export declare const dashboardLocales: Record<string, DashboardMessages>;
+export type DashboardMessagesOverride = Partial<DashboardMessages>;
+/**
+ * The dashboard's texts, picked by the name of DouUI's current locale.
+ * Pass `messages` to override any of them.
+ */
+export declare function useDashboardMessages(override?: MaybeRefOrGetter<DashboardMessagesOverride | undefined>): import("vue").ComputedRef<DashboardMessages>;
+/** Fills `{name}` placeholders. */
+export declare const format: (text: string, params: Record<string, string | number>) => string;

package/dist/types/pivot/index.d.ts

@@ -0,0 +1,14 @@
+import type { PivotField } from '@dou-ui/pivot';
+import type { WidgetOverrides } from '../widgets';
+import type { PivotWidgetProps } from './types';
+export type { PivotWidgetProps } from './types';
+export interface PivotWidgetOptions extends WidgetOverrides<PivotWidgetProps> {
+    /** What the fields hold and how to show them, as `DouPivot`'s `fields`; worked out from the records when left out. */
+    fields?: readonly PivotField[];
+}
+/**
+ * A pivot table of a source's records, drawn with `@dou-ui/pivot`; its
+ * settings lay the fields out, and clicking a cell can filter the other
+ * widgets. Needs `@dou-ui/pivot` and its styles.
+ */
+export declare function pivotWidget(options?: PivotWidgetOptions): import("..").DashboardWidgetType<PivotWidgetProps>;

package/dist/types/pivot/pivot-settings.vue.d.ts

@@ -0,0 +1,16 @@
+import type { PivotField } from '@dou-ui/pivot';
+import type { PivotWidgetProps } from './types';
+type __VLS_Props = {
+    fields?: readonly PivotField[];
+};
+type __VLS_ModelProps = {
+    modelValue: PivotWidgetProps;
+};
+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: PivotWidgetProps) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: PivotWidgetProps) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/pivot/pivot.vue.d.ts

@@ -0,0 +1,7 @@
+import type { PivotField } from '@dou-ui/pivot';
+type __VLS_Props = {
+    fields?: readonly PivotField[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/pivot/types.d.ts

@@ -0,0 +1,11 @@
+import type { PivotConfig } from '@dou-ui/pivot';
+/** The `props` of a `pivot` widget. */
+export interface PivotWidgetProps {
+    source?: string;
+    /** Where the records are, when the data isn't the list itself. */
+    path?: string;
+    /** Which fields go where, as `DouPivot`'s `config`. */
+    config?: PivotConfig;
+    /** Clicking a cell filters the other widgets by its row and column groups, one filter per field. */
+    filter?: boolean;
+}

package/dist/types/widget/context.d.ts

@@ -0,0 +1,91 @@
+import type { SheetWorkbook } from '@dou-ui/sheet/core';
+import type { ComputedRef, InjectionKey, Ref } from 'vue';
+import type { DashboardWidget } from '../core/types';
+import type { DashboardFilters, DashboardSetFilterOptions } from '../data/types';
+/** What a widget shows instead of, or over, its content. */
+export type DashboardWidgetState = 'ready' | 'loading' | 'error' | 'empty';
+export interface DashboardWidgetStatus {
+    state: DashboardWidgetState;
+    /** For `error` and `empty`: the line shown. */
+    message?: string;
+    /** For `error`: what the retry button does; without it there is no button. */
+    retry?: () => void;
+}
+export interface DashboardWidgetContext<P extends object = Record<string, unknown>, D = unknown> {
+    /** The widget as stored in the document. */
+    widget: ComputedRef<DashboardWidget<P>>;
+    /** Its `props`, `{}` when it has none. */
+    props: ComputedRef<P>;
+    /** Whether the dashboard is being edited. */
+    editing: ComputedRef<boolean>;
+    /** Whether this is the full-screen view of the widget. */
+    fullscreen: ComputedRef<boolean>;
+    /** The size of the widget's content area, in px; updated once a frame at most. */
+    size: {
+        width: Ref<number>;
+        height: Ref<number>;
+    };
+    /**
+     * Merges keys into the widget's `props`, as one undoable change. Changes
+     * with the same `group` within a second undo together.
+     */
+    setProps: (patch: Partial<P>, options?: {
+        group?: string;
+    }) => void;
+    /**
+     * What the frame shows: a loading mark over the content, an error, or an
+     * empty notice. Loading and failing to load `props.source` come first.
+     */
+    status: Readonly<Ref<DashboardWidgetStatus>>;
+    setStatus: (state: DashboardWidgetState, options?: Omit<DashboardWidgetStatus, 'state'>) => void;
+    /**
+     * The data of the source named in `props.source`, loaded with the filters
+     * in effect. While new data loads, the last data stays.
+     */
+    data: Readonly<Ref<D | undefined>>;
+    /** Why the source failed to load, if it did. */
+    error: Readonly<Ref<unknown>>;
+    /** The filters in effect for this widget: all of them but those it set itself. */
+    filters: ComputedRef<DashboardFilters>;
+    /**
+     * Sets a filter for the other widgets, e.g. when a bar of a chart is
+     * clicked; an empty value (`undefined`, `null`, `''`, `[]`) clears it.
+     * The widget itself keeps showing everything, and its title bar shows
+     * the filter with a button to clear it.
+     */
+    setFilter: (key: string, value: unknown, options?: DashboardSetFilterOptions) => void;
+    /** The filters this widget set itself and that are still in effect, e.g. to mark the picked bar. */
+    ownFilters: ComputedRef<DashboardFilters>;
+    /** Loads the widget's source again. */
+    refresh: () => void;
+    /** The names of the dashboard's sources, e.g. to pick one in a settings form. */
+    sources: ComputedRef<string[]>;
+    /**
+     * Gives the dashboard the widget's content as a workbook, read when it is
+     * exported with one of the dashboard's `exporters`; a sheet without a
+     * name takes the widget's title. Returning `undefined` fails the export
+     * with "no data to export"; `null` takes the export menu away, such as
+     * while the widget isn't set up. A widget that never calls it has no
+     * export menu. Undone when the widget goes.
+     */
+    setWorkbook: (get: (() => SheetWorkbook | undefined) | null) => void;
+}
+export declare const widgetContextKey: InjectionKey<DashboardWidgetContext<any, any>>;
+/** The widget a component is drawn in, for widget types' `component` and `settings`. */
+export declare function useDashboardWidget<P extends object = Record<string, unknown>, D = unknown>(): DashboardWidgetContext<P, D>;
+interface ContextSource {
+    widget: () => DashboardWidget;
+    editing: () => boolean;
+    fullscreen: () => boolean;
+    size: {
+        width: Ref<number>;
+        height: Ref<number>;
+    };
+    setProps: (id: string, patch: Record<string, unknown>, options?: {
+        group?: string;
+    }) => void;
+    setWorkbook?: (id: string, get: () => SheetWorkbook | undefined) => () => void;
+}
+/** Makes the context of one widget and provides it to the components below. */
+export declare function provideWidgetContext(source: ContextSource): DashboardWidgetContext;
+export {};