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

package/dist/types/builder/form-builder.vue.d.ts

@@ -0,0 +1,24 @@
+import type { FormBuilderMode } from './context';
+import type { FormBuilderProps, FormBuilderSlots } from './types';
+type __VLS_Slots = FormBuilderSlots;
+declare const __VLS_base: import("vue").DefineComponent<FormBuilderProps, import("./context").FormBuilderContext, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (tr: import(".").FormBuilderTransaction) => any;
+    "update:modelValue": (document: import("..").FormDocument) => any;
+    "update:selection": (ids: string[]) => any;
+    "update:mode": (mode: FormBuilderMode) => any;
+}, string, import("vue").PublicProps, Readonly<FormBuilderProps> & Readonly<{
+    onChange?: ((tr: import(".").FormBuilderTransaction) => any) | undefined;
+    "onUpdate:modelValue"?: ((document: import("..").FormDocument) => any) | undefined;
+    "onUpdate:selection"?: ((ids: string[]) => any) | undefined;
+    "onUpdate:mode"?: ((mode: FormBuilderMode) => any) | undefined;
+}>, {
+    readonly: 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/types/builder/index.d.ts

@@ -0,0 +1,76 @@
+import FormBuilder from './form-builder.vue';
+export declare const DouFormBuilder: import("dou-ui").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./types").FormBuilderProps> & Readonly<{
+        onChange?: ((tr: import("./index.js").FormBuilderTransaction) => any) | undefined;
+        "onUpdate:modelValue"?: ((document: import("../index.js").FormDocument) => any) | undefined;
+        "onUpdate:selection"?: ((ids: string[]) => any) | undefined;
+        "onUpdate:mode"?: ((mode: import("./context").FormBuilderMode) => any) | undefined;
+    }>, import("./context").FormBuilderContext, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (tr: import("./index.js").FormBuilderTransaction) => any;
+        "update:modelValue": (document: import("../index.js").FormDocument) => any;
+        "update:selection": (ids: string[]) => any;
+        "update:mode": (mode: import("./context").FormBuilderMode) => any;
+    }, import("vue").PublicProps, {
+        readonly: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./types").FormBuilderProps> & Readonly<{
+        onChange?: ((tr: import("./index.js").FormBuilderTransaction) => any) | undefined;
+        "onUpdate:modelValue"?: ((document: import("../index.js").FormDocument) => any) | undefined;
+        "onUpdate:selection"?: ((ids: string[]) => any) | undefined;
+        "onUpdate:mode"?: ((mode: import("./context").FormBuilderMode) => any) | undefined;
+    }>, import("./context").FormBuilderContext, {}, {}, {}, {
+        readonly: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./types").FormBuilderProps> & Readonly<{
+    onChange?: ((tr: import("./index.js").FormBuilderTransaction) => any) | undefined;
+    "onUpdate:modelValue"?: ((document: import("../index.js").FormDocument) => any) | undefined;
+    "onUpdate:selection"?: ((ids: string[]) => any) | undefined;
+    "onUpdate:mode"?: ((mode: import("./context").FormBuilderMode) => any) | undefined;
+}>, import("./context").FormBuilderContext, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (tr: import("./index.js").FormBuilderTransaction) => any;
+    "update:modelValue": (document: import("../index.js").FormDocument) => any;
+    "update:selection": (ids: string[]) => any;
+    "update:mode": (mode: import("./context").FormBuilderMode) => any;
+}, string, {
+    readonly: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./types").FormBuilderSlots;
+}), import("vue").HTMLAttributes>;
+export declare const DouFormBuilderPalette: import("dou-ui").WithInstall<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").HTMLAttributes>;
+export declare const DouFormBuilderInspector: import("dou-ui").WithInstall<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").HTMLAttributes>;
+export declare const DouFormBuilderOutline: import("dou-ui").WithInstall<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").HTMLAttributes>;
+export declare const DouFormBuilderCanvas: import("dou-ui").WithInstall<import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").HTMLAttributes>;
+export declare const DouFormBuilderPreview: import("dou-ui").WithInstall<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").HTMLAttributes>;
+export type { FormBuilderEmits, FormBuilderExpose, FormBuilderProps, FormBuilderSlots, } from './types';
+export { useFormBuilder } from './context';
+export type { FormBuilderContext, FormBuilderDispatchOptions, FormBuilderMode, FormBuilderSelectMode, } from './context';
+export { defineFormBuilderExtension, resolveFormBuilderExtensions, resolveFormBuilderFields, } from './extension';
+export type { FormBuilderExtension, FormBuilderExtensionContext, FormBuilderInspectorSection, FormBuilderKeyHandler, FormBuilderMenuItem, FormBuilderToolbarItem, ResolvedFormBuilderExtensions, } from './extension';
+export { applyFormSteps, canContainFormNode, compactFormSteps, FormBuilderTransaction, formNodePlaces, } from './core/transaction';
+export type { FormBuilderStep, FormBuilderTransactionMeta, FormDocumentPatch, FormNodePatch, FormNodePlace, } from './core/transaction';
+export { FormBuilderHistory } from './core/history';
+export type { FormBuilderInsertPlace } from './core/commands';
+export { formBuilderLocales, useFormBuilderMessages } from './locale';
+export type { FormBuilderMessages, FormBuilderMessagesOverride } from './locale';
+export type FormBuilderInstance = InstanceType<typeof FormBuilder>;
+declare module 'vue' {
+    interface GlobalComponents {
+        DouFormBuilder: typeof DouFormBuilder;
+        DouFormBuilderPalette: typeof DouFormBuilderPalette;
+        DouFormBuilderInspector: typeof DouFormBuilderInspector;
+        DouFormBuilderOutline: typeof DouFormBuilderOutline;
+        DouFormBuilderCanvas: typeof DouFormBuilderCanvas;
+        DouFormBuilderPreview: typeof DouFormBuilderPreview;
+    }
+}

package/dist/types/builder/inspector.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/builder/json-dialog.vue.d.ts

@@ -0,0 +1,10 @@
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/builder/locale.d.ts

@@ -0,0 +1,195 @@
+import type { MaybeRefOrGetter } from 'vue';
+/** The texts of the builder: its panels, actions, announcements and the settings of the built-in types. */
+export interface FormBuilderMessages {
+    /** Names of the built-in field types and of the containers, by type. */
+    types: Record<string, string>;
+    /** Names of the palette's groups, by the `group` of a field type. */
+    groups: Record<string, string>;
+    palette: {
+        /** The palette's search box, read out and shown when empty. */
+        search: string;
+        /** Shown when no type matches the search. */
+        empty: string;
+        /** Read out on a type: `{label}`. */
+        add: string;
+    };
+    outline: {
+        label: string;
+        expand: string;
+        collapse: string;
+    };
+    canvas: {
+        /** Names the canvas for screen readers. */
+        label: string;
+        /** Shown on an empty form or container. */
+        empty: string;
+        /** Shown on an empty form or container of a `readonly` builder. */
+        readonlyEmpty: string;
+    };
+    /** The tabs of the side panel. */
+    /** `side` names the pane, or the button that opens it, holding the fields and the outline. */
+    panels: {
+        side: string;
+        fields: string;
+        outline: string;
+        settings: string;
+    };
+    actions: {
+        parent: string;
+        up: string;
+        down: string;
+        duplicate: string;
+        remove: string;
+        /** The button that holds the other actions when a node is too narrow to show them. */
+        more: string;
+        /** On phones: taps add nodes to the selection instead of replacing it. */
+        selectMany: string;
+        wrap: string;
+        addPage: string;
+        undo: string;
+        redo: string;
+    };
+    inspector: {
+        /** Heading when nothing is selected: the form's own settings. */
+        form: string;
+        /** Heading of several selected nodes: `{count}`. */
+        multiple: string;
+        /** Heading over the settings of the field type. */
+        type: string;
+        /** Headings over the checks, and over when the node shows, is disabled or required. */
+        rules: string;
+        logic: string;
+    };
+    /** Read out after a change. */
+    announce: {
+        inserted: string;
+        removed: string;
+        duplicated: string;
+        moved: string;
+        /** After a drag or `moveTo`: `{where}` is the container, `{count}` how many nodes moved. */
+        movedTo: string;
+        movedManyTo: string;
+        wrapped: string;
+        undone: string;
+        redone: string;
+        /** After the whole form was replaced, e.g. by imported JSON. */
+        replaced: string;
+    };
+    /** The condition editor: rows of "field, how, value". */
+    condition: {
+        /** A line of the canvas mark's tooltip: a setting and its expression. `{label}`, `{text}`. */
+        summary: string;
+        /** Names a row for screen readers, followed by its number. */
+        row: string;
+        field: string;
+        operator: string;
+        value: string;
+        add: string;
+        remove: string;
+        /** How the rows combine. */
+        all: string;
+        any: string;
+        /** Switch to writing the expression, and back. */
+        toText: string;
+        toRows: string;
+        /** Why the expression cannot be shown as rows. */
+        notRows: string;
+        yes: string;
+        no: string;
+        /** Groups of the field list inside a list: the item's fields and the form's. */
+        itemGroup: string;
+        formGroup: string;
+        operators: Record<string, string>;
+        /** Names of the comparisons of dates, where they differ. */
+        dateOperators: Record<string, string>;
+    };
+    /** Expression text: what the completions mean, and the problems by their code. `{text}` is the text at fault. */
+    expression: {
+        values: string;
+        item: string;
+        value: string;
+        problems: Record<string, string>;
+        /** What the built-in functions take and do, for hover text and parameter hints. */
+        functions: Record<string, {
+            signature: string;
+            info: string;
+        }>;
+        /** Shown beside `true`, `false`, `null` and `in` in completions. */
+        keyword: string;
+    };
+    preview: {
+        /** The button that shows the preview. */
+        toggle: string;
+        label: string;
+        device: string;
+        devices: {
+            desktop: string;
+            tablet: string;
+            phone: string;
+        };
+        submit: string;
+        reset: string;
+        /** Over the values a submit would send. */
+        passed: string;
+    };
+    /** The JSON of the form. */
+    json: {
+        title: string;
+        /** Lays the text out again, two spaces a level. */
+        format: string;
+        file: string;
+        download: string;
+        copy: string;
+        copied: string;
+        cancel: string;
+        apply: string;
+        /** Closes the dialog of a `readonly` builder, which cannot apply anything. */
+        close: string;
+        syntax: string;
+        /** `{line}`, `{column}`. */
+        syntaxAt: string;
+        fine: string;
+        /** `{count}` problems not listed. */
+        more: string;
+        /** A value of the wrong kind, by what it should be, and `required` for one that is missing. */
+        shape: Record<string, string>;
+        /** The problems of `checkDocument`, by code. */
+        problems: Record<string, string>;
+    };
+    /** Moving nodes by dragging, or with the keyboard after `Space`. `{index}` counts from 1. */
+    drag: {
+        /** Read out before the first place, so it ends with its own stop. */
+        picked: string;
+        place: string;
+        /** The top of the form, as `{where}` in `place`. */
+        top: string;
+        cancelled: string;
+        /** The handle on a node's edge that changes its width. */
+        resize: string;
+    };
+    /** What new nodes are called. `{index}` counts from 1. */
+    created: {
+        option: string;
+        page: string;
+        step: string;
+        text: string;
+        alert: string;
+    };
+    /** Labels of the settings, by key. */
+    settings: Record<string, string>;
+    /** Choices of the settings, by setting and value. */
+    choices: Record<string, Record<string, string>>;
+    errors: {
+        /** A field holding a value needs a name. */
+        name: string;
+        /** `{text}`: the name. */
+        taken: string;
+    };
+}
+export declare const formBuilderLocales: Record<string, FormBuilderMessages>;
+/** Texts to change; each group is merged, so only the texts given are replaced. */
+export type FormBuilderMessagesOverride = {
+    [K in keyof FormBuilderMessages]?: K extends 'choices' ? Record<string, Record<string, string>> : Partial<FormBuilderMessages[K]>;
+};
+/** The builder's texts, picked by the name of DouUI's current locale. */
+export declare function useFormBuilderMessages(override?: MaybeRefOrGetter<FormBuilderMessagesOverride | undefined>): import("vue").ComputedRef<FormBuilderMessages>;

package/dist/types/builder/logic-fields.d.ts

@@ -0,0 +1,2 @@
+export declare const expressionField: import("..").FormFieldType<import("..").FormFieldProps>;
+export declare const conditionField: import("..").FormFieldType<import("..").FormFieldProps>;

package/dist/types/builder/logic.d.ts

@@ -0,0 +1,57 @@
+import type { FormDocument, FormNode, FormRuleSpec } from '../core/types';
+import type { FormFieldType } from '../fields/define';
+import type { ConditionLiteral, ConditionOperator } from './condition';
+import type { FormBuilderMessages } from './locale';
+/** What a value is like, for the operators and the value input a condition row offers. */
+export type TargetKind = 'text' | 'number' | 'date' | 'boolean' | 'choice' | 'choices' | 'list';
+/** A field a condition or an expression can read. */
+export interface LogicTarget {
+    scope: 'values' | 'item';
+    path: string;
+    label: string;
+    kind: TargetKind;
+    /** The field's own options, for `choice` and `choices`. */
+    options?: {
+        label: string;
+        value: ConditionLiteral;
+    }[];
+}
+export declare const operatorsOf: Record<TargetKind, ConditionOperator[]>;
+/** What the logic of a node can read: the form's fields, and those of the list item around it. */
+export interface LogicScope {
+    targets: LogicTarget[];
+    /** The names `values` can read. */
+    names: string[];
+    /** The names `item` can read; `undefined` outside lists. */
+    itemNames: string[] | undefined;
+}
+export declare function logicScope(document: FormDocument, id: string | undefined, fields: ReadonlyMap<string, FormFieldType>, messages: FormBuilderMessages): LogicScope;
+/** Whether two scopes hold the same targets, so settings forms built on the first are kept. */
+export declare function sameLogicScope(a: LogicScope, b: LogicScope): boolean;
+export interface LogicSettingsContext {
+    messages: FormBuilderMessages;
+    /** What the node's expressions can read. */
+    scope: LogicScope;
+    /** The node's type, for a field. */
+    type?: FormFieldType;
+    /**
+     * The names of the validators given to the builder, offered by a
+     * `validator` rule; left out, any name can be typed.
+     */
+    validators?: readonly string[];
+}
+/** When a node shows, is disabled or required, and the value a field works out. */
+export declare function logicSettings(node: FormNode, context: LogicSettingsContext): FormNode[];
+/** The kinds of check the rules editor offers, each writing its own keys of a rule. */
+export declare const ruleKinds: readonly ["type", "range", "pattern", "check", "validator"];
+export type RuleKind = (typeof ruleKinds)[number];
+/** The checks of a field or a list, as a list of rules. */
+export declare function ruleSettings(context: LogicSettingsContext): FormNode[];
+type RuleItem = Record<string, unknown> & {
+    kind?: RuleKind;
+};
+/** A rule as a row of the rules editor: its keys, and which kind of check it is. */
+export declare function ruleToItem(rule: FormRuleSpec): RuleItem;
+/** A row of the rules editor as a rule: only the keys of its kind, and the message and trigger. */
+export declare function itemToRule(item: RuleItem): FormRuleSpec;
+export {};

package/dist/types/builder/menu.d.ts

@@ -0,0 +1,23 @@
+import type { Component, VNode } from 'vue';
+import type { BuilderState } from './context';
+/** An item of a node's menu, built in or from an extension. */
+export interface NodeMenuEntry {
+    key: string;
+    label: string;
+    icon?: Component;
+    run: () => void;
+    disabled?: boolean;
+    tone?: 'neutral' | 'danger';
+    /** The key that does the same, shown at the end of the item. */
+    shortcut?: string;
+    /** A line above it, between the built-in items and an extension's. */
+    divided?: boolean;
+}
+/**
+ * The menu of some nodes: move, copy, group and delete them, then the
+ * extensions' items. A read-only builder keeps only going to the parent
+ * and the extensions' items.
+ */
+export declare function nodeMenu(state: BuilderState, ids: readonly string[]): NodeMenuEntry[];
+/** The entries as items of a dropdown or a context menu. */
+export declare function menuItems(entries: readonly NodeMenuEntry[]): VNode[];

package/dist/types/builder/outline-row.vue.d.ts

@@ -0,0 +1,19 @@
+import type { FormNode } from '../core/types';
+type __VLS_Props = {
+    node: FormNode;
+    level: number;
+    position: number;
+    size: number;
+    container: boolean;
+    open: boolean;
+    selected: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    toggle: () => any;
+    press: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: (() => any) | undefined;
+    onPress?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/builder/outline.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/builder/palette.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/builder/preview.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/builder/settings-binding.d.ts

@@ -0,0 +1,23 @@
+import type { Ref } from 'vue';
+import type { FormDocument } from '../core/types';
+import type { FormFieldType } from '../fields/define';
+type Data = Record<string, unknown>;
+/**
+ * Edit an object (a node, its `props`, or the document's settings)
+ * through a settings form. The form's values start as a copy of the
+ * object; when one changes, the keys it touches are handed to `apply`
+ * as a patch. A setting set back to what leaving it out means (its
+ * `default`, or empty) is left out of the object again.
+ */
+export declare function useSettingsBinding(options: {
+    source: () => Data | undefined;
+    /** What the object belongs to, e.g. the node's id: a new key shows a new copy even if the object is the same. */
+    key?: () => unknown;
+    form: () => FormDocument;
+    fields: () => Map<string, FormFieldType>;
+    /** Prepare a copy of the object for the form, e.g. turn plain options into objects. */
+    prepare?: (data: Data) => Data;
+    /** Write the patch; returns the object as it now is. */
+    apply: (patch: Data) => Data | undefined;
+}): Ref<Data>;
+export {};

package/dist/types/builder/settings.d.ts

@@ -0,0 +1,49 @@
+import type { Component } from 'vue';
+import type { FormDocument, FormNode } from '../core/types';
+import type { FormFieldType } from '../fields/define';
+import type { FormBuilderMessages } from './locale';
+/** The palette groups in the order they are listed; groups of other names follow. */
+export declare const paletteGroups: string[];
+/** The containers the palette offers, after the field types. */
+export declare const containerTypes: string[];
+/** A type's icon: its own, else the built-in one, else a plain box. */
+export declare function iconOf(type: string, spec?: FormFieldType): Component;
+export declare function groupOf(type: string, spec?: FormFieldType): string;
+/** A type's name for people: its own `label`, else the locale's. */
+export declare function labelOf(type: string, spec: FormFieldType | undefined, messages: FormBuilderMessages): string;
+/** What a node is called in the outline and the inspector's heading. */
+export declare function nodeTitle(node: FormNode, fields: ReadonlyMap<string, FormFieldType>, messages: FormBuilderMessages): string;
+type Setting = Record<string, unknown>;
+export declare const field: (type: string, name: string, label: string, extra?: Setting) => FormNode;
+export declare const text: (name: string, label: string, extra?: Setting) => FormNode;
+export declare const number: (name: string, label: string, props?: Setting, extra?: Setting) => FormNode;
+export declare function choices(messages: FormBuilderMessages, key: string, values: readonly (string | boolean)[]): {
+    value: string | boolean;
+    label: string;
+}[];
+export declare const segmented: (messages: FormBuilderMessages, name: string, values: readonly string[], fallback: string, extra?: Setting, key?: string) => FormNode;
+/** Settings of the built-in types, edited in a node's `props`. */
+export declare function builtinSettings(type: string, messages: FormBuilderMessages): FormNode[];
+/** What the node-level settings of a node depend on. */
+export interface NodeSettingsContext {
+    messages: FormBuilderMessages;
+    /** Columns of the grid the node sits on. */
+    columns: number;
+    /** Whether the node sits in a list item, so its name is a key of the item. */
+    inItem: boolean;
+    /** The node's type, for a field. */
+    type?: FormFieldType;
+}
+/** The builder's own type for a node's width: a number of columns, or one per breakpoint. */
+export declare const SPAN_TYPE = "dou-builder-span";
+/** The builder's own type for expression text, with completions and problems. */
+export declare const EXPRESSION_TYPE = "dou-builder-expression";
+/** The builder's own type for a condition, edited as rows or as text. */
+export declare const CONDITION_TYPE = "dou-builder-condition";
+/** The settings of a node itself, besides its type's: name, label, width and so on. */
+export declare function nodeSettings(node: FormNode, context: NodeSettingsContext): FormNode[];
+/** The settings of the document itself. */
+export declare function documentSettings(messages: FormBuilderMessages): FormNode[];
+/** A settings form: the nodes in a vertical, compact document. */
+export declare function settingsDocument(nodes: FormNode[]): FormDocument;
+export {};

package/dist/types/builder/span-field.d.ts

@@ -0,0 +1,4 @@
+/** The width setting of the inspector, a field type of the builder's own. */
+export declare const spanField: import("..").FormFieldType<{
+    columns?: number;
+}>;

package/dist/types/builder/types.d.ts

@@ -0,0 +1,59 @@
+import type { FormFunction } from '../core/expression';
+import type { FormDocument, FormValidator } from '../core/types';
+import type { FormFieldType } from '../fields/define';
+import type { FormOptionsLoader } from '../renderer/context';
+import type { FormBuilderMessagesOverride } from './locale';
+import type { FormBuilderContext, FormBuilderMode } from './context';
+import type { FormBuilderExtension } from './extension';
+import type { FormBuilderTransaction } from './core/transaction';
+export interface FormBuilderProps {
+    /** The form being built, bound with `v-model`. Each change hands over a new document. */
+    modelValue: FormDocument;
+    /** The ids of the selected nodes, bound with `v-model:selection`. */
+    selection?: string[];
+    /** Field types besides the built-in ones, the same list the renderer gets. */
+    fields?: FormFieldType<any>[];
+    /** Show the canvas (`design`, the default) or the form to fill in (`preview`), bound with `v-model:mode`. */
+    mode?: FormBuilderMode;
+    /**
+     * Functions the expressions can call, the same as the renderer's: the
+     * preview runs them, and the inspector completes and checks their names.
+     */
+    functions?: Record<string, FormFunction>;
+    /** Where options come from, the same as the renderer's, for the preview. */
+    sources?: Record<string, FormOptionsLoader>;
+    /**
+     * Checks that need code, the same as the renderer's: the preview runs
+     * them, and the rules editor offers their names.
+     */
+    validators?: Record<string, FormValidator>;
+    /**
+     * Show the form without letting it change: nodes can be selected, their
+     * settings read and the form previewed, but nothing can be added, moved,
+     * removed or edited.
+     */
+    readonly?: boolean;
+    /** Pieces of the builder: field types, keys, buttons, menu items, inspector parts. */
+    extensions?: (FormBuilderExtension | readonly FormBuilderExtension[])[];
+    /** Replaces texts of the builder. */
+    messages?: FormBuilderMessagesOverride;
+}
+export interface FormBuilderEmits {
+    'update:modelValue': [document: FormDocument];
+    'update:selection': [ids: string[]];
+    'update:mode': [mode: FormBuilderMode];
+    /** A change was made: the transaction, with its steps and `meta`. Also for undo and redo. */
+    change: [tr: FormBuilderTransaction];
+}
+export interface FormBuilderSlots {
+    /**
+     * Replaces the layout: place `DouFormBuilderPalette`, `DouFormBuilderCanvas`,
+     * `DouFormBuilderInspector`, `DouFormBuilderOutline` and
+     * `DouFormBuilderPreview` as you like.
+     */
+    default?: () => unknown;
+    /** Buttons after undo and redo, over the canvas. */
+    toolbar?: () => unknown;
+}
+/** What a builder's ref gives, the same as `useFormBuilder()` inside it. */
+export type FormBuilderExpose = FormBuilderContext;

package/dist/types/code/expression-input.vue.d.ts

@@ -0,0 +1,23 @@
+import type { ExpressionName } from './extension';
+type __VLS_Props = {
+    modelValue?: string | null;
+    names?: ExpressionName[];
+    itemNames?: ExpressionName[];
+    readsValue?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Shown and selectable, but not changed; also when the form around is read-only. */
+    readonly?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    modelValue: string | null;
+    placeholder: string;
+    names: ExpressionName[];
+    itemNames: ExpressionName[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/code/extension.d.ts

@@ -0,0 +1,45 @@
+import type { CodeExtension } from '@dou-ui/code';
+import type { ExpressionProblem } from '../core/expression';
+/** A path an expression can read, with what to show beside it. */
+export interface ExpressionName {
+    path: string;
+    label?: string;
+}
+/** What a function takes and does, for hover text and parameter hints. */
+export interface ExpressionFunctionInfo {
+    /** As it is called, e.g. `round(value, digits?)`. */
+    signature: string;
+    info?: string;
+}
+type Getter<T> = T | (() => T);
+export interface ExpressionCodeOptions {
+    /** The paths `values` can read. */
+    names?: Getter<readonly ExpressionName[]>;
+    /** The paths `item` can read; left out where there is no list item. */
+    itemNames?: Getter<readonly ExpressionName[] | undefined>;
+    /** Whether `value` (the field's own value) can be read, as in a check. */
+    readsValue?: Getter<boolean>;
+    /** Functions besides the built-in ones. */
+    functions?: Getter<readonly string[]>;
+    /** What each function takes and does, by name. */
+    functionInfo?: Getter<Readonly<Record<string, ExpressionFunctionInfo>>>;
+    /** Shown beside `values`, `item`, `value` and the keywords in completions. */
+    labels?: Getter<{
+        values?: string;
+        item?: string;
+        value?: string;
+        keyword?: string;
+    }>;
+    /** The words for a problem; the English description by default. */
+    problemMessage?: (problem: ExpressionProblem) => string;
+    /** Finds problems as the expression is typed. On by default. */
+    lint?: boolean;
+}
+/**
+ * Completions, hover text, parameter hints and problems for form
+ * expressions in a `DouCodeEditor` or `DouCodeInput`: field paths after
+ * `values.` and `item.`, functions as snippets, and the problems of
+ * `checkExpression` underlined where they are.
+ */
+export declare function expressionCodeExtension(options?: ExpressionCodeOptions): CodeExtension;
+export {};