e10-ebuilder-prototype 0.5.4 → 0.5.7

package/dist/form-behavior-runtime.mjs

@@ -0,0 +1,681 @@
+// Serialized by the CLI. No imports, model calls, eval, remote APIs or generated executors.
+export function installFormBehavior(contract) {
+    const clone = (v) => JSON.parse(JSON.stringify(v));
+    const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+    const fail = (code, message, source) => {
+        const e = new Error(message);
+        Object.assign(e, { code, source });
+        throw e;
+    };
+    const empty = (v) => v === undefined || v === null || v === '' || (Array.isArray(v) && !v.length);
+    const text = (v) => (empty(v) ? '' : typeof v === 'object' ? JSON.stringify(v) : String(v));
+    const fields = new Map(contract.fields.map((f) => [f.key, f]));
+    if (fields.size !== contract.fields.length)
+        fail('FIELD_IDENTITY', '字段身份重复');
+    const field = (key) => fields.get(key) || fail('FIELD_UNKNOWN', '未知字段', key);
+    const scalar = (v) => v === null || ['string', 'number', 'boolean'].includes(typeof v);
+    const decimal = (v) => {
+        const m = String(v).match(/^([+-]?)(\d+)(?:\.(\d+))?$/);
+        if (!m)
+            fail('FIELD_NUMBER', '请输入有效数字');
+        return {
+            n: BigInt((m[1] === '-' ? '-' : '') + m[2] + (m[3] || '')),
+            scale: (m[3] || '').length,
+        };
+    };
+    const compare = (a, b, f) => {
+        if (empty(a) || empty(b))
+            return empty(a) === empty(b) ? 0 : empty(a) ? 1 : -1;
+        if (f.kind === 'number') {
+            const x = decimal(a), y = decimal(b), scale = Math.max(x.scale, y.scale);
+            const delta = x.n * 10n ** BigInt(scale - x.scale) - y.n * 10n ** BigInt(scale - y.scale);
+            return delta < 0n ? -1 : delta > 0n ? 1 : 0;
+        }
+        return text(a).localeCompare(text(b), 'zh-CN', { numeric: true });
+    };
+    const operators = [
+        'eq',
+        'ne',
+        'contains',
+        'notContains',
+        'in',
+        'notIn',
+        'gt',
+        'gte',
+        'lt',
+        'lte',
+        'between',
+        'empty',
+        'notEmpty',
+    ];
+    const validateCondition = (c, depth = 0) => {
+        if (depth > 12 || !c || typeof c !== 'object' || Array.isArray(c))
+            fail('CONDITION_UNSUPPORTED', '条件结构无效');
+        if (c.all && c.any)
+            fail('CONDITION_UNSUPPORTED', '组合条件不能同时包含 all 和 any');
+        if (c.all || c.any) {
+            const values = c.all || c.any;
+            if (!Array.isArray(values) || !values.length || values.length > 100)
+                fail('CONDITION_UNSUPPORTED', '组合条件不能为空');
+            values.forEach((v) => validateCondition(v, depth + 1));
+            return;
+        }
+        const f = field(c.field);
+        if (f.group || !operators.includes(c.op))
+            fail('CONDITION_UNSUPPORTED', '不支持该条件或明细字段条件', f.source);
+        if (['in', 'notIn', 'between'].includes(c.op) &&
+            (!Array.isArray(c.value) ||
+                !c.value.every(scalar) ||
+                (c.op === 'between' && c.value.length !== 2)))
+            fail('CONDITION_VALUE', '条件值必须是合法数组');
+        if (!['empty', 'notEmpty', 'in', 'notIn', 'between'].includes(c.op) && !scalar(c.value))
+            fail('CONDITION_VALUE', '条件值必须是基本值');
+    };
+    const matches = (row, c) => {
+        if (c.all)
+            return c.all.every((item) => matches(row, item));
+        if (c.any)
+            return c.any.some((item) => matches(row, item));
+        const f = field(c.field), value = row?.fields?.[f.id], expected = c.value;
+        switch (c.op) {
+            case 'empty':
+                return empty(value);
+            case 'notEmpty':
+                return !empty(value);
+            case 'eq':
+                return same(value, expected);
+            case 'ne':
+                return !same(value, expected);
+            case 'contains':
+                return text(value).toLocaleLowerCase().includes(text(expected).toLocaleLowerCase());
+            case 'notContains':
+                return !text(value).toLocaleLowerCase().includes(text(expected).toLocaleLowerCase());
+            case 'in':
+                return (Array.isArray(value) ? value : [value]).some((v) => expected.some((e) => same(v, e)));
+            case 'notIn':
+                return !(Array.isArray(value) ? value : [value]).some((v) => expected.some((e) => same(v, e)));
+            case 'between':
+                return (!empty(value) &&
+                    compare(value, expected[0], f) >= 0 &&
+                    compare(value, expected[1], f) <= 0);
+            default: {
+                const n = compare(value, expected, f);
+                return !empty(value) && { gt: n > 0, gte: n >= 0, lt: n < 0, lte: n <= 0 }[c.op];
+            }
+        }
+    };
+    const options = (f) => {
+        const raw = f.options?.$e10Options
+            ? window.E10FormOptions.get(f.options.$e10Options)
+            : f.options;
+        const flatten = (items, ancestors = []) => (items || []).flatMap((o) => {
+            const value = o.value ?? o.id, label = String(o.label ?? o.name ?? o.content ?? value);
+            if (!scalar(value))
+                fail('OPTION_UNSUPPORTED', '选项缺少有效标识', f.source);
+            const path = [...ancestors, label];
+            return o.children?.length
+                ? flatten(o.children, path)
+                : [{ value: String(value), label: path.join(' / ') }];
+        });
+        if (!Array.isArray(raw))
+            fail('OPTION_UNSUPPORTED', '选项格式未支持', f.source);
+        return flatten(raw);
+    };
+    const supported = new Set(['add', 'view', 'edit', 'save', 'saveNew', 'cancel', 'delete']);
+    async function create(initial, decisions = {}) {
+        if (!initial || initial.schema !== 1 || !Array.isArray(initial.records))
+            fail('STATE_INVALID', '初始记录格式无效');
+        if (new Set(initial.records.map((r) => r.id)).size !== initial.records.length)
+            fail('STATE_INVALID', '记录 ID 重复');
+        const store = window.E10FormStore;
+        let state, mode = 'list', draft = null, original = null, busy = false;
+        let querySpec = { page: 1, pageSize: 20 }, selected = [];
+        const entities = clone(decisions.entities || {}), conditions = clone(decisions.conditions || {}), actionDecisions = clone(decisions.actions || {});
+        const buttons = new Map(contract.buttons.map((b) => [b.key, clone(b)]));
+        const conditionSources = new Set(contract.buttons.flatMap((b) => [b.source, ...b.actions.map((a) => a.source)]));
+        for (const [source, c] of Object.entries(conditions)) {
+            if (!conditionSources.has(source))
+                fail('CONDITION_SOURCE', '条件没有对应配置来源', source);
+            validateCondition(c);
+        }
+        for (const key of Object.keys(entities)) {
+            if (field(key).kind !== 'entity')
+                fail('ENTITY_SOURCE', '实体选项必须绑定实体字段', key);
+        }
+        for (const [source, decision] of Object.entries(actionDecisions)) {
+            const action = [...buttons.values()]
+                .flatMap((b) => b.actions)
+                .find((a) => a.source === source);
+            if (!action || !decision || !supported.has(decision.op) || !decision.reason?.trim())
+                fail('ACTION_DECISION', '动作决策需要有效来源、已支持操作和解释', source);
+            if (action.op && action.op !== decision.op)
+                fail('ACTION_MISMATCH', '不能替换已确定的系统动作', source);
+            Object.assign(action, { op: decision.op, reason: decision.reason });
+        }
+        // Invalid decisions must fail before even initializing shared local records.
+        state = await store.load(initial);
+        const limitations = [
+            ...contract.fields.flatMap((f) => f.issues.map((reason) => ({ source: f.source, reason }))),
+            ...contract.scopes
+                .filter((s) => s.status !== 'ready')
+                .map((s) => ({ source: s.source, reason: s.status })),
+            ...[...buttons.values()].flatMap((b) => b.actions
+                .filter((a) => a.enabled !== false && (!a.op || (a.conditionRequired && !conditions[a.source])))
+                .map((a) => ({ source: a.source, reason: 'unresolved-action-or-condition' }))),
+            ...[...buttons.values()]
+                .filter((b) => b.conditionRequired && !conditions[b.source])
+                .map((b) => ({ source: b.source, reason: 'unresolved-button-condition' })),
+        ];
+        window.__E10_FORM_BEHAVIOR__ = {
+            schema: 1,
+            menuId: contract.menuId,
+            initialized: true,
+            limitations,
+            decisions: {
+                actionSources: Object.keys(actionDecisions),
+                conditionSources: Object.keys(conditions),
+            },
+        };
+        const notify = () => {
+            if (decisions.onChange)
+                try {
+                    decisions.onChange(snapshot());
+                }
+                catch (error) {
+                    console.error('FORM_VIEW_UPDATE_FAILED', error);
+                }
+        };
+        const snapshot = () => clone({ state, mode, draft, selected, busy, limitations });
+        const dirty = () => !!draft && !same(draft, original);
+        const choices = (f) => f.kind === 'entity'
+            ? (entities[f.key] || []).map((o) => ({ value: String(o.value), label: String(o.label) }))
+            : options(f);
+        const writable = (f) => {
+            if (!draft || !['add', 'edit'].includes(mode))
+                fail('DRAFT_REQUIRED', '请先打开可编辑草稿');
+            if (f.readOnly ||
+                f.hidden ||
+                f.kind === 'unsupported' ||
+                f.issues.includes('dynamic-field-rule-requires-decision'))
+                fail('FIELD_READONLY', '此字段只读或包含尚未支持的动态规则', f.source);
+        };
+        const validateValue = (f, value) => {
+            if (empty(value))
+                return f.required ? '此字段必填' : undefined;
+            if (['text', 'textarea', 'tel', 'email'].includes(f.kind) && typeof value !== 'string')
+                return '请输入文本';
+            if (f.maxLength !== undefined && text(value).length > f.maxLength)
+                return `最多 ${f.maxLength} 个字符`;
+            if (f.kind === 'email' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+                return '邮箱格式无效';
+            if (f.kind === 'number') {
+                try {
+                    if (typeof value === 'number' &&
+                        !Number.isSafeInteger(value) &&
+                        Math.abs(value) >= Number.MAX_SAFE_INTEGER)
+                        return '大数请使用字符串避免精度丢失';
+                    const n = decimal(value);
+                    if (f.precision !== undefined && n.scale > f.precision)
+                        return `最多 ${f.precision} 位小数`;
+                    if ((f.min !== undefined && compare(value, f.min, f) < 0) ||
+                        (f.max !== undefined && compare(value, f.max, f) > 0))
+                        return '数值超出配置范围';
+                }
+                catch {
+                    return '请输入有效数字';
+                }
+            }
+            if (f.kind === 'date') {
+                const v = String(value).replace(' ', 'T'), match = v.match(/^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2}))?)?$/);
+                if (!match)
+                    return '日期格式无效';
+                const [year, month, day, hour = 0, minute = 0, second = 0] = match
+                    .slice(1)
+                    .map((v) => (v === undefined ? 0 : Number(v)));
+                if (month < 1 ||
+                    month > 12 ||
+                    day < 1 ||
+                    day > new Date(Date.UTC(year, month, 0)).getUTCDate() ||
+                    hour > 23 ||
+                    minute > 59 ||
+                    second > 59)
+                    return '日期范围无效';
+            }
+            if (['select', 'radio', 'multi', 'cascader', 'entity'].includes(f.kind)) {
+                const many = f.multiple || f.kind === 'multi';
+                if (many !== Array.isArray(value))
+                    return many ? '此字段需要多选值' : '此字段需要单选值';
+                const allowed = choices(f).map((o) => o.value);
+                if ((many ? value : [value]).some((v) => typeof v !== 'string' || !allowed.includes(v)))
+                    return '选择值不在已配置选项中';
+            }
+        };
+        const set = (key, value, rowIndex) => {
+            if (busy)
+                fail('FORM_BUSY', '操作进行中，请稍后');
+            const f = field(key);
+            writable(f);
+            const target = f.group ? draft.details?.[f.group]?.[rowIndex]?.fields : draft.fields;
+            if (!target)
+                fail('DETAIL_ROW_UNKNOWN', '明细行不存在', f.source);
+            // Keep invalid input in the draft; saving validates and focuses its control.
+            target[f.id] = clone(value);
+            notify();
+        };
+        const validation = () => {
+            const errors = [];
+            for (const f of contract.fields) {
+                if (f.hidden)
+                    continue;
+                const rows = f.group ? draft?.details?.[f.group] || [] : [draft];
+                rows.forEach((row, rowIndex) => {
+                    if (f.kind === 'unsupported' && f.required && empty(row?.fields?.[f.id])) {
+                        errors.push({
+                            key: f.key,
+                            rowIndex: f.group ? rowIndex : undefined,
+                            message: '必填控件尚未支持，不能将缺值记录保存为完成',
+                        });
+                        return;
+                    }
+                    if (f.readOnly || f.kind === 'unsupported')
+                        return;
+                    const message = validateValue(f, row?.fields?.[f.id]);
+                    if (message)
+                        errors.push({ key: f.key, rowIndex: f.group ? rowIndex : undefined, message });
+                });
+            }
+            return errors;
+        };
+        const query = (spec = querySpec) => {
+            const filters = spec.filters || [], sort = spec.sort || [], pageSize = spec.pageSize ?? 20;
+            if (!Array.isArray(filters))
+                fail('QUERY_INVALID', 'filters 必须是条件数组，例如 [{field:"字段key",op:"eq",value:"值"}]；无筛选用 []', 'filters');
+            if (!Array.isArray(sort))
+                fail('QUERY_INVALID', 'sort 必须是排序数组，例如 [{field:"字段key",direction:"asc"}]；无排序用 []', 'sort');
+            if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 500)
+                fail('QUERY_INVALID', 'pageSize 必须是 1..500 的整数；全量筛选结果使用 orderedIds，不传超大分页值', 'pageSize');
+            if (spec.page !== undefined && (!Number.isInteger(spec.page) || spec.page < 1))
+                fail('QUERY_INVALID', 'page 必须是从 1 开始的整数；更改筛选时传 page:1', 'page');
+            filters.forEach((c) => validateCondition(c));
+            for (const order of sort)
+                if (field(order.field).group || !['asc', 'desc'].includes(order.direction))
+                    fail('SORT_INVALID', '排序字段或方向无效');
+            let rows = state.records.filter((r) => filters.every((f) => matches(r, f)));
+            rows = [...rows].sort((a, b) => {
+                for (const order of sort) {
+                    const f = field(order.field), n = compare(a.fields[f.id], b.fields[f.id], f);
+                    if (n)
+                        return n * (order.direction === 'desc' ? -1 : 1);
+                }
+                return 0;
+            });
+            const pageCount = Math.max(1, Math.ceil(rows.length / pageSize)), page = Math.min(spec.page || 1, pageCount);
+            selected = selected.filter((id) => rows.some((r) => r.id === id));
+            querySpec = clone({ ...spec, page, pageSize });
+            return clone({
+                records: rows.slice((page - 1) * pageSize, page * pageSize),
+                orderedIds: rows.map((r) => r.id),
+                total: rows.length,
+                page,
+                pageSize,
+                pageCount,
+                selected,
+            });
+        };
+        const confirmation = async (message) => (decisions.confirm ? await decisions.confirm(message) : window.confirm(message)) === true;
+        const fresh = () => ({
+            id: `demo-${crypto.randomUUID()}`,
+            fields: {},
+            details: Object.fromEntries([...new Set(contract.fields.filter((f) => f.group).map((f) => f.group))].map((group) => [
+                group,
+                [],
+            ])),
+        });
+        const open = async (nextMode, id) => {
+            if (!['add', 'view', 'edit'].includes(nextMode))
+                fail('MODE_INVALID', '打开模式无效');
+            if (dirty() && !(await confirmation('放弃尚未保存的修改？')))
+                return false;
+            const row = nextMode === 'add' ? fresh() : state.records.find((r) => r.id === id);
+            if (!row)
+                fail('RECORD_MISSING', '记录不存在');
+            mode = nextMode;
+            draft = clone(row);
+            original = clone(row);
+            notify();
+            return true;
+        };
+        const commit = async (next, operation, recordIds) => {
+            next.logs ||= [];
+            next.logs.push({
+                id: crypto.randomUUID(),
+                operation,
+                recordIds,
+                at: new Date().toISOString(),
+                origin: 'local',
+                changes: operation === 'save' ? { before: original, after: draft } : undefined,
+            });
+            state = await store.compareSave(state, next);
+            query();
+        };
+        const save = async (again) => {
+            if (!draft || !['add', 'edit'].includes(mode))
+                fail('DRAFT_REQUIRED', '没有可保存的草稿');
+            const errors = validation();
+            if (errors.length) {
+                const target = [...document.querySelectorAll('[data-e10-field]')].find((el) => el.dataset.e10Field === errors[0].key);
+                target?.querySelector('input,select,textarea')?.focus();
+                const e = new Error(errors[0].message);
+                Object.assign(e, { code: 'FORM_VALIDATION', errors });
+                throw e;
+            }
+            const next = clone(state), index = next.records.findIndex((r) => r.id === draft.id);
+            if (mode === 'edit' && (index < 0 || !same(next.records[index], original)))
+                fail('FORM_CONFLICT', '原记录已变化，草稿已保留');
+            if (mode === 'add' && index >= 0)
+                fail('FORM_CONFLICT', '新记录 ID 已存在');
+            if (index < 0)
+                next.records.push(clone(draft));
+            else
+                next.records[index] = clone(draft);
+            await commit(next, 'save', [draft.id]);
+            original = clone(draft);
+            const savedId = draft.id;
+            if (again) {
+                mode = 'add';
+                draft = fresh();
+                original = clone(draft);
+            }
+            else
+                mode = 'view';
+            notify();
+            return { saved: true, recordId: savedId };
+        };
+        const preflight = (button, row) => {
+            if (!button.enabled || button.mode !== mode)
+                fail('BUTTON_UNAVAILABLE', '当前模式没有此按钮', button.source);
+            if (button.conditionRequired && !conditions[button.source])
+                fail('CONDITION_UNSUPPORTED', '按钮条件尚未映射', button.source);
+            if (conditions[button.source] && !matches(row, conditions[button.source]))
+                fail('CONDITION_FALSE', '当前记录不满足按钮条件', button.source);
+            const actions = button.actions.filter((a) => a.enabled !== false);
+            if (!actions.length)
+                fail('ACTION_UNSUPPORTED', '没有已配置动作', button.source);
+            for (const a of actions) {
+                if (a.enabled !== true ||
+                    !supported.has(a.op) ||
+                    (a.conditionRequired && !conditions[a.source]))
+                    fail('ACTION_UNSUPPORTED', '动作或条件未支持，整条动作链未执行', a.source);
+                if (conditions[a.source] && !matches(row, conditions[a.source]))
+                    fail('CONDITION_FALSE', '不满足动作条件，整条动作链未执行', a.source);
+            }
+            // Multiple writes and post-commit branching require an explicit transaction domain.
+            if (actions.length > 1)
+                fail('ACTION_CHAIN_UNSUPPORTED', '多步骤动作链仅展示配置说明，本轮不执行', button.source);
+            return actions;
+        };
+        const execute = async (key, params = {}) => {
+            if (busy)
+                fail('FORM_BUSY', '操作进行中，请勿重复提交');
+            const button = buttons.get(key);
+            if (!button)
+                fail('BUTTON_UNKNOWN', '按钮不属于本菜单或模式', key);
+            if (!params || typeof params !== 'object' || Array.isArray(params))
+                fail('ACTION_PARAMS', '动作参数无效');
+            const targetIds = params.ids || (params.recordId ? [params.recordId] : selected);
+            if (!Array.isArray(targetIds) || targetIds.some((id) => typeof id !== 'string'))
+                fail('ACTION_PARAMS', '操作目标必须为记录 ID 数组');
+            const targetRows = mode === 'list' && targetIds.length
+                ? targetIds.map((id) => state.records.find((r) => r.id === id))
+                : [draft || state.records.find((r) => r.id === params.recordId)];
+            if (targetRows.some((row) => !row) && targetIds.length)
+                fail('RECORD_MISSING', '操作目标记录不存在');
+            const actions = preflight(button, targetRows[0]);
+            for (const row of targetRows.slice(1))
+                preflight(button, row);
+            busy = true;
+            try {
+                const results = [];
+                for (const action of actions) {
+                    let result;
+                    switch (action.op) {
+                        case 'add':
+                        case 'view':
+                        case 'edit':
+                            result = await open(action.op, params.recordId);
+                            break;
+                        case 'save':
+                        case 'saveNew':
+                            result = await save(action.op === 'saveNew');
+                            break;
+                        case 'cancel':
+                            if (dirty() && !(await confirmation('放弃尚未保存的修改？')))
+                                return { ok: false, cancelled: true };
+                            mode = 'list';
+                            draft = original = null;
+                            result = true;
+                            break;
+                        case 'delete': {
+                            const ids = params.ids || (params.recordId ? [params.recordId] : selected);
+                            if (!Array.isArray(ids) ||
+                                !ids.length ||
+                                new Set(ids).size !== ids.length ||
+                                ids.some((id) => !state.records.some((r) => r.id === id)))
+                                fail('SELECTION_INVALID', '请选择有效记录');
+                            if (!(await confirmation(`删除所选 ${ids.length} 条本地记录？`)))
+                                return { ok: false, cancelled: true };
+                            const next = clone(state);
+                            next.records = next.records.filter((r) => !ids.includes(r.id));
+                            await commit(next, 'delete', ids);
+                            if (draft && ids.includes(draft.id)) {
+                                draft = original = null;
+                                mode = 'list';
+                            }
+                            result = true;
+                            break;
+                        }
+                    }
+                    if (result === false)
+                        return { ok: false, cancelled: true };
+                    results.push(result);
+                }
+                notify();
+                return { ok: true, results };
+            }
+            finally {
+                busy = false;
+                notify();
+            }
+        };
+        const mount = (container, key, rowIndex) => {
+            const f = field(key);
+            let value = f.group
+                ? draft?.details?.[f.group]?.[rowIndex]?.fields?.[f.id]
+                : draft?.fields?.[f.id];
+            container.replaceChildren();
+            container.dataset.e10Field = key;
+            const label = document.createElement('label'), caption = document.createElement('span'), error = document.createElement('small');
+            caption.textContent = f.label + (f.required ? ' *' : '');
+            label.append(caption);
+            container.append(label, error);
+            error.setAttribute('role', 'alert');
+            if (f.hidden) {
+                container.hidden = true;
+                return;
+            }
+            container.hidden = false;
+            if (mode === 'view' ||
+                f.readOnly ||
+                f.kind === 'unsupported' ||
+                f.issues.includes('dynamic-field-rule-requires-decision')) {
+                const output = document.createElement('output');
+                output.textContent = format(key, value);
+                label.append(output);
+                return;
+            }
+            const update = (v) => {
+                try {
+                    set(key, v, rowIndex);
+                    error.textContent = validateValue(f, v) || '';
+                }
+                catch (e) {
+                    error.textContent = e.message;
+                }
+            };
+            let input;
+            if (['select', 'radio', 'multi', 'cascader', 'entity'].includes(f.kind)) {
+                input = document.createElement('select');
+                input.multiple = f.multiple || f.kind === 'multi';
+                const populate = (search) => {
+                    input.replaceChildren();
+                    if (!input.multiple) {
+                        const option = document.createElement('option');
+                        option.value = '';
+                        option.textContent = '请选择';
+                        input.append(option);
+                    }
+                    for (const o of choices(f))
+                        if (!search ||
+                            o.label.includes(search) ||
+                            (Array.isArray(value) ? value : [value]).includes(o.value)) {
+                            const option = document.createElement('option');
+                            option.value = o.value;
+                            option.textContent = o.label;
+                            option.selected = (Array.isArray(value) ? value : [value]).includes(o.value);
+                            input.append(option);
+                        }
+                };
+                populate('');
+                if (f.kind === 'entity') {
+                    const search = document.createElement('input');
+                    search.type = 'search';
+                    search.placeholder = '搜索';
+                    search.setAttribute('aria-label', `搜索${f.label}`);
+                    search.oninput = () => populate(search.value);
+                    label.append(search);
+                }
+                input.onchange = () => {
+                    value = input.multiple ? [...input.selectedOptions].map((o) => o.value) : input.value;
+                    update(value);
+                };
+            }
+            else {
+                input = document.createElement(f.kind === 'textarea' ? 'textarea' : 'input');
+                if (f.kind !== 'textarea')
+                    input.type =
+                        f.kind === 'date'
+                            ? f.format?.includes('HH')
+                                ? 'datetime-local'
+                                : 'date'
+                            : ['email', 'tel'].includes(f.kind)
+                                ? f.kind
+                                : 'text';
+                if (f.kind === 'number')
+                    input.inputMode = 'decimal';
+                input.value = f.kind === 'date' ? text(value).replace(' ', 'T') : text(value);
+                input.oninput = () => update(input.value);
+            }
+            input.setAttribute('aria-label', f.label);
+            label.append(input);
+        };
+        const format = (key, value) => {
+            const f = field(key);
+            if (empty(value))
+                return '—';
+            if (['select', 'radio', 'multi', 'cascader', 'entity'].includes(f.kind))
+                return (Array.isArray(value) ? value : [value])
+                    .map((v) => choices(f).find((o) => o.value === String(v))?.label || text(v))
+                    .join('、');
+            if (f.kind === 'number') {
+                const parts = String(value).split('.');
+                parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+                return parts.join('.');
+            }
+            return text(value);
+        };
+        return Object.freeze({
+            snapshot,
+            query,
+            async open(nextMode, id) {
+                if (busy)
+                    fail('FORM_BUSY', '操作进行中');
+                busy = true;
+                try {
+                    return await open(nextMode, id);
+                }
+                finally {
+                    busy = false;
+                    notify();
+                }
+            },
+            set,
+            mount,
+            format,
+            execute,
+            validate: validation,
+            dirty,
+            buttons: () => [...buttons.values()]
+                .filter((b) => b.mode === mode)
+                .map((b) => {
+                try {
+                    preflight(b, draft);
+                    return { ...clone(b), available: true };
+                }
+                catch (e) {
+                    return { ...clone(b), available: false, reason: e.message };
+                }
+            }),
+            select(ids) {
+                const allowed = query().orderedIds;
+                if (!Array.isArray(ids) || ids.some((id) => !allowed.includes(id)))
+                    fail('SELECTION_INVALID', '选择不在当前结果中');
+                selected = [...new Set(ids)];
+                return clone(selected);
+            },
+            addDetail(group) {
+                if (busy)
+                    fail('FORM_BUSY', '操作进行中');
+                if (!draft ||
+                    !['add', 'edit'].includes(mode) ||
+                    !contract.fields.some((f) => f.group === group))
+                    fail('DETAIL_GROUP', '明细分组或模式无效');
+                draft.details ||= {};
+                draft.details[group] ||= [];
+                draft.details[group].push({ id: `demo-${crypto.randomUUID()}`, fields: {} });
+                notify();
+            },
+            removeDetail(group, index) {
+                if (busy)
+                    fail('FORM_BUSY', '操作进行中');
+                if (!draft ||
+                    !['add', 'edit'].includes(mode) ||
+                    !Number.isInteger(index) ||
+                    index < 0 ||
+                    !draft.details?.[group]?.[index])
+                    fail('DETAIL_ROW_UNKNOWN', '明细行不存在');
+                draft.details[group].splice(index, 1);
+                notify();
+            },
+            async close() {
+                if (busy)
+                    fail('FORM_BUSY', '操作进行中');
+                busy = true;
+                try {
+                    if (dirty() && !(await confirmation('放弃尚未保存的修改？')))
+                        return false;
+                    mode = 'list';
+                    draft = original = null;
+                    return true;
+                }
+                finally {
+                    busy = false;
+                    notify();
+                }
+            },
+        });
+    }
+    Object.defineProperty(window, 'E10FormUI', {
+        value: Object.freeze({ contract: clone(contract), create }),
+        configurable: true,
+    });
+}