@svadmin/ui 0.72.0 → 0.73.0

package/dist/components/json-schema-form-state.js

@@ -0,0 +1,168 @@
+export const SCHEMA_FORM_LIMITS = Object.freeze({ depth: 32, nodes: 10_000, characters: 1_048_576 });
+const unsafe = new Set(['__proto__', 'prototype', 'constructor']);
+const record = (value) => value !== null
+    && typeof value === 'object' && !Array.isArray(value)
+    && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+function safeKey(key) {
+    if (unsafe.has(key))
+        throw new Error('Unsafe form field');
+}
+/** wire 模式仅省略对象的 undefined；数组的空洞/undefined 不能偷偷转成 null。 */
+function copy(value, wire) {
+    const active = new Set();
+    let nodes = 0, characters = 0;
+    function visit(current, depth) {
+        if (++nodes > SCHEMA_FORM_LIMITS.nodes || depth > SCHEMA_FORM_LIMITS.depth)
+            throw new Error('Form value exceeds limits');
+        if (current === undefined && !wire)
+            return undefined;
+        if (current === null || typeof current === 'boolean')
+            return current;
+        if (typeof current === 'number' && Number.isFinite(current))
+            return current;
+        if (typeof current === 'string') {
+            characters += current.length;
+            if (characters > SCHEMA_FORM_LIMITS.characters)
+                throw new Error('Form text exceeds limits');
+            return current;
+        }
+        if ((!record(current) && !Array.isArray(current)) || active.has(current))
+            throw new Error('Expected acyclic plain form data');
+        active.add(current);
+        try {
+            if (Reflect.ownKeys(current).some(key => typeof key === 'symbol'))
+                throw new Error('Symbol values are not JSON fields');
+            if (Array.isArray(current)) {
+                if (current.length > SCHEMA_FORM_LIMITS.nodes)
+                    throw new Error('Form array exceeds limits');
+                const result = [];
+                for (let index = 0; index < current.length; index++) {
+                    const descriptor = Object.getOwnPropertyDescriptor(current, String(index));
+                    if (!descriptor || !('value' in descriptor))
+                        throw new Error('Sparse arrays and accessors are not form data');
+                    result.push(visit(descriptor.value, depth + 1));
+                }
+                if (Object.keys(current).some(key => !/^(0|[1-9][0-9]*)$/u.test(key) || Number(key) >= current.length)) {
+                    throw new Error('Array properties are not JSON fields');
+                }
+                return result;
+            }
+            const result = {};
+            for (const key of Object.keys(current)) {
+                safeKey(key);
+                characters += key.length;
+                if (characters > SCHEMA_FORM_LIMITS.characters)
+                    throw new Error('Form text exceeds limits');
+                const descriptor = Object.getOwnPropertyDescriptor(current, key);
+                if (!descriptor || !('value' in descriptor))
+                    throw new Error('Accessors are not form data');
+                if (!wire || descriptor.value !== undefined)
+                    result[key] = visit(descriptor.value, depth + 1);
+            }
+            return result;
+        }
+        finally {
+            active.delete(current);
+        }
+    }
+    return visit(value, 0);
+}
+/** Svelte 代理也通过普通数据属性读取；回调永远收不到活跃草稿的引用。 */
+export function schemaFormSnapshot(value) {
+    if (!record(value))
+        throw new Error('Form root must be an object');
+    return copy(value, true);
+}
+/** 默认值只填“缺失的键”；显式 undefined/null/false/0/空串都表示调用方的决定。 */
+export function initializeSchemaForm(schema, value) {
+    if (!record(value))
+        throw new Error('Form root must be an object');
+    const active = new Set();
+    let nodes = 0;
+    function visit(node, current, present, required, depth) {
+        if (++nodes > SCHEMA_FORM_LIMITS.nodes || depth > SCHEMA_FORM_LIMITS.depth || !record(node) || active.has(node)) {
+            throw new Error('Form schema exceeds supported traversal limits');
+        }
+        active.add(node);
+        try {
+            if (!present) {
+                if (Object.hasOwn(node, 'default'))
+                    current = copy(node.default, false);
+                else if (node.type === 'object' || node.properties)
+                    current = {};
+                else if (node.type === 'array')
+                    current = [];
+                else if (node.type === 'boolean' && required)
+                    current = false;
+            }
+            if (record(current) && (node.type === 'object' || node.properties)) {
+                let result = current;
+                for (const [key, child] of Object.entries(node.properties ?? {})) {
+                    safeKey(key);
+                    const exists = Object.hasOwn(current, key);
+                    const next = visit(child, exists ? current[key] : undefined, exists, node.required?.includes(key) ?? false, depth + 1);
+                    if ((!exists && next !== undefined) || (exists && next !== current[key])) {
+                        if (result === current)
+                            result = { ...current };
+                        result[key] = next;
+                    }
+                }
+                return result;
+            }
+            if (Array.isArray(current) && node.type === 'array' && node.items) {
+                if (current.length > SCHEMA_FORM_LIMITS.nodes)
+                    throw new Error('Form array exceeds limits');
+                const array = current;
+                const items = array.map(item => visit(node.items, item, true, true, depth + 1));
+                return items.some((item, index) => item !== array[index]) ? items : array;
+            }
+            return current;
+        }
+        finally {
+            active.delete(node);
+        }
+    }
+    return visit(schema, value, true, true, 0);
+}
+export function schemaFormArrayItem(schema) {
+    // 新增对象项也初始化其嵌套默认值及必填 false；数字留空，不猜测为 0。
+    const seed = Object.hasOwn(schema, 'default') ? copy(schema.default, false)
+        : schema.type === 'object' || schema.properties ? {}
+            : schema.type === 'array' ? [] : schema.type === 'boolean' ? false : schema.type === 'number' || schema.type === 'integer' ? undefined : '';
+    return initializeSchemaForm({ properties: { item: schema }, required: ['item'] }, { item: seed })['item'];
+}
+export function writeSchemaFormPath(value, path, nextValue) {
+    if (!path.length || path.length > SCHEMA_FORM_LIMITS.depth)
+        throw new Error('Invalid form path');
+    const next = copy(value, false);
+    let target = next;
+    for (const [index, key] of path.entries()) {
+        safeKey(key);
+        if (Array.isArray(target) && (!/^(0|[1-9][0-9]*)$/u.test(key) || Number(key) >= target.length))
+            throw new Error('Invalid array field');
+        if (index === path.length - 1) {
+            Reflect.set(target, key, copy(nextValue, false));
+        }
+        else {
+            let child = Object.hasOwn(target, key) ? Reflect.get(target, key) : undefined;
+            if (!record(child) && !Array.isArray(child)) {
+                child = {};
+                Reflect.set(target, key, child);
+            }
+            target = child;
+        }
+    }
+    return next;
+}
+/** option.value 是索引，不是 String(value)：1 与 "1"、null 与 "null" 必须可区分。 */
+export function schemaFormEnumIndex(choices, value) {
+    const index = choices.findIndex(choice => choice === value);
+    return index === -1 ? '' : String(index);
+}
+export function schemaFormEnumValue(choices, index) {
+    if (index === '')
+        return undefined;
+    if (!/^(0|[1-9][0-9]*)$/u.test(index) || !Object.hasOwn(choices, Number(index)))
+        throw new Error('Invalid form choice');
+    return choices[Number(index)];
+}

package/dist/components/record-detail.svelte.d.ts

@@ -1,13 +1,16 @@
+import { type ResourceRendering } from '../rendering/index.js';
 /** Views mount this only when they have an explicit record ID. */
 export declare function useRecordDetail(options: () => {
     resourceName: string;
     id: string | number;
+    rendering?: ResourceRendering | undefined;
 }): {
     query: import("@tanstack/query-core").QueryObserverResult<import("@svadmin/core").GetOneResult<import("@svadmin/core").BaseRecord & {
         id: string | number;
     }>, unknown> & {
         overtime: import("@svadmin/core").OvertimeResult;
     };
+    readonly rendering: ResourceRendering | undefined;
     readonly resource: import("@svadmin/core").ResourceDefinition;
     readonly fields: import("@svadmin/core").FieldDefinition[];
     readonly canRead: boolean;

package/dist/components/record-detail.svelte.js

@@ -1,20 +1,26 @@
+import { bindResourceRendering } from '../rendering/index.js';
 import { captureAdminContext, useOne, useCan, useResourceContract } from '@svadmin/core';
 /** Views mount this only when they have an explicit record ID. */
 export function useRecordDetail(options) {
     const context = captureAdminContext();
     const binding = useResourceContract(() => options().resourceName);
+    const rendering = $derived(bindResourceRendering(options().rendering, binding.resource));
     const resource = $derived(context.getResource(options().resourceName));
     const permission = useCan(() => ({
         resource: options().resourceName, action: 'show', id: options().id,
         queryOptions: { enabled: resource.canShow !== false },
     }));
     const canRead = $derived(resource.canShow !== false && permission.allowed === true);
-    const query = useOne(() => ({
-        resource: binding.resource, id: options().id, dataProviderName: binding.dataProviderName,
-        queryOptions: { enabled: canRead },
-    }));
+    const query = useOne(() => {
+        void rendering;
+        return {
+            resource: binding.resource, id: options().id, dataProviderName: binding.dataProviderName,
+            queryOptions: { enabled: canRead },
+        };
+    });
     return {
         query,
+        get rendering() { return rendering; },
         get resource() { return resource; },
         get fields() { return resource.fields.filter(field => field.showInShow !== false); },
         get canRead() { return canRead; },

package/dist/components/svar-grid-cells.d.ts

@@ -0,0 +1,14 @@
+import type { Snippet } from 'svelte';
+import type { SvarRecordId } from './svar-grid-operations.js';
+export interface SvarCellContent {
+    readonly id: SvarRecordId;
+    readonly field: string;
+    readonly value: unknown;
+    readonly record: Record<string, unknown>;
+}
+export interface SvarCellContext {
+    readonly render: () => Snippet<[SvarCellContent]> | undefined;
+    readonly resolve: (row: unknown, column: unknown) => SvarCellContent | undefined;
+}
+/** 仅可信宿主可提供原生 snippet；不把引擎 api 或 exec 传给内容组件。 */
+export declare const SVAR_CELL_CONTEXT: unique symbol;

package/dist/components/svar-grid-cells.js

@@ -0,0 +1,2 @@
+/** 仅可信宿主可提供原生 snippet；不把引擎 api 或 exec 传给内容组件。 */
+export const SVAR_CELL_CONTEXT = Symbol('svadmin.svar.cell');

package/dist/components/svar-grid-contract.d.ts

@@ -0,0 +1,80 @@
+/** SVAR 2.7 的窄适配契约。应用注入 Grid，未启用的页面无需安装或加载 SVAR。 */
+export interface SvarColumn {
+    readonly key: string;
+    readonly label: string;
+    readonly width?: number;
+    readonly sortable?: boolean;
+    /** 首批内建列过滤只支持文本 contains；其他过滤通过资源 filters 传入。 */
+    readonly filterable?: boolean;
+}
+export interface SvarSort {
+    readonly field: string;
+    readonly order: 'asc' | 'desc';
+}
+export interface SvarTextFilter {
+    readonly field: string;
+    readonly operator: 'contains';
+    readonly value: string;
+}
+export interface SvarRow {
+    id: string;
+    data?: SvarRow[];
+    open?: boolean;
+    [key: string]: unknown;
+}
+export interface SvarEngineColumn {
+    id: string;
+    header: string | (string | {
+        filter: 'text';
+    })[];
+    width?: number;
+    flexgrow?: number;
+    sort: boolean;
+    resize: boolean;
+    treetoggle: boolean;
+}
+export interface SvarGridApi {
+    intercept(action: string, callback: (event: unknown) => false | undefined): void;
+}
+/** 仅使用已核对的上游属性；不暴露任意 editor、template 或事件执行入口。 */
+export interface SvarGridEngineProps {
+    /** 上游声明带事件索引；适配层不直接转发任何事件 prop。 */
+    [event: `on${string}`]: never;
+    columns: SvarEngineColumn[];
+    data?: SvarRow[];
+    tree?: boolean;
+    split?: {
+        left?: number;
+    };
+    sizes?: {
+        rowHeight?: number;
+        headerHeight?: number;
+        columnWidth?: number;
+    };
+    sortMarks?: Record<string, {
+        order: 'asc' | 'desc';
+        index?: number;
+    }>;
+    filterValues?: Record<string, string>;
+    select?: boolean;
+    multiselect?: boolean;
+    reorder?: boolean;
+    draggableRows?: boolean;
+    undo?: boolean;
+    init?: (api: SvarGridApi) => void;
+}
+export declare function svarColumnId(key: string): string;
+export declare function checkedSvarColumns(columns: readonly SvarColumn[]): SvarColumn[];
+export declare function buildSvarColumns(columns: readonly SvarColumn[], tree: boolean): SvarEngineColumn[];
+export declare function projectSvarRows(items: readonly Record<string, unknown>[], columns: readonly SvarColumn[], primaryKey?: string, childrenKey?: string): SvarRow[];
+export declare function nextSvarSort(event: unknown, columns: readonly SvarColumn[], current: readonly SvarSort[]): SvarSort[] | undefined;
+export declare function nextSvarFilter(event: unknown, columns: readonly SvarColumn[], current: readonly SvarTextFilter[]): SvarTextFilter[] | undefined;
+export declare function svarSortMarks(sorters: readonly SvarSort[]): NonNullable<SvarGridEngineProps['sortMarks']>;
+export declare function svarFilterValues(filters: readonly SvarTextFilter[]): Record<string, string>;
+export declare const SVAR_BLOCKED_ACTIONS: readonly ["add-row", "delete-row", "update-row", "update-cell", "copy-row", "move-item", "open-editor", "editor", "undo", "redo", "export-data", "print"];
+export declare function installSvarGuards(api: SvarGridApi, options: {
+    current: () => boolean;
+    server: () => boolean;
+    sort: (event: unknown) => void;
+    filter: (event: unknown) => void;
+}): void;

package/dist/components/svar-grid-contract.js

@@ -0,0 +1,159 @@
+const forbidden = new Set(['__proto__', 'prototype', 'constructor']);
+function fieldName(value) {
+    return typeof value === 'string' && value.length > 0 && !forbidden.has(value);
+}
+export function svarColumnId(key) {
+    return `column:${encodeURIComponent(key)}`;
+}
+export function checkedSvarColumns(columns) {
+    if (!Array.isArray(columns) || columns.length === 0)
+        throw new Error('At least one grid column is required');
+    const ids = new Set();
+    return columns.map(column => {
+        if (!column || !fieldName(column.key) || typeof column.label !== 'string' || ids.has(column.key)) {
+            throw new Error('Invalid or duplicate grid column');
+        }
+        if (column.width !== undefined && (!Number.isFinite(column.width) || column.width < 40 || column.width > 4096)) {
+            throw new Error('Grid column width must be between 40 and 4096');
+        }
+        ids.add(column.key);
+        // 显式投影，拒绝将宿主对象上的 editor/template 等额外属性传入 Grid。
+        return {
+            key: column.key, label: column.label,
+            sortable: column.sortable === true, filterable: column.filterable === true,
+            ...(column.width === undefined ? {} : { width: column.width }),
+        };
+    });
+}
+export function buildSvarColumns(columns, tree) {
+    return columns.map((column, index) => ({
+        id: svarColumnId(column.key),
+        header: column.filterable ? [column.label, { filter: 'text' }] : column.label,
+        ...(column.width === undefined ? { flexgrow: 1 } : { width: column.width }),
+        sort: column.sortable === true, resize: true, treetoggle: tree && index === 0,
+    }));
+}
+function ownValue(record, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    if (!descriptor)
+        return undefined;
+    if (!('value' in descriptor))
+        throw new Error('Grid records must not contain accessors');
+    return descriptor.value;
+}
+function scalar(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    // 复杂字段需要独立格式化；不隐式调用用户对象的 toString/toJSON。
+    return '—';
+}
+export function projectSvarRows(items, columns, primaryKey = 'id', childrenKey) {
+    if (!Array.isArray(items) || !fieldName(primaryKey) || (childrenKey !== undefined && !fieldName(childrenKey))) {
+        throw new Error('Invalid grid data configuration');
+    }
+    const ids = new Set();
+    const ancestors = new Set();
+    function visit(rows, depth) {
+        if (depth > 64)
+            throw new Error('Grid tree is too deep');
+        return rows.map(record => {
+            if (!record || typeof record !== 'object' || Array.isArray(record) || ancestors.has(record)) {
+                throw new Error('Invalid or cyclic grid record');
+            }
+            const id = ownValue(record, primaryKey);
+            if (!(typeof id === 'string' && id.length > 0) && !(typeof id === 'number' && Number.isFinite(id))) {
+                throw new Error('Every grid record requires a stable string or finite number ID');
+            }
+            // SVAR 内部 ID 使用字符串；防止数字 1 与字符串 "1" 相互覆盖。
+            const key = `${typeof id === 'number' ? 'n' : 's'}:${id}`;
+            if (ids.has(key))
+                throw new Error('Duplicate grid record ID');
+            ids.add(key);
+            const row = { id: key };
+            for (const column of columns)
+                row[svarColumnId(column.key)] = scalar(ownValue(record, column.key));
+            if (childrenKey !== undefined) {
+                const children = ownValue(record, childrenKey);
+                if (children !== undefined && !Array.isArray(children))
+                    throw new Error('Grid children must be an array');
+                if (Array.isArray(children) && children.length) {
+                    ancestors.add(record);
+                    row.data = visit(children, depth + 1);
+                    ancestors.delete(record);
+                    row.open = false;
+                }
+            }
+            return row;
+        });
+    }
+    return visit(items, 0);
+}
+function eventRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+export function nextSvarSort(event, columns, current) {
+    const value = eventRecord(event);
+    if (!value || (value['order'] !== undefined && value['order'] !== 'asc' && value['order'] !== 'desc')
+        || (value['add'] !== undefined && typeof value['add'] !== 'boolean'))
+        return undefined;
+    const column = columns.find(column => svarColumnId(column.key) === value['key'] && column.sortable);
+    if (!column)
+        return undefined;
+    const existing = current.find(sort => sort.field === column.key);
+    const order = value['order'] ?? (existing?.order === 'asc' ? 'desc' : 'asc');
+    const next = value['add'] ? current.map(sort => ({ ...sort })) : [];
+    const index = next.findIndex(sort => sort.field === column.key);
+    const sort = { field: column.key, order };
+    if (index < 0)
+        next.push(sort);
+    else
+        next[index] = sort;
+    return next;
+}
+export function nextSvarFilter(event, columns, current) {
+    const value = eventRecord(event);
+    if (!value || (value['value'] != null && typeof value['value'] !== 'string'))
+        return undefined;
+    const column = columns.find(column => svarColumnId(column.key) === value['key'] && column.filterable);
+    if (!column)
+        return undefined;
+    const next = current.filter(filter => filter.field !== column.key).map(filter => ({ ...filter }));
+    if (typeof value['value'] === 'string' && value['value'] !== '') {
+        next.push({ field: column.key, operator: 'contains', value: value['value'] });
+    }
+    return next;
+}
+export function svarSortMarks(sorters) {
+    return Object.fromEntries(sorters.map((sort, index) => [svarColumnId(sort.field), { order: sort.order, index }]));
+}
+export function svarFilterValues(filters) {
+    return Object.fromEntries(filters.map(filter => [svarColumnId(filter.field), filter.value]));
+}
+export const SVAR_BLOCKED_ACTIONS = [
+    'add-row', 'delete-row', 'update-row', 'update-cell', 'copy-row', 'move-item',
+    'open-editor', 'editor', 'undo', 'redo', 'export-data', 'print',
+];
+export function installSvarGuards(api, options) {
+    for (const action of SVAR_BLOCKED_ACTIONS)
+        api.intercept(action, () => false);
+    api.intercept('sort-rows', event => {
+        if (!options.current())
+            return false;
+        if (options.server()) {
+            options.sort(event);
+            return false;
+        }
+    });
+    api.intercept('filter-rows', event => {
+        if (!options.current())
+            return false;
+        if (options.server()) {
+            options.filter(event);
+            return false;
+        }
+    });
+}

package/dist/components/svar-grid-interactions.d.ts

@@ -0,0 +1,54 @@
+import type { SvarColumn, SvarEngineColumn, SvarGridApi, SvarGridEngineProps, SvarSort, SvarTextFilter } from './svar-grid-contract.js';
+import { svarRecordKey, type SvarRecordId } from './svar-grid-operations.js';
+export type SvarValueFormat = 'plain' | 'number' | 'currency' | 'percent' | 'date' | 'datetime' | 'boolean';
+export interface SvarInteractiveColumn extends SvarColumn {
+    readonly editable?: 'text' | 'number';
+    readonly format?: SvarValueFormat;
+    readonly currency?: string;
+}
+export interface SvarCellEdit {
+    readonly id: SvarRecordId;
+    readonly field: string;
+    readonly value: string | number;
+}
+export interface SvarInteractiveApi extends SvarGridApi {
+    on(action: string, callback: (event: unknown) => void): void;
+    getState(): {
+        selectedRows?: unknown;
+    };
+}
+export interface SvarInteractiveEngineProps extends Omit<SvarGridEngineProps, 'init' | 'columns'> {
+    columns: (SvarEngineColumn & {
+        editor?: 'text';
+        template?: (value: unknown) => string;
+    })[];
+    selectedRows?: (string | number)[];
+    init?: (api: SvarInteractiveApi) => void;
+}
+export declare function checkedSvarInteractiveColumns(columns: readonly SvarInteractiveColumn[]): SvarInteractiveColumn[];
+export declare function formatSvarValue(value: unknown, column: SvarInteractiveColumn, locale: string): string;
+export declare function buildSvarInteractiveColumns(columns: readonly SvarInteractiveColumn[], tree: boolean, editable: boolean, locale: string): SvarInteractiveEngineProps['columns'];
+export declare function resolveSvarCell(event: unknown, columns: readonly SvarInteractiveColumn[], index: Map<string, Record<string, unknown>>, primaryKey: string): {
+    id: SvarRecordId;
+    column: SvarInteractiveColumn;
+} | undefined;
+export declare function parseSvarCellEdit(event: unknown, columns: readonly SvarInteractiveColumn[], index: Map<string, Record<string, unknown>>, primaryKey: string): SvarCellEdit | undefined;
+/** 引擎永远不能自行写业务数据；编辑只生成宿主请求，成功后由查询数据回填。 */
+export declare function installSvarInteractions(api: SvarInteractiveApi, options: {
+    current: () => boolean;
+    columns: () => readonly SvarInteractiveColumn[];
+    items: () => readonly Record<string, unknown>[];
+    primaryKey: () => string;
+    childrenKey: () => string | undefined;
+    server: () => boolean;
+    sorters: () => readonly SvarSort[];
+    filters: () => readonly SvarTextFilter[];
+    sort: (sorters: SvarSort[]) => void;
+    filter: (filters: SvarTextFilter[]) => void;
+    editable: () => boolean;
+    edit: (edit: SvarCellEdit) => void;
+    selectable: () => boolean;
+    selection: (ids: SvarRecordId[]) => void;
+    error: (message: string) => void;
+}): void;
+export { svarRecordKey };