@kubohiroya/turbowarp-extension-data-editor 0.2.2 → 0.3.1

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,7 +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 } from './rjsf-templates.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;
@@ -27,11 +29,15 @@ const Form = moduleExports(RjsfCore).default;
 const { getDefaultFormState, ADDITIONAL_PROPERTY_FLAG } = moduleExports(RjsfUtils);
 const { customizeValidator } = moduleExports(RjsfAjv);
 const defaultTemplates = moduleExports(RjsfCore).getDefaultRegistry().templates;
-const ObjectItems = numberedObjectTemplate(defaultTemplates.ObjectFieldTemplate, ADDITIONAL_PROPERTY_FLAG);
+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 {
@@ -71,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;
@@ -101,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);
@@ -115,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) {
@@ -134,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.');
@@ -147,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 } : {}),
@@ -214,11 +221,15 @@ 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()),
@@ -242,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;