@svadmin/ui 0.72.0 → 0.74.0

package/dist/components/content/SettingsGroup.svelte

@@ -1,33 +1,17 @@
 <script lang="ts">
   import type { Snippet } from 'svelte';
-  import { cn } from '../../utils.js';
-
-  interface Props {
-    title: string;
-    description?: string;
-    actions?: Snippet;
-    children: Snippet;
-    class?: string;
-    bodyClass?: string;
-  }
-
-  let {
-    title,
-    description,
-    actions,
-    children,
-    class: className = '',
-    bodyClass = '',
-  }: Props = $props();
+  import { productSettingsRecipe as productSettings } from '../../recipes.js';
+  interface Props { title: string; description?: string; actions?: Snippet; children: Snippet; class?: string; bodyClass?: string; }
+  let { title, description, actions, children, class: className = '', bodyClass = '' }: Props = $props();
+  const styles = productSettings();
 </script>
-
-<section class={cn('svadmin-u-2cd02d11d1af svadmin-u-5f22e64f2282 svadmin-u-ca6bcd4b6f3f svadmin-u-18049387f0af svadmin-u-cd0ad9a56558 svadmin-u-438b2237b8d6', className)} data-svadmin-settings-group>
-  <header class="svadmin-u-60fbb7713999 svadmin-u-8dddea0773ed svadmin-u-1004c0c3954c svadmin-u-65fdbade2025 svadmin-u-18049387f0af svadmin-u-d139dd09e38d svadmin-u-cb11fec3bb46 svadmin-u-020ba687fa12 svadmin-u-64cac80d2e9a svadmin-u-3b9871a0bf93">
-    <div class="svadmin-u-7e0b7cdf1a94 svadmin-u-da7c36cd8867">
-      <h2 class="svadmin-u-fc7473ca09eb svadmin-u-e83a7042bc91 svadmin-u-d4108abe6359">{title}</h2>
-      {#if description}<p class="svadmin-u-2cc8041eca99 svadmin-u-fc7473ca09eb svadmin-u-18550d5945ae svadmin-u-bfa603190748">{description}</p>{/if}
+<section class={styles.root + ' ' + className} data-svadmin-settings-group>
+  <header class={styles.header}>
+    <div class={styles.heading}>
+      <h2 class={styles.title}>{title}</h2>
+      {#if description}<p class={styles.description}>{description}</p>{/if}
     </div>
-    {#if actions}<div class="svadmin-u-60fbb7713999 svadmin-u-012fbd121f37 svadmin-u-1eb5c6df38c1 svadmin-u-3960ffc248d9 svadmin-u-77a2a20e90d4">{@render actions()}</div>{/if}
+    {#if actions}<div class={styles.actions}>{@render actions()}</div>{/if}
   </header>
-  <div class={cn('svadmin-u-c07e54fd1439', bodyClass)}>{@render children()}</div>
+  <div class={styles.body + ' ' + bodyClass}>{@render children()}</div>
 </section>

package/dist/components/content/StatusBadge.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
   import { Badge } from '../ui/badge/index.js';
+  import { productStatusRecipe as productStatus } from '../../recipes.js';
   export type Status = 'success' | 'warning' | 'danger' | 'info' | 'neutral';
   interface Props {
     status: Status;
@@ -7,13 +8,7 @@
     class?: string;
   }
   let { status, label = status, class: className = '' }: Props = $props();
-  const toneClass: Record<Status, string> = {
-    success: 'svadmin-u-18a6e7a36f29 svadmin-u-17a9f7af2265 svadmin-u-76747e5e02ff',
-    warning: 'svadmin-u-2f960aa0c478 svadmin-u-283481e780bb svadmin-u-3a4ff758c2ab',
-    danger: 'svadmin-u-9d5d8b4711b4 svadmin-u-43928fcc832f svadmin-u-811148b13d1e',
-    info: 'svadmin-u-05f954a846d6 svadmin-u-375dc44df6e9 svadmin-u-20aaf08a7ed1',
-    neutral: 'svadmin-u-18049387f0af svadmin-u-2ef11f1cb219 svadmin-u-bfa603190748',
-  };
+  const styles = $derived(productStatus({ status }));
 </script>
 
-<Badge variant="outline" class={'svadmin-u-2689f3958069 ' + toneClass[status] + ' ' + className}>{label}</Badge>
+<Badge variant="outline" data-svadmin-status={status} class={styles.root + ' ' + className}>{label}</Badge>

package/dist/components/content/WorkspaceLayout.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
   import type { Snippet } from 'svelte';
-  import { cn } from '../../utils.js';
+  import { productWorkspaceRecipe as productWorkspace } from '../../recipes.js';
 
   interface Props {
     primary: Snippet;
@@ -24,19 +24,15 @@
     class: className = '',
   }: Props = $props();
 
+  const styles = $derived(productWorkspace({ hasSecondary: Boolean(secondary) }));
   const resolvedSecondaryWidth = $derived(secondaryCollapsed ? secondaryCollapsedWidth : secondaryWidth);
 </script>
 
-<div
-  class={cn('svadmin-u-60fbb7713999 svadmin-u-8dddea0773ed svadmin-u-0d304f904cb0', className)}
-  data-svadmin-workspace-layout
-  data-secondary-collapsed={secondaryCollapsed}
-  style:--workspace-secondary-width={resolvedSecondaryWidth}
->
-  {#if summary}<div data-svadmin-workspace-summary>{@render summary()}</div>{/if}
-  <div class={cn('svadmin-u-f3c543ad5fe9 svadmin-u-7e0b7cdf1a94 svadmin-u-60541e1e26f8 svadmin-u-0d304f904cb0 svadmin-u-febbcd95bf06', mobileOrder === 'secondary-first' && 'svadmin-u-dfb5e722be57')}>
-    {#if mobileOrder === 'secondary-first' && secondary}<aside class="svadmin-u-ea37b42b1c3b svadmin-u-7e0b7cdf1a94 svadmin-u-2c1f5e2b6a5b">{@render secondary()}</aside>{/if}
-    <div class={cn('svadmin-u-7e0b7cdf1a94', mobileOrder === 'secondary-first' ? 'svadmin-u-ef72121aca75 svadmin-u-831f8770959d' : 'svadmin-u-ea37b42b1c3b')} data-svadmin-workspace-primary>{@render primary()}</div>
-    {#if mobileOrder !== 'secondary-first' && secondary}<aside class="svadmin-u-ef72121aca75 svadmin-u-7e0b7cdf1a94 svadmin-u-2c1f5e2b6a5b">{@render secondary()}</aside>{/if}
+<div class={styles.root + ' ' + className} data-svadmin-workspace-layout data-secondary-collapsed={secondaryCollapsed} style:--workspace-secondary-width={resolvedSecondaryWidth}>
+  {#if summary}<div class={styles.summary} data-svadmin-workspace-summary>{@render summary()}</div>{/if}
+  <div class={styles.columns}>
+    {#if mobileOrder === 'secondary-first' && secondary}<aside class={styles.secondary} data-svadmin-workspace-secondary>{@render secondary()}</aside>{/if}
+    <div class={styles.primary} data-svadmin-workspace-primary>{@render primary()}</div>
+    {#if mobileOrder !== 'secondary-first' && secondary}<aside class={styles.secondary} data-svadmin-workspace-secondary>{@render secondary()}</aside>{/if}
   </div>
 </div>

package/dist/components/enterprise/filter-tree.d.ts

@@ -0,0 +1,48 @@
+import type { CrudOperator, FieldDefinition, Filter } from '@svadmin/core';
+export declare const FILTER_EDITOR_LIMITS: Readonly<{
+    depth: 12;
+    nodes: 256;
+    values: 1000;
+}>;
+export interface FilterRuleNode {
+    kind: 'rule';
+    id: string;
+    field: string;
+    operator: CrudOperator;
+    value: unknown;
+    readonly?: boolean;
+}
+export interface FilterGroupNode {
+    kind: 'group';
+    id: string;
+    operator: 'and' | 'or';
+    children: FilterNode[];
+    wrapped?: boolean;
+}
+export type FilterNode = FilterRuleNode | FilterGroupNode;
+export type FilterIssueCode = 'invalid-filter' | 'limit' | 'unknown-field' | 'operator' | 'value' | 'empty-group';
+export interface FilterEditorIssue {
+    path: string;
+    code: FilterIssueCode;
+}
+export type FilterTreeRead = {
+    ok: true;
+    root: FilterGroupNode;
+} | {
+    ok: false;
+    issues: FilterEditorIssue[];
+};
+export type FilterTreeCompile = {
+    ok: true;
+    filters: Filter[];
+} | {
+    ok: false;
+    issues: FilterEditorIssue[];
+};
+export declare const isCollectionOperator: (operator: CrudOperator) => boolean;
+export declare const isNullOperator: (operator: CrudOperator) => boolean;
+export declare function filterOperators(field: Pick<FieldDefinition, 'type'> | undefined): CrudOperator[];
+/** Filter[] 的顶层是隐式 AND；只有单个显式组可以成为编辑器根组，且保留包装信息。 */
+export declare function readFilterTree(input: unknown): FilterTreeRead;
+export declare function compileFilterTree(root: FilterGroupNode, fields: readonly FieldDefinition[], preserved?: ReadonlyMap<string, Filter>): FilterTreeCompile;
+export declare function parseFilterInput(raw: string, field: Pick<FieldDefinition, 'type'> | undefined, operator: CrudOperator): unknown;

package/dist/components/enterprise/filter-tree.js

@@ -0,0 +1,224 @@
+export const FILTER_EDITOR_LIMITS = Object.freeze({ depth: 12, nodes: 256, values: 1000 });
+const operators = ['eq', 'ne', 'lt', 'gt', 'lte', 'gte', 'contains', 'ncontains', 'startswith', 'endswith', 'in', 'nin', 'null', 'nnull', 'between', 'nbetween'];
+const comparison = ['eq', 'ne', 'lt', 'gt', 'lte', 'gte', 'in', 'nin', 'between', 'nbetween', 'null', 'nnull'];
+const selection = ['eq', 'ne', 'in', 'nin', 'null', 'nnull'];
+const text = ['eq', 'ne', 'contains', 'ncontains', 'startswith', 'endswith', 'in', 'nin', 'null', 'nnull'];
+const scalar = (value) => value === null || typeof value === 'string' || typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value));
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+export const isCollectionOperator = (operator) => ['in', 'nin', 'between', 'nbetween'].includes(operator);
+export const isNullOperator = (operator) => operator === 'null' || operator === 'nnull';
+export function filterOperators(field) {
+    if (!field)
+        return [];
+    if (field.type === 'number' || field.type === 'date')
+        return [...comparison];
+    if (field.type === 'boolean' || field.type === 'select' || field.type === 'multiselect')
+        return [...selection];
+    return [...text];
+}
+/** Filter[] 的顶层是隐式 AND；只有单个显式组可以成为编辑器根组，且保留包装信息。 */
+export function readFilterTree(input) {
+    let count = 0;
+    const active = new Set();
+    const issues = [];
+    function read(raw, depth, path) {
+        if (++count > FILTER_EDITOR_LIMITS.nodes || depth > FILTER_EDITOR_LIMITS.depth) {
+            issues.push({ path, code: 'limit' });
+            return;
+        }
+        if (!object(raw) || active.has(raw)) {
+            issues.push({ path, code: 'invalid-filter' });
+            return;
+        }
+        active.add(raw);
+        try {
+            const id = `node-${count}`;
+            if ('field' in raw) {
+                if (typeof raw['field'] !== 'string' || !raw['field'] || !operators.includes(raw['operator'])
+                    || Object.keys(raw).some((key) => !['field', 'operator', 'value'].includes(key))) {
+                    issues.push({ path, code: 'invalid-filter' });
+                    return;
+                }
+                const value = raw['value'];
+                if (!scalar(value) && !(Array.isArray(value) && value.length <= FILTER_EDITOR_LIMITS.values && Array.from(value).every(scalar))) {
+                    issues.push({ path, code: 'value' });
+                    return;
+                }
+                return { kind: 'rule', id, field: raw['field'], operator: raw['operator'], value: Array.isArray(value) ? [...value] : value };
+            }
+            if (!['and', 'or'].includes(String(raw['operator'])) || !Array.isArray(raw['value'])
+                || Object.keys(raw).some((key) => !['operator', 'value'].includes(key))) {
+                issues.push({ path, code: 'invalid-filter' });
+                return;
+            }
+            if (raw['value'].length > FILTER_EDITOR_LIMITS.nodes) {
+                issues.push({ path, code: 'limit' });
+                return;
+            }
+            const children = [];
+            for (const [index, child] of raw['value'].entries()) {
+                const node = read(child, depth + 1, `${path}/value/${index}`);
+                if (node)
+                    children.push(node);
+            }
+            return { kind: 'group', id, operator: raw['operator'], children };
+        }
+        finally {
+            active.delete(raw);
+        }
+    }
+    if (!Array.isArray(input))
+        return { ok: false, issues: [{ path: '', code: 'invalid-filter' }] };
+    if (input.length > FILTER_EDITOR_LIMITS.nodes)
+        return { ok: false, issues: [{ path: '', code: 'limit' }] };
+    const children = [];
+    for (const [index, raw] of input.entries()) {
+        const node = read(raw, 1, `/${index}`);
+        if (node)
+            children.push(node);
+    }
+    if (issues.length)
+        return { ok: false, issues };
+    const only = children[0];
+    return { ok: true, root: children.length === 1 && only?.kind === 'group'
+            ? { ...only, wrapped: true }
+            : { kind: 'group', id: 'root', operator: 'and', children, wrapped: false } };
+}
+export function compileFilterTree(root, fields, preserved = new Map()) {
+    const issues = [];
+    const fieldMap = new Map(fields.map((field) => [field.key, field]));
+    const active = new Set();
+    let count = 0;
+    function visit(node, depth) {
+        const issue = (code) => { issues.push({ path: node.id, code }); };
+        if (++count > FILTER_EDITOR_LIMITS.nodes || depth > FILTER_EDITOR_LIMITS.depth) {
+            issue('limit');
+            return;
+        }
+        if (active.has(node)) {
+            issue('invalid-filter');
+            return;
+        }
+        active.add(node);
+        try {
+            // Only unchanged host-owned readonly leaves and originally empty groups may bypass
+            // editor capability checks. A forged readonly flag or edited payload is not sufficient.
+            const original = preserved.get(node.id);
+            if (original && node.kind === 'rule' && node.readonly && 'field' in original
+                && node.field === original.field && node.operator === original.operator
+                && JSON.stringify(node.value) === JSON.stringify(original.value)) {
+                return { ...original, value: Array.isArray(original.value) ? [...original.value] : original.value };
+            }
+            if (original && node.kind === 'group' && !('field' in original)
+                && !node.children.length && !original.value.length && node.operator === original.operator) {
+                return { operator: node.operator, value: [] };
+            }
+            if (node.kind === 'group') {
+                if (node.operator !== 'and' && node.operator !== 'or') {
+                    issue('operator');
+                    return;
+                }
+                if (!node.children.length)
+                    issue('empty-group');
+                if (node.children.length > FILTER_EDITOR_LIMITS.nodes) {
+                    issue('limit');
+                    return;
+                }
+                const children = [];
+                for (const child of node.children) {
+                    const filter = visit(child, depth + 1);
+                    if (filter)
+                        children.push(filter);
+                }
+                return { operator: node.operator, value: children };
+            }
+            const field = fieldMap.get(node.field);
+            if (!field || field.filterable === false) {
+                issue('unknown-field');
+                return;
+            }
+            if (!filterOperators(field).includes(node.operator)) {
+                issue('operator');
+                return;
+            }
+            const validScalar = (value) => {
+                if (!scalar(value) || value === null)
+                    return false;
+                if (field.type === 'number')
+                    return typeof value === 'number';
+                if (field.type === 'boolean')
+                    return typeof value === 'boolean';
+                if (field.options?.length)
+                    return field.options.some((option) => !option.disabled && option.value === value);
+                return typeof value === 'string';
+            };
+            if (isNullOperator(node.operator)) {
+                if (node.value !== null) {
+                    issue('value');
+                    return;
+                }
+            }
+            else if (isCollectionOperator(node.operator)) {
+                if (!Array.isArray(node.value) || node.value.length === 0 || node.value.length > FILTER_EDITOR_LIMITS.values || !Array.from(node.value).every(validScalar)
+                    || ((node.operator === 'between' || node.operator === 'nbetween') && node.value.length !== 2)) {
+                    issue('value');
+                    return;
+                }
+                if ((node.operator === 'between' || node.operator === 'nbetween') && typeof node.value[0] === 'number' && typeof node.value[1] === 'number' && node.value[0] > node.value[1]) {
+                    issue('value');
+                    return;
+                }
+            }
+            else if (!validScalar(node.value)) {
+                issue('value');
+                return;
+            }
+            return { field: node.field, operator: node.operator, value: Array.isArray(node.value) ? [...node.value] : node.value };
+        }
+        finally {
+            active.delete(node);
+        }
+    }
+    if (root.children.length > FILTER_EDITOR_LIMITS.nodes)
+        return { ok: false, issues: [{ path: root.id, code: 'limit' }] };
+    if (!root.children.length && !root.wrapped)
+        return { ok: true, filters: [] };
+    // 隐式根不占公开 Filter 的深度或节点预算；显式根与读入时一致。
+    let filters = [];
+    if (root.operator === 'and' && !root.wrapped) {
+        for (const child of root.children) {
+            const filter = visit(child, 1);
+            if (filter)
+                filters.push(filter);
+        }
+    }
+    else {
+        const filter = visit(root, 1);
+        if (filter)
+            filters = [filter];
+    }
+    return issues.length ? { ok: false, issues } : { ok: true, filters };
+}
+export function parseFilterInput(raw, field, operator) {
+    if (raw.length > 1_048_576)
+        throw new Error('value');
+    if (isNullOperator(operator))
+        return null;
+    if (isCollectionOperator(operator))
+        return raw.trim() ? JSON.parse(raw) : undefined;
+    if (field?.type === 'number') {
+        if (!raw.trim())
+            return undefined;
+        if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(raw.trim()) || !Number.isFinite(Number(raw)))
+            throw new Error('value');
+        return Number(raw);
+    }
+    if (field?.type === 'boolean') {
+        if (raw === '')
+            return undefined;
+        if (raw !== 'true' && raw !== 'false')
+            throw new Error('value');
+        return raw === 'true';
+    }
+    return raw;
+}

package/dist/components/enterprise/json-schema-form.d.ts

@@ -0,0 +1,39 @@
+/** JsonSchemaForm 当前支持的标量子集。未知断言必须显式拒绝，不能假装已校验。 */
+export type JsonScalar = string | number | boolean | null;
+export type SchemaIssueCode = 'unsupported-schema' | 'invalid-schema' | 'required' | 'type' | 'enum' | 'minimum' | 'maximum' | 'multipleOf' | 'minLength' | 'maxLength' | 'additionalProperties' | 'invalid-value' | 'minItems' | 'maxItems';
+export interface SchemaFormIssue {
+    path: string;
+    code: SchemaIssueCode;
+}
+export interface SchemaFormField {
+    key: string;
+    title: string;
+    description: string;
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'enum';
+    nullable: boolean;
+    required: boolean;
+    readonly: boolean;
+    choices: JsonScalar[] | undefined;
+    hasDefault: boolean;
+    defaultValue: JsonScalar | undefined;
+    minimum: number | undefined;
+    maximum: number | undefined;
+    exclusiveMinimum: number | undefined;
+    exclusiveMaximum: number | undefined;
+    multipleOf: number | undefined;
+    minLength: number | undefined;
+    maxLength: number | undefined;
+}
+export interface SchemaFormModel {
+    fields: SchemaFormField[];
+    issues: SchemaFormIssue[];
+    additionalProperties: boolean;
+}
+export declare function readSchemaForm(schema: Record<string, unknown>): SchemaFormModel;
+/** 只为不存在的键补默认值；显式 undefined 表示用户已清空，不重新灌回默认值。 */
+export declare function schemaFormValues(model: SchemaFormModel, value: Record<string, unknown>): Record<string, unknown>;
+export declare function parseSchemaNumber(raw: string): number | undefined;
+export declare function enumIndex(choices: readonly JsonScalar[], value: unknown): string;
+export declare function enumValue(choices: readonly JsonScalar[], index: string): JsonScalar | undefined;
+export declare function validateSchemaForm(model: SchemaFormModel, value: Record<string, unknown>): SchemaFormIssue[];
+export { schemaFormSnapshot } from '../json-schema-form-state.js';

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

@@ -0,0 +1,195 @@
+const rootKeys = new Set(['$schema', '$id', '$comment', 'title', 'description', 'type', 'properties', 'required', 'additionalProperties']);
+const fieldKeys = new Set(['$id', '$comment', 'title', 'description', 'type', 'enum', 'const', 'default', 'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf', 'minLength', 'maxLength', 'readOnly', 'writeOnly', 'deprecated', 'examples']);
+const unsafeKeys = new Set(['__proto__', 'constructor', 'prototype']);
+const pointer = (key) => `/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`;
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const scalar = (value) => value === null || typeof value === 'string' || typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value));
+const same = (a, b) => a === b;
+function matches(field, value) {
+    if (value === null)
+        return field.nullable;
+    if (field.type === 'enum')
+        return scalar(value);
+    if (field.type === 'integer')
+        return typeof value === 'number' && Number.isSafeInteger(value);
+    if (field.type === 'number')
+        return typeof value === 'number' && Number.isFinite(value);
+    return typeof value === field.type;
+}
+export function readSchemaForm(schema) {
+    const model = { fields: [], issues: [], additionalProperties: true };
+    const issue = (path, code) => { model.issues.push({ path, code }); };
+    if (!record(schema)) {
+        issue('', 'invalid-schema');
+        return model;
+    }
+    for (const key of Object.keys(schema))
+        if (!rootKeys.has(key))
+            issue(pointer(key), 'unsupported-schema');
+    if (schema['type'] !== undefined && schema['type'] !== 'object')
+        issue('/type', 'unsupported-schema');
+    if (schema['additionalProperties'] !== undefined && typeof schema['additionalProperties'] !== 'boolean')
+        issue('/additionalProperties', 'unsupported-schema');
+    model.additionalProperties = schema['additionalProperties'] !== false;
+    const properties = schema['properties'] === undefined ? {} : schema['properties'];
+    if (!record(properties) || Object.keys(properties).length > 256) {
+        issue('/properties', 'invalid-schema');
+        return model;
+    }
+    const required = schema['required'] === undefined ? [] : schema['required'];
+    if (!Array.isArray(required) || required.length > 256 || required.some((key) => typeof key !== 'string' || !Object.hasOwn(properties, key)))
+        issue('/required', 'invalid-schema');
+    const requiredKeys = new Set(Array.isArray(required) ? required : []);
+    for (const [key, raw] of Object.entries(properties)) {
+        const path = pointer(key);
+        if (unsafeKeys.has(key) || !record(raw)) {
+            issue(path, 'invalid-schema');
+            continue;
+        }
+        for (const keyword of Object.keys(raw))
+            if (!fieldKeys.has(keyword))
+                issue(`${path}${pointer(keyword)}`, 'unsupported-schema');
+        let type = raw['type'];
+        let nullable = false;
+        if (Array.isArray(type)) {
+            nullable = type.includes('null');
+            const nonNull = type.filter((item) => item !== 'null');
+            if (type.length !== 2 || nonNull.length !== 1)
+                issue(path, 'unsupported-schema');
+            type = nonNull[0];
+        }
+        const hasEnum = Object.hasOwn(raw, 'enum');
+        const hasConst = Object.hasOwn(raw, 'const');
+        const rawChoices = hasEnum ? raw['enum'] : hasConst ? [raw['const']] : undefined;
+        let choices;
+        if (rawChoices !== undefined) {
+            if (!Array.isArray(rawChoices) || rawChoices.length === 0 || rawChoices.length > 1000 || !rawChoices.every(scalar))
+                issue(path, 'invalid-schema');
+            else {
+                choices = [...rawChoices];
+                if (hasConst)
+                    choices = choices.filter((item) => same(item, raw['const']));
+                if (!choices.length)
+                    issue(path, 'invalid-schema');
+            }
+        }
+        else if (hasEnum)
+            issue(path, 'invalid-schema');
+        if (type === undefined)
+            type = choices ? 'enum' : 'string';
+        else if (type === 'enum') {
+            issue(path, 'invalid-schema');
+            continue;
+        }
+        if (!['string', 'number', 'integer', 'boolean', 'enum'].includes(String(type))) {
+            issue(path, 'unsupported-schema');
+            continue;
+        }
+        if (type === 'enum')
+            nullable = choices?.includes(null) ?? false;
+        const field = {
+            key, title: String(raw['title'] ?? key), description: String(raw['description'] ?? ''),
+            type: type, nullable, required: requiredKeys.has(key), readonly: raw['readOnly'] === true,
+            choices, hasDefault: Object.hasOwn(raw, 'default'), defaultValue: scalar(raw['default']) ? raw['default'] : undefined,
+            minimum: undefined, maximum: undefined, exclusiveMinimum: undefined, exclusiveMaximum: undefined,
+            multipleOf: undefined, minLength: undefined, maxLength: undefined,
+        };
+        for (const constraint of ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf', 'minLength', 'maxLength']) {
+            const value = raw[constraint];
+            if (value === undefined)
+                continue;
+            if (typeof value !== 'number' || !Number.isFinite(value)
+                || (constraint === 'multipleOf' && value <= 0)
+                || ((constraint === 'minLength' || constraint === 'maxLength') && (!Number.isSafeInteger(value) || value < 0)))
+                issue(`${path}/${constraint}`, 'invalid-schema');
+            else
+                field[constraint] = value;
+        }
+        if (choices?.some((choice) => !matches(field, choice)))
+            issue(path, 'invalid-schema');
+        if (field.hasDefault && (!scalar(raw['default']) || !matches(field, raw['default']) || (choices && !choices.some((choice) => same(choice, raw['default'])))))
+            issue(path, 'invalid-schema');
+        model.fields.push(field);
+    }
+    return model;
+}
+/** 只为不存在的键补默认值；显式 undefined 表示用户已清空，不重新灌回默认值。 */
+export function schemaFormValues(model, value) {
+    const result = { ...value };
+    for (const field of model.fields)
+        if (!Object.hasOwn(value, field.key) && field.hasDefault)
+            result[field.key] = field.defaultValue;
+    return result;
+}
+export function parseSchemaNumber(raw) {
+    if (raw.trim() === '')
+        return undefined;
+    if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(raw.trim()))
+        throw new Error('invalid-value');
+    const value = Number(raw);
+    if (!Number.isFinite(value))
+        throw new Error('invalid-value');
+    return value;
+}
+export function enumIndex(choices, value) {
+    const index = choices.findIndex((choice) => same(choice, value));
+    return index < 0 ? '' : String(index);
+}
+export function enumValue(choices, index) {
+    if (index === '')
+        return undefined;
+    if (!/^(0|[1-9]\d*)$/.test(index))
+        throw new Error('invalid-value');
+    const value = choices[Number(index)];
+    if (value === undefined)
+        throw new Error('invalid-value');
+    return value;
+}
+export function validateSchemaForm(model, value) {
+    const issues = [...model.issues];
+    if (!record(value))
+        return [...issues, { path: '', code: 'invalid-value' }];
+    for (const field of model.fields) {
+        const path = pointer(field.key), current = Object.hasOwn(value, field.key) ? value[field.key] : undefined;
+        const issue = (code) => { issues.push({ path, code }); };
+        if (current === undefined) {
+            if (field.required)
+                issue('required');
+            continue;
+        }
+        if (!matches(field, current)) {
+            issue('type');
+            continue;
+        }
+        if (field.choices && !field.choices.some((choice) => same(choice, current)))
+            issue('enum');
+        if (typeof current === 'number') {
+            if ((field.minimum !== undefined && current < field.minimum) || (field.exclusiveMinimum !== undefined && current <= field.exclusiveMinimum))
+                issue('minimum');
+            if ((field.maximum !== undefined && current > field.maximum) || (field.exclusiveMaximum !== undefined && current >= field.exclusiveMaximum))
+                issue('maximum');
+            if (field.multipleOf !== undefined) {
+                const quotient = current / field.multipleOf;
+                if (!Number.isFinite(quotient) || Math.abs(quotient - Math.round(quotient)) > Math.min(1e-8, Number.EPSILON * Math.max(1, Math.abs(quotient)) * 4))
+                    issue('multipleOf');
+            }
+        }
+        if (typeof current === 'string') {
+            const length = Array.from(current).length;
+            if (field.minLength !== undefined && length < field.minLength)
+                issue('minLength');
+            if (field.maxLength !== undefined && length > field.maxLength)
+                issue('maxLength');
+        }
+    }
+    const keys = new Set(model.fields.map((field) => field.key));
+    for (const [key, current] of Object.entries(value)) {
+        if (unsafeKeys.has(key))
+            issues.push({ path: pointer(key), code: 'invalid-value' });
+        if (!model.additionalProperties && !keys.has(key) && current !== undefined)
+            issues.push({ path: pointer(key), code: 'additionalProperties' });
+    }
+    return issues;
+}
+// Reuse the hardened recursive form transport boundary, including accessor/symbol rejection.
+export { schemaFormSnapshot } from '../json-schema-form-state.js';

package/dist/components/enterprise/recursive-schema-form.d.ts

@@ -0,0 +1,30 @@
+import { type SchemaFormModel, type SchemaFormIssue } from './json-schema-form.js';
+type Node = {
+    kind: 'object';
+    properties: Record<string, Node>;
+    required: Set<string>;
+    additional: boolean;
+    nullable: boolean;
+} | {
+    kind: 'array';
+    item: Node;
+    min: number | undefined;
+    max: number | undefined;
+    nullable: boolean;
+} | {
+    kind: 'scalar';
+    model: SchemaFormModel;
+};
+export interface RecursiveSchemaFormModel {
+    node: Node | undefined;
+    issues: SchemaFormIssue[];
+}
+export declare const schemaFormPointer: (path: readonly string[]) => string;
+/** Compile bounded objects/arrays, delegating scalar assertions to the reviewed leaf validator.
+ * Unsupported assertions fail closed; this is deliberately not a complete JSON Schema engine.
+ * TypeBox's symbol annotations are not JSON assertion keywords and are not executed.
+ */
+export declare function readRecursiveSchemaForm(schema: unknown): RecursiveSchemaFormModel;
+/** Validate a detached JSON payload without defaults, coercion, cleaning or partial acceptance. */
+export declare function validateRecursiveSchemaForm(model: RecursiveSchemaFormModel, value: unknown): SchemaFormIssue[];
+export {};