@kubohiroya/turbowarp-extension-data-editor 0.2.1 → 0.3.0

package/dist/rjsf-templates.js

@@ -0,0 +1,199 @@
+import * as React from 'react';
+import { ObjectLayout, useCommonLayout } from './layout-view.js';
+import { resolveEditorLayout } from './layout.js';
+import { FormHelp, propertyLabel } from './form-presentation.js';
+const ItemNumber = React.createContext(1);
+const PropertyKey = React.createContext(undefined);
+function errorCount(value) {
+    if (!value || typeof value !== 'object')
+        return 0;
+    if (Array.isArray(value))
+        return value.length;
+    return Object.values(value).reduce((count, child) => count + errorCount(child), 0);
+}
+/** Reuse the v5 object template's title, description and add-property controls. */
+export function layoutObjectTemplate(DefaultTemplate) {
+    return function LayoutObject(props) {
+        var _a, _b;
+        const enabled = useCommonLayout();
+        const title = enabled && !props.schema.title && !((_a = props.uiSchema) === null || _a === void 0 ? void 0 : _a['ui:title']) ? propertyLabel(props.title) : props.title;
+        const view = { ...props, title };
+        const knownFields = [...new Set([...Object.keys((_b = props.schema.properties) !== null && _b !== void 0 ? _b : {}), ...props.properties.map(property => property.name)])];
+        const resolution = enabled ? resolveEditorLayout(props.uiSchema, knownFields) : { kind: 'absent' };
+        if (resolution.kind === 'absent')
+            return React.createElement(DefaultTemplate, { ...view });
+        if (resolution.kind === 'invalid')
+            return React.createElement(React.Fragment, null,
+                React.createElement("p", { role: "status", "data-layout-diagnostic": "" },
+                    "\u30EC\u30A4\u30A2\u30A6\u30C8\u3092\u9069\u7528\u3067\u304D\u307E\u305B\u3093: ",
+                    resolution.diagnostic),
+                React.createElement(DefaultTemplate, { ...props }));
+        const content = React.createElement(ObjectLayout, { key: "__editor_layout__", ui: props.uiSchema, knownFields: knownFields, fallback: null, fields: props.properties.map(property => {
+                var _a;
+                return ({
+                    name: property.name, content: property.content, errors: errorCount((_a = props.errorSchema) === null || _a === void 0 ? void 0 : _a[property.name])
+                });
+            }) });
+        return React.createElement(DefaultTemplate, { ...view, properties: [{ name: '__editor_layout__', content, hidden: false, disabled: !!props.disabled, readonly: !!props.readonly }] });
+    };
+}
+export function compactDescriptionTemplate(DefaultTemplate) {
+    return function CompactDescription(props) {
+        const enabled = useCommonLayout();
+        return enabled && typeof props.description === 'string' ? React.createElement(FormHelp, { id: props.id, description: props.description }) : React.createElement(DefaultTemplate, { ...props });
+    };
+}
+export function compactArrayTitleTemplate(DefaultTemplate) {
+    return function CompactArrayTitle(props) {
+        var _a;
+        const enabled = useCommonLayout();
+        if (!enabled || !props.title || props.schema.title || ((_a = props.uiSchema) === null || _a === void 0 ? void 0 : _a['ui:title']))
+            return React.createElement(DefaultTemplate, { ...props });
+        return React.createElement(DefaultTemplate, { ...props, title: propertyLabel(props.title) });
+    };
+}
+export function compactArrayTemplate(DefaultTemplate) {
+    return function CompactArray(props) {
+        const enabled = useCommonLayout();
+        return React.createElement(React.Fragment, null,
+            React.createElement(DefaultTemplate, { ...props }),
+            enabled && props.items.length === 0 && React.createElement("p", { className: "editor-form-hint" }, "\u9805\u76EE\u306A\u3057"));
+    };
+}
+/** Boolean widgets own their visible label instead of using the surrounding FieldTemplate. */
+export function compactCheckboxWidget(DefaultWidget) {
+    return function CompactCheckbox(props) {
+        var _a;
+        const enabled = useCommonLayout();
+        const label = enabled && !props.schema.title && !((_a = props.uiSchema) === null || _a === void 0 ? void 0 : _a['ui:title']) && !props.options.title ? propertyLabel(props.label) : props.label;
+        return React.createElement(DefaultWidget, { ...props, label: label });
+    };
+}
+/** Keep the property key out of the value's visible label. */
+export function valueFieldTemplate(DefaultTemplate, flag) {
+    return function ValueField(props) {
+        var _a;
+        const enabled = useCommonLayout();
+        if (!(flag in props.schema))
+            return React.createElement(DefaultTemplate, { ...props, label: enabled && !props.schema.title && !((_a = props.uiSchema) === null || _a === void 0 ? void 0 : _a['ui:title']) ? propertyLabel(props.label) : props.label });
+        return React.createElement(PropertyKey.Provider, { value: props.label },
+            React.createElement(DefaultTemplate, { ...props, label: "\u5024" }));
+    };
+}
+/** Keep RJSF's object layout while numbering each editable additional property. */
+export function numberedObjectTemplate(DefaultTemplate, flag) {
+    return function ObjectItems(props) {
+        let number = 0;
+        const properties = props.properties.map(property => {
+            var _a;
+            const schema = (_a = props.schema.properties) === null || _a === void 0 ? void 0 : _a[property.name];
+            if (!schema || typeof schema !== 'object' || !(flag in schema) || property.hidden)
+                return property;
+            return { ...property, content: React.createElement(ItemNumber.Provider, { key: property.name, value: ++number }, property.content) };
+        });
+        return React.createElement(DefaultTemplate, { ...props, properties: properties });
+    };
+}
+export function additionalItemTemplate(flag) {
+    return function AdditionalItem(props) {
+        const number = React.useContext(ItemNumber);
+        const propertyKey = React.useContext(PropertyKey);
+        const { id, classNames, style, children, schema, label, disabled, readonly, onKeyChange, onDropPropertyClick } = props;
+        if (!(flag in schema))
+            return React.createElement("div", { className: classNames, style: style }, children);
+        const key = propertyKey !== null && propertyKey !== void 0 ? propertyKey : label;
+        return React.createElement("div", { className: classNames, style: style, "data-block-editor-item": "" },
+            React.createElement("div", { "data-block-editor-item-heading": "" },
+                React.createElement("span", null,
+                    "\u30FB\u9805\u76EE",
+                    number),
+                React.createElement(ItemMenu, { disabled: disabled || readonly, onClick: onDropPropertyClick(key) })),
+            React.createElement("div", { "data-block-editor-pair-row": "" },
+                React.createElement("label", { htmlFor: `${id}-key` }, "\u30AD\u30FC"),
+                React.createElement("input", { id: `${id}-key`, type: "text", defaultValue: key, disabled: disabled, readOnly: readonly, onBlur: event => onKeyChange(event.target.value) })),
+            React.createElement("div", { "data-block-editor-pair-row": "" }, children));
+    };
+}
+/** Deletion is available only after explicitly opening the item's menu. */
+export function ItemMenu({ disabled, onClick }) {
+    const [open, setOpen] = React.useState(false);
+    const container = React.useRef(null);
+    const trigger = React.useRef(null);
+    const item = React.useRef(null);
+    React.useEffect(() => {
+        var _a;
+        if (!open)
+            return;
+        (_a = item.current) === null || _a === void 0 ? void 0 : _a.focus();
+        const closeOutside = (event) => {
+            var _a;
+            if (!((_a = container.current) === null || _a === void 0 ? void 0 : _a.contains(event.target)))
+                setOpen(false);
+        };
+        // RJSF and its host modal have separate React roots. Stop Escape before either root delegates it.
+        const keepEscapeInMenu = (event) => {
+            var _a;
+            if (event.key !== 'Escape' || event.isComposing || event.keyCode === 229)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            setOpen(false);
+            (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.focus();
+        };
+        const menu = container.current;
+        menu === null || menu === void 0 ? void 0 : menu.addEventListener('keydown', keepEscapeInMenu);
+        document.addEventListener('mousedown', closeOutside);
+        return () => {
+            menu === null || menu === void 0 ? void 0 : menu.removeEventListener('keydown', keepEscapeInMenu);
+            document.removeEventListener('mousedown', closeOutside);
+        };
+    }, [open]);
+    React.useEffect(() => { if (disabled)
+        setOpen(false); }, [disabled]);
+    return React.createElement("div", { "data-block-editor-item-menu": "", ref: container, onBlur: event => {
+            if (!event.currentTarget.contains(event.relatedTarget))
+                setOpen(false);
+        }, onKeyDown: event => {
+            var _a, _b;
+            if (event.key === 'Escape' && open && !event.nativeEvent.isComposing && event.keyCode !== 229) {
+                event.preventDefault();
+                event.stopPropagation();
+                setOpen(false);
+                (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.focus();
+            }
+            else if (['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) {
+                event.preventDefault();
+                if (open)
+                    (_b = item.current) === null || _b === void 0 ? void 0 : _b.focus();
+                else if (!disabled)
+                    setOpen(true);
+            }
+        } },
+        React.createElement("button", { "aria-label": "\u9805\u76EE\u306E\u30E1\u30CB\u30E5\u30FC", "aria-haspopup": "menu", "aria-expanded": open && !disabled, disabled: disabled, ref: trigger, type: "button", onClick: () => setOpen(!open) }, "\u2026"),
+        open && !disabled ? React.createElement("div", { role: "menu", "aria-label": "\u9805\u76EE\u306E\u64CD\u4F5C" },
+            React.createElement("button", { ref: item, role: "menuitem", type: "button", onClick: event => {
+                    var _a;
+                    setOpen(false);
+                    (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.focus();
+                    onClick === null || onClick === void 0 ? void 0 : onClick(event);
+                } }, "\uD83D\uDDD1\uFE0F\u3053\u306E\u9805\u76EE\u3092\u524A\u9664")) : null);
+}
+export function AddItemButton({ disabled, onClick, className }) {
+    return React.createElement("button", { className: className, "data-block-editor-add-item": "", disabled: disabled, type: "button", onClick: onClick }, "\u2795\u9805\u76EE\u3092\u8FFD\u52A0");
+}
+export function ArrayItem(props) {
+    const { children, className, disabled, readonly, index, hasMoveUp, hasMoveDown, hasCopy, hasRemove, onReorderClick, onCopyIndexClick, onDropIndexClick } = props;
+    const locked = disabled || readonly;
+    return React.createElement("div", { className: className, "data-block-editor-item": "" },
+        React.createElement("div", { "data-block-editor-item-heading": "" },
+            React.createElement("span", null,
+                "\u30FB\u9805\u76EE",
+                index + 1),
+            React.createElement("div", { "data-block-editor-item-actions": "" },
+                hasMoveUp || hasMoveDown ? React.createElement(React.Fragment, null,
+                    React.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0A\u3078\u79FB\u52D5", disabled: locked || !hasMoveUp, type: "button", onClick: onReorderClick(index, index - 1) }, "\u2191"),
+                    React.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0B\u3078\u79FB\u52D5", disabled: locked || !hasMoveDown, type: "button", onClick: onReorderClick(index, index + 1) }, "\u2193")) : null,
+                hasCopy ? React.createElement("button", { disabled: locked, type: "button", onClick: onCopyIndexClick(index) }, "\u9805\u76EE\u3092\u8907\u88FD") : null,
+                hasRemove ? React.createElement(ItemMenu, { disabled: locked, onClick: onDropIndexClick(index) }) : null)),
+        children);
+}

package/dist/rjsf.d.ts

@@ -1,3 +1,6 @@
+import type { EditorFeatureFlags } from './config/feature-flags.js';
+export type { EditorFeatureFlags } from './config/feature-flags.js';
+export type { EditorLayout, EditorLayoutItem } from './layout.js';
 import type { FixedInputMessageSource } from './fixed-input-view.js';
 export type { FixedInputViewMessages, FixedInputMessageSource } from './fixed-input-view.js';
 import type { FixedInputEditorOptions } from './fixed-input-editor.js';
@@ -9,11 +12,11 @@ export { createSourceEditor } from './source-editor.js';
 export type * from './source-types.js';
 export type * from './prepared-types.js';
 import type { RJSFSchema } from '@rjsf/utils';
-import type { SchemaBundle, SchemaValidationContext, SyncOwnerValidator } from './schema-types.js';
+import type { SchemaBundle, SchemaJsonObject, SchemaValidationContext, SyncOwnerValidator } from './schema-types.js';
 import type { SourceFormat } from './codec.js';
 import { EditorRegistry } from './registry.js';
 import { EDITOR_API_VERSION } from './types.js';
-import type { BlockSnapshot, EditorDefinition, JsonObject, JsonValue, ValidationIssue } from './types.js';
+import type { BlockSnapshot, EditorDefinition, JsonValue, ValidationIssue } from './types.js';
 export interface SchemaEditorOptions {
     readonly apiVersion: typeof EDITOR_API_VERSION;
     readonly extensionId: string;
@@ -24,7 +27,7 @@ export interface SchemaEditorOptions {
     /** Defaults to JSON for compatibility with existing registrations. */
     readonly format?: SourceFormat;
     readonly schema: RJSFSchema;
-    readonly uiSchema?: JsonObject;
+    readonly uiSchema?: SchemaJsonObject;
     /** Optional business validation, always run after schema validation when saving. */
     validateData?(data: JsonValue, snapshot: BlockSnapshot): readonly ValidationIssue[] | Promise<readonly ValidationIssue[]>;
 }
@@ -34,7 +37,7 @@ export interface SchemaBundleEditorOptions<C = null> extends Omit<SchemaEditorOp
     readonly validationContext: () => SchemaValidationContext<C>;
     readonly ownerValidate?: SyncOwnerValidator<C>;
 }
-export declare function createSchemaBundleEditor<C>(options: SchemaBundleEditorOptions<C>): EditorDefinition;
+export declare function createSchemaBundleEditor<C>(options: SchemaBundleEditorOptions<C>, features?: EditorFeatureFlags): EditorDefinition;
 export interface BlockEditorRegistrationAPI {
     readonly apiVersion: typeof EDITOR_API_VERSION;
     register(definition: EditorDefinition | SchemaEditorOptions): () => void;
@@ -60,21 +63,21 @@ export interface BlockEditorService {
     subscribe(listener: () => void): () => void;
 }
 /** A host owns the service's lifetime; this module never stores VM or workspace instances. */
-export declare function createBlockEditorService(options: {
+export declare function createBlockEditorService(options: EditorFeatureFlags & {
     readonly fixedInputs: true;
     readonly fixedInputMessages?: FixedInputMessageSource;
 }): BlockEditorService & {
     readonly api: FixedBlockEditorRegistrationAPI;
 };
-export declare function createBlockEditorService(options?: {
+export declare function createBlockEditorService(options?: EditorFeatureFlags & {
     readonly fixedInputs?: false;
     readonly fixedInputMessages?: FixedInputMessageSource;
 }): BlockEditorService & {
     readonly api: SourceBlockEditorRegistrationAPI;
 };
-export declare function createBlockEditorService(options: {
+export declare function createBlockEditorService(options: EditorFeatureFlags & {
     readonly fixedInputs?: boolean;
     readonly fixedInputMessages?: FixedInputMessageSource;
 }): BlockEditorService;
 /** Build an editor with JSON/YAML serialization, schema validation and the standard RJSF body. */
-export declare function createSchemaEditor(options: SchemaEditorOptions): EditorDefinition;
+export declare function createSchemaEditor(options: SchemaEditorOptions, features?: EditorFeatureFlags): EditorDefinition;

package/dist/rjsf.js

@@ -1,4 +1,6 @@
 import * as React from 'react';
+import { captureFeatureFlags } from './config/feature-flags.js';
+import { LayoutHost } from './layout-view.js';
 import { createSourceEditor } from './source-editor.js';
 import { createFixedInputEditor } from './fixed-input-editor.js';
 import { captureFixedInputMessages, resolveFixedInputMessages, mountFixedInputView } from './fixed-input-view.js';
@@ -16,6 +18,7 @@ import { cloneJson } from './data.js';
 import { decodeSource, encodeSource, sameData } from './codec.js';
 import { EditorRegistry } from './registry.js';
 import { EDITOR_API_VERSION } from './types.js';
+import { AddItemButton, ArrayItem, ItemMenu, additionalItemTemplate, numberedObjectTemplate, valueFieldTemplate, layoutObjectTemplate, compactDescriptionTemplate, compactArrayTitleTemplate, compactArrayTemplate, compactCheckboxWidget } from './rjsf-templates.js';
 // RJSF v5 exposes CommonJS to Node and ESM to browser bundlers.
 function moduleExports(namespace) {
     const fallback = namespace.default;
@@ -23,10 +26,18 @@ function moduleExports(namespace) {
         ? fallback : namespace;
 }
 const Form = moduleExports(RjsfCore).default;
-const { getDefaultFormState } = moduleExports(RjsfUtils);
+const { getDefaultFormState, ADDITIONAL_PROPERTY_FLAG } = moduleExports(RjsfUtils);
 const { customizeValidator } = moduleExports(RjsfAjv);
+const defaultTemplates = moduleExports(RjsfCore).getDefaultRegistry().templates;
+const ObjectItems = numberedObjectTemplate(layoutObjectTemplate(defaultTemplates.ObjectFieldTemplate), ADDITIONAL_PROPERTY_FLAG);
+const AdditionalItem = additionalItemTemplate(ADDITIONAL_PROPERTY_FLAG);
+const ValueField = valueFieldTemplate(defaultTemplates.FieldTemplate, ADDITIONAL_PROPERTY_FLAG);
+const Description = compactDescriptionTemplate(defaultTemplates.DescriptionFieldTemplate);
+const ArrayTitle = compactArrayTitleTemplate(defaultTemplates.ArrayFieldTitleTemplate);
+const ArrayBody = compactArrayTemplate(defaultTemplates.ArrayFieldTemplate);
+const Checkbox = compactCheckboxWidget(moduleExports(RjsfCore).getDefaultRegistry().widgets.CheckboxWidget);
 let nextViewId = 0;
-export function createSchemaBundleEditor(options) {
+export function createSchemaBundleEditor(options, features = {}) {
     const { schemaBundle, validationContext: provider, ownerValidate, apiVersion, extensionId, editorId, opcodes, argument, format, uiSchema, validateData } = options;
     let bundle;
     try {
@@ -66,9 +77,10 @@ export function createSchemaBundleEditor(options) {
     };
     return createSchemaEditorImpl({ apiVersion, extensionId, editorId, opcodes, argument, schema,
         ...(format === undefined ? {} : { format }), ...(uiSchema === undefined ? {} : { uiSchema }),
-        ...(validateData === undefined ? {} : { validateData }) }, { issuesFor, dialect: result.validator.dialect });
+        ...(validateData === undefined ? {} : { validateData }) }, { issuesFor, dialect: result.validator.dialect }, captureFeatureFlags(features));
 }
 export function createBlockEditorService(options) {
+    const features = captureFeatureFlags(options);
     if ((options === null || options === void 0 ? void 0 : options.fixedInputs) !== undefined && typeof options.fixedInputs !== 'boolean')
         throw new TypeError('Invalid fixed input capability option.');
     const messageSource = options === null || options === void 0 ? void 0 : options.fixedInputMessages;
@@ -96,7 +108,7 @@ export function createBlockEditorService(options) {
         register: (definition) => {
             const custom = definition;
             const editor = !custom.mount && Object.hasOwn(definition, 'schema')
-                ? createSchemaEditor(definition) : custom;
+                ? createSchemaEditor(definition, features) : custom;
             if (typeof editor.mount !== 'function')
                 throw new TypeError('A block editor must provide mount().');
             const remove = registry.register(editor);
@@ -110,10 +122,10 @@ export function createBlockEditorService(options) {
                 notify();
             };
         },
-        registerSchema: (definition) => api.register(createSchemaEditor(definition)),
-        registerSchemaBundle: (definition) => api.register(createSchemaBundleEditor(definition)),
+        registerSchema: (definition) => api.register(createSchemaEditor(definition, features)),
+        registerSchemaBundle: (definition) => api.register(createSchemaBundleEditor(definition, features)),
         registerSourceEditor: (definition) => {
-            const remove = registry.registerPrepared(createSourceEditor(definition));
+            const remove = registry.registerPrepared(createSourceEditor(definition, features));
             notify();
             let active = true;
             return () => { if (active) {
@@ -129,10 +141,10 @@ export function createBlockEditorService(options) {
         } };
 }
 /** Build an editor with JSON/YAML serialization, schema validation and the standard RJSF body. */
-export function createSchemaEditor(options) {
-    return createSchemaEditorImpl(options);
+export function createSchemaEditor(options, features = {}) {
+    return createSchemaEditorImpl(options, undefined, captureFeatureFlags(features));
 }
-function createSchemaEditorImpl(options, bundle) {
+function createSchemaEditorImpl(options, bundle, features = captureFeatureFlags()) {
     var _a, _b;
     if (options.apiVersion !== EDITOR_API_VERSION || typeof options.argument !== 'string' || !options.argument) {
         throw new TypeError('A supported API version and JSON argument name are required.');
@@ -142,7 +154,7 @@ function createSchemaEditorImpl(options, bundle) {
     if (format !== 'json' && format !== 'yaml')
         throw new TypeError('Unsupported source format.');
     const schema = cloneJson(options.schema);
-    const uiSchema = options.uiSchema ? cloneJson(options.uiSchema) : {};
+    const uiSchema = options.uiSchema ? snapshotJson(options.uiSchema) : {};
     const validateData = options.validateData;
     const validator = customizeValidator({
         ...((bundle === null || bundle === void 0 ? void 0 : bundle.dialect) === '2020-12' ? { AjvClass: Ajv2020 } : {}),
@@ -209,6 +221,17 @@ function createSchemaEditorImpl(options, bundle) {
                 const state = context.getState();
                 const props = {
                     schema, uiSchema, validator, idPrefix,
+                    widgets: { CheckboxWidget: Checkbox },
+                    templates: {
+                        ArrayFieldItemTemplate: ArrayItem,
+                        ArrayFieldTitleTemplate: ArrayTitle,
+                        ArrayFieldTemplate: ArrayBody,
+                        ObjectFieldTemplate: ObjectItems,
+                        WrapIfAdditionalTemplate: AdditionalItem,
+                        FieldTemplate: ValueField,
+                        DescriptionFieldTemplate: Description,
+                        ButtonTemplates: { AddButton: AddItemButton, RemoveButton: ItemMenu }
+                    },
                     formData: dataFor(context.getDraft()),
                     // Defaults belong to read(), not subsequent renders or remounts.
                     experimental_defaultFormStateBehavior: {
@@ -230,7 +253,7 @@ function createSchemaEditorImpl(options, bundle) {
                     }
                 };
                 // Suppress RJSF's own submit control; the host's shared footer owns saving.
-                ReactDOM.render(React.createElement(Form, props, React.createElement('span', { hidden: true })), container);
+                ReactDOM.render(React.createElement(LayoutHost, { enabled: features.commonLayout, context, children: React.createElement(Form, props, React.createElement('span', { hidden: true })) }), container);
             };
             const schedule = () => {
                 if (scheduled || !active)

package/dist/schema-presentation.d.ts

@@ -0,0 +1,10 @@
+type SchemaNode = Record<string, unknown>;
+export declare const schemaRecord: (value: unknown) => value is SchemaNode;
+export declare const jsonTypes: readonly ["object", "array", "string", "number", "boolean", "null"];
+/** Only schema constraints prove a type; a currently matching union branch does not. */
+export declare function presentationTypes(schema: unknown, reference?: (ref: string) => unknown, seen?: Set<unknown>): ReadonlySet<string>;
+/** Initial values are produced only after an explicit add/type-change action, never on mount. */
+export declare function presentationInitial(schema: unknown): unknown;
+/** A deliberately small tri-state evaluator for presentation-only if/then/else hints. */
+export declare function presentationCondition(schema: unknown, data: unknown, reference: (ref: string) => unknown, seen?: Set<unknown>): boolean | undefined;
+export {};

package/dist/schema-presentation.js

@@ -0,0 +1,109 @@
+export const schemaRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+export const jsonTypes = ['object', 'array', 'string', 'number', 'boolean', 'null'];
+const valueType = (value) => value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value;
+/** Only schema constraints prove a type; a currently matching union branch does not. */
+export function presentationTypes(schema, reference = () => undefined, seen = new Set()) {
+    if (schema === false)
+        return new Set();
+    if (!schemaRecord(schema) || seen.has(schema))
+        return new Set(jsonTypes);
+    const visited = new Set(seen);
+    visited.add(schema);
+    let types = new Set(jsonTypes);
+    const intersect = (other) => { types = new Set([...types].filter(type => other.has(type))); };
+    const infer = (child) => presentationTypes(child, reference, visited);
+    if (typeof schema.$ref === 'string')
+        intersect(infer(reference(schema.$ref)));
+    if (schema.type !== undefined) {
+        const declared = Array.isArray(schema.type) ? schema.type : [schema.type];
+        intersect(new Set(declared.map(type => type === 'integer' ? 'number' : type)));
+    }
+    if (Object.hasOwn(schema, 'const'))
+        intersect(new Set([valueType(schema.const)]));
+    if (Array.isArray(schema.enum))
+        intersect(new Set(schema.enum.map(valueType)));
+    if (Array.isArray(schema.allOf))
+        schema.allOf.forEach(child => intersect(infer(child)));
+    for (const keyword of ['anyOf', 'oneOf']) {
+        const children = schema[keyword];
+        if (Array.isArray(children))
+            intersect(new Set(children.flatMap(child => [...infer(child)])));
+    }
+    return types;
+}
+/** Initial values are produced only after an explicit add/type-change action, never on mount. */
+export function presentationInitial(schema) {
+    if (schemaRecord(schema)) {
+        if (Object.hasOwn(schema, 'const'))
+            return schema.const;
+        if (Array.isArray(schema.enum) && schema.enum.length)
+            return schema.enum[0];
+    }
+    const types = presentationTypes(schema);
+    if (types.size !== 1)
+        return null;
+    switch ([...types][0]) {
+        case 'object': return {};
+        case 'array': return [];
+        case 'string': return '';
+        case 'number': return 0;
+        case 'boolean': return false;
+        default: return null;
+    }
+}
+/** A deliberately small tri-state evaluator for presentation-only if/then/else hints. */
+export function presentationCondition(schema, data, reference, seen = new Set()) {
+    if (typeof schema === 'boolean')
+        return schema;
+    if (!schemaRecord(schema) || seen.has(schema))
+        return undefined;
+    const supported = ['type', 'const', 'enum', 'required', 'properties', 'allOf', 'anyOf', 'oneOf', 'not', '$ref', '$id', '$schema', 'title', 'description', '$comment'];
+    if (Object.keys(schema).some(key => !supported.includes(key)))
+        return undefined;
+    const visited = new Set(seen);
+    visited.add(schema);
+    const test = (child, value = data) => presentationCondition(child, value, reference, visited);
+    const equal = (a, b) => {
+        if (a === b)
+            return true;
+        if (Array.isArray(a) && Array.isArray(b))
+            return a.length === b.length && a.every((child, index) => equal(child, b[index]));
+        return schemaRecord(a) && schemaRecord(b) && Object.keys(a).length === Object.keys(b).length && Object.keys(a).every(key => Object.hasOwn(b, key) && equal(a[key], b[key]));
+    };
+    const results = [];
+    if (typeof schema.$ref === 'string')
+        results.push(test(reference(schema.$ref)));
+    if (schema.type !== undefined) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        results.push(types.some(type => type === 'integer' ? typeof data === 'number' && Number.isInteger(data) : type === valueType(data)));
+    }
+    if (Object.hasOwn(schema, 'const'))
+        results.push(equal(data, schema.const));
+    if (Array.isArray(schema.enum))
+        results.push(schema.enum.some(item => equal(data, item)));
+    if (schemaRecord(data)) {
+        if (Array.isArray(schema.required))
+            results.push(schema.required.every(key => typeof key === 'string' && Object.hasOwn(data, key)));
+        if (schemaRecord(schema.properties))
+            for (const [key, child] of Object.entries(schema.properties))
+                if (Object.hasOwn(data, key))
+                    results.push(test(child, data[key]));
+    }
+    if (Array.isArray(schema.allOf))
+        results.push(...schema.allOf.map(child => test(child)));
+    for (const keyword of ['anyOf', 'oneOf']) {
+        const children = schema[keyword];
+        if (!Array.isArray(children))
+            continue;
+        const states = children.map(child => test(child));
+        if (keyword === 'anyOf')
+            results.push(states.includes(true) ? true : states.includes(undefined) ? undefined : false);
+        else
+            results.push(states.includes(undefined) ? undefined : states.filter(Boolean).length === 1);
+    }
+    if (Object.hasOwn(schema, 'not')) {
+        const result = test(schema.not);
+        results.push(result === undefined ? undefined : !result);
+    }
+    return results.includes(false) ? false : results.includes(undefined) ? undefined : true;
+}

package/dist/source-editor.d.ts

@@ -1,3 +1,4 @@
+import type { EditorFeatureFlags } from './config/feature-flags.js';
 import type { CompiledSchema } from './schema-types.js';
 import type { PreparedEditorDefinition } from './prepared-types.js';
 import type { SourceBinding, SourceDocument, SourceEditorOptions, SourceVariant } from './source-types.js';
@@ -10,4 +11,4 @@ export declare function createSourceCandidate(format: 'json' | 'yaml', data: Jso
 export declare function patchDecodedSource(document: SourceDocument, data: JsonValue, decode?: (source: string) => SourceDocument): string;
 export declare function readSourceDocument<C>(binding: SourceBinding<C>, source: string): SourceDocument;
 /** An additive path: legacy validate/createPatch deliberately refuse prepared definitions. */
-export declare function createSourceEditor<C = null>(options: SourceEditorOptions<C>): PreparedEditorDefinition;
+export declare function createSourceEditor<C = null>(options: SourceEditorOptions<C>, featureOptions?: EditorFeatureFlags): PreparedEditorDefinition;

package/dist/source-editor.js

@@ -1,3 +1,4 @@
+import { captureFeatureFlags } from './config/feature-flags.js';
 import { compileSchemaBundle } from './schema-engine.js';
 import { snapshotJson, isJsonRecord } from './schema-json.js';
 import { stringify } from 'yaml';
@@ -55,8 +56,9 @@ function entryFor(draft, argument) {
     return entry;
 }
 /** An additive path: legacy validate/createPatch deliberately refuse prepared definitions. */
-export function createSourceEditor(options) {
+export function createSourceEditor(options, featureOptions = {}) {
     var _a;
+    const features = captureFeatureFlags(featureOptions);
     const { apiVersion, extensionId, editorId, validationContext: provider } = options;
     if (apiVersion !== 1 || typeof provider !== 'function' || !Array.isArray(options.bindings) || !options.bindings.length) {
         throw new TypeError('Invalid source editor options.');
@@ -143,7 +145,12 @@ export function createSourceEditor(options) {
                 try {
                     const entry = entryFor(draft, binding.argument);
                     if (entry.invalidForm === true) {
-                        issues.push(issue('form-value-invalid', path));
+                        if (features.commonLayout && isJsonRecord(entry.invalidNumbers) && Object.keys(entry.invalidNumbers).length > 0) {
+                            for (const pointer of Object.keys(entry.invalidNumbers))
+                                issues.push(issue('form-value-invalid', path + pointer));
+                        }
+                        else
+                            issues.push(issue('form-value-invalid', path));
                         continue;
                     }
                     const slot = snapshot.arguments[binding.argument];
@@ -198,7 +205,14 @@ export function createSourceEditor(options) {
                     if (validation.result.kind !== 'valid') {
                         if (!['invalid', 'execution-error', 'schema-error'].includes(validation.result.kind))
                             throw new TypeError();
-                        issues.push(issue('owner-input-invalid', path));
+                        if (features.commonLayout && validation.result.diagnostics.length) {
+                            for (const diagnostic of validation.result.diagnostics) {
+                                const pointer = typeof diagnostic.dataPath === 'string' && diagnostic.dataPath.startsWith('/') ? diagnostic.dataPath : '';
+                                issues.push(issue('owner-input-invalid', path + pointer));
+                            }
+                        }
+                        else
+                            issues.push(issue('owner-input-invalid', path));
                         continue;
                     }
                     if (validation.result.diagnostics.length)
@@ -213,7 +227,11 @@ export function createSourceEditor(options) {
                     if (validator) {
                         const result = validator.validate(document.data, { consumerId: context.consumerId });
                         if (result.kind !== 'valid') {
-                            issues.push(issue('schema-data-invalid', path));
+                            if (features.commonLayout)
+                                for (const diagnostic of result.diagnostics)
+                                    issues.push(issue('schema-data-invalid', path + ('dataPath' in diagnostic ? diagnostic.dataPath : '')));
+                            else
+                                issues.push(issue('schema-data-invalid', path));
                             continue;
                         }
                     }
@@ -230,6 +248,6 @@ export function createSourceEditor(options) {
             }
             return issues.length ? { kind: 'invalid', issues } : { kind: 'ready', changes };
         },
-        mount: (container, context) => mountSourceView(container, context, bindings)
+        mount: (container, context) => mountSourceView(container, context, bindings, features.commonLayout)
     });
 }

package/dist/source-view.d.ts

@@ -1,3 +1,3 @@
 import type { CapturedBinding } from './source-editor.js';
 import type { EditorViewContext } from './types.js';
-export declare function mountSourceView<C>(container: HTMLElement, context: EditorViewContext, bindings: readonly CapturedBinding<C>[]): () => void;
+export declare function mountSourceView<C>(container: HTMLElement, context: EditorViewContext, bindings: readonly CapturedBinding<C>[], commonLayout?: boolean): () => void;