@kubohiroya/turbowarp-extension-data-editor 0.1.0 → 0.2.0

package/dist/schema-view.d.ts

@@ -0,0 +1,7 @@
+import type { SchemaBundle } from './schema-types.js';
+import type { RJSFSchema, ErrorSchema } from '@rjsf/utils';
+import type { ValidationIssue } from './types.js';
+/** RJSF v5 only resolves fragment pointers; flatten a private, already checked resource graph. */
+export declare function schemaView(input: SchemaBundle): RJSFSchema;
+/** Keep literal property names, including dots and pointer escapes, intact. */
+export declare function fieldErrors(issues: readonly ValidationIssue[]): ErrorSchema;

package/dist/schema-view.js

@@ -0,0 +1,102 @@
+import { Ajv } from 'ajv';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import formats from 'ajv-formats';
+import uri from 'fast-uri';
+import { prepare } from './schema-engine.js';
+import { snapshotJson } from './schema-json.js';
+/** RJSF v5 only resolves fragment pointers; flatten a private, already checked resource graph. */
+export function schemaView(input) {
+    const bundle = snapshotJson(input);
+    const ajv = bundle.dialect === 'draft-07' ? new Ajv({ strict: false }) : new Ajv2020({ strict: false });
+    formats.default(ajv);
+    const prepared = prepare(bundle, ajv);
+    const pointerFor = (reference, base) => {
+        const absolute = uri.normalize(uri.resolve(base, reference)).replace(/#$/, '');
+        let location = prepared.registry.get(absolute);
+        if (location === undefined) {
+            const hash = absolute.indexOf('#');
+            const resource = prepared.registry.get(hash < 0 ? absolute : absolute.slice(0, hash));
+            const fragment = hash < 0 ? '' : decodeURIComponent(absolute.slice(hash + 1));
+            if (resource === undefined || (fragment !== '' && !fragment.startsWith('/')))
+                throw new TypeError('Unsupported form reference.');
+            location = resource + fragment;
+        }
+        const slash = location.indexOf('/');
+        const index = slash < 0 ? location : location.slice(0, slash);
+        return `#${encodeURIComponent(`/definitions/__resource${index}${slash < 0 ? '' : location.slice(slash)}`).replace(/%2F/g, '/')}`;
+    };
+    for (const { node, base } of prepared.nodes) {
+        // These constructs cannot be represented faithfully by this RJSF version.
+        if ('$dynamicRef' in node || '$recursiveRef' in node || 'prefixItems' in node)
+            throw new TypeError('Unsupported form schema keyword.');
+        if (typeof node.$ref === 'string')
+            node.$ref = pointerFor(node.$ref, base);
+        // Every reference is now absolute within the presentation wrapper; canonical documents are untouched.
+        delete node.$id;
+        delete node.$anchor;
+        delete node.$dynamicAnchor;
+    }
+    if (typeof bundle.root.document === 'boolean')
+        throw new TypeError('A form requires an object schema.');
+    const view = { $schema: bundle.dialect === 'draft-07' ? 'http://json-schema.org/draft-07/schema#' : 'https://json-schema.org/draft/2020-12/schema',
+        definitions: Object.fromEntries(prepared.resources.map((resource, index) => [`__resource${index}`, resource.document])),
+        $ref: '#/definitions/__resource0' };
+    assertFiniteObjectRendering(view, prepared.nodes.map(({ node }) => node));
+    return view;
+}
+// RJSF eagerly expands object defaults even for absent optional properties. Array items
+// are expanded only for actual elements, so recursion through arrays remains supported.
+function assertFiniteObjectRendering(root, seeds) {
+    const active = new Set(), done = new Set();
+    const visit = (value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return;
+        if (active.has(value))
+            throw new TypeError('Unsupported recursive object form schema.');
+        if (done.has(value))
+            return;
+        active.add(value);
+        const node = value;
+        if (typeof node.$ref === 'string') {
+            let target = root;
+            for (const segment of decodeURIComponent(node.$ref.slice(1)).slice(1).split('/')) {
+                target = target[segment.replace(/~1/g, '/').replace(/~0/g, '~')];
+            }
+            visit(target);
+        }
+        for (const key of ['properties', 'patternProperties', 'dependentSchemas', 'dependencies']) {
+            const map = node[key];
+            if (map && typeof map === 'object')
+                Object.values(map).forEach(visit);
+        }
+        for (const key of ['allOf', 'anyOf', 'oneOf'])
+            if (Array.isArray(node[key]))
+                node[key].forEach(visit);
+        for (const key of ['additionalProperties', 'if', 'then', 'else'])
+            visit(node[key]);
+        active.delete(value);
+        done.add(value);
+    };
+    visit(root);
+    seeds.forEach(visit);
+}
+/** Keep literal property names, including dots and pointer escapes, intact. */
+export function fieldErrors(issues) {
+    const root = Object.create(null);
+    for (const issue of issues) {
+        let node = root;
+        const path = issue.path;
+        const segments = (path === null || path === void 0 ? void 0 : path.startsWith('/')) ? path.slice(1).split('/').map(s => s.replace(/~1/g, '/').replace(/~0/g, '~')) : [];
+        // RJSF reserves __errors; retain this diagnostic at the root rather than losing it.
+        if (!segments.includes('__errors'))
+            for (const segment of segments) {
+                if (!Object.hasOwn(node, segment))
+                    Object.defineProperty(node, segment, { value: Object.create(null), enumerable: true });
+                node = node[segment];
+            }
+        if (!Object.hasOwn(node, '__errors'))
+            Object.defineProperty(node, '__errors', { value: [], enumerable: true });
+        node.__errors.push(issue.message);
+    }
+    return root;
+}

package/dist/schema.d.ts

@@ -0,0 +1,8 @@
+import type { InputDiagnostic, ValidationIssue } from './schema-types.js';
+export type * from './schema-types.js';
+export { compileSchemaBundle } from './schema-engine.js';
+export { validateSchemaInput } from './schema-compose.js';
+/** Convert input diagnostics without copying raw data or changing JSON Pointer paths. */
+export declare function toValidationIssues(diagnostics: readonly InputDiagnostic[]): readonly ValidationIssue[];
+export type * from './source-types.js';
+export { jsonValueSchema, jsonValueSchemaBundle } from './json-value.js';

package/dist/schema.js

@@ -0,0 +1,86 @@
+export { compileSchemaBundle } from './schema-engine.js';
+export { validateSchemaInput } from './schema-compose.js';
+const messages = {
+    'input-format-invalid': 'Input format is invalid.',
+    'variant-unrecognized': 'Input variant is not recognized.',
+    'input-not-json': 'Input must be a JSON-compatible value.',
+    'schema-data-invalid': 'Value does not satisfy the schema.',
+    'owner-input-invalid': 'Value does not satisfy the owner input rules.'
+};
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isPointer(value) {
+    return typeof value === 'string' && (value === '' || value.startsWith('/')) && !/~(?:[^01]|$)/u.test(value);
+}
+function readValidationIssue(value) {
+    if (!isRecord(value))
+        throw new TypeError();
+    const scope = value.scope;
+    if (!isRecord(scope))
+        throw new TypeError();
+    const identity = scope.identity;
+    if (!isRecord(identity))
+        throw new TypeError();
+    if (['ownerId', 'contractId', 'revision', 'variantId'].some(key => typeof identity[key] !== 'string')) {
+        throw new TypeError();
+    }
+    if ('consumerId' in scope && typeof scope.consumerId !== 'string')
+        throw new TypeError();
+    if ('resourceUri' in value && typeof value.resourceUri !== 'string')
+        throw new TypeError();
+    if ('schemaPath' in value && !isPointer(value.schemaPath))
+        throw new TypeError();
+    // Keep primitives locally so accessors cannot change them between validation and conversion.
+    const dataPath = value.dataPath;
+    const phase = value.phase;
+    const code = value.code;
+    if (!isPointer(dataPath))
+        throw new TypeError();
+    switch (phase) {
+        case 'decode':
+            if (code !== 'input-format-invalid' && code !== 'variant-unrecognized')
+                throw new TypeError();
+            break;
+        case 'structure':
+            if (code !== 'input-not-json' && code !== 'schema-data-invalid')
+                throw new TypeError();
+            if ('keyword' in value && typeof value.keyword !== 'string')
+                throw new TypeError();
+            break;
+        case 'semantic':
+            if (code !== 'owner-input-invalid' || typeof value.ruleId !== 'string')
+                throw new TypeError();
+            break;
+        default:
+            throw new TypeError();
+    }
+    return Object.freeze({ message: messages[code], path: dataPath });
+}
+/** Convert input diagnostics without copying raw data or changing JSON Pointer paths. */
+export function toValidationIssues(diagnostics) {
+    try {
+        if (!Array.isArray(diagnostics))
+            throw new TypeError();
+        const length = diagnostics.length;
+        if (!Number.isSafeInteger(length) || length < 0)
+            throw new TypeError();
+        // Snapshot indexed elements before invoking diagnostic getters. Ignore input iterators.
+        const snapshot = [];
+        for (let index = 0; index < length; index++) {
+            if (!Object.hasOwn(diagnostics, index))
+                throw new TypeError();
+            snapshot.push(diagnostics[index]);
+        }
+        const issues = [];
+        for (let index = 0; index < length; index++) {
+            issues.push(readValidationIssue(snapshot[index]));
+        }
+        return Object.freeze(issues);
+    }
+    catch (_a) {
+        // Never expose an external value or a getter's exception through this boundary.
+        throw new TypeError('Invalid input diagnostic.');
+    }
+}
+export { jsonValueSchema, jsonValueSchemaBundle } from './json-value.js';

package/dist/session.d.ts

@@ -2,7 +2,7 @@ import type { BlockEditorHost, BlockReference, BlockSnapshot, EditorDefinition,
 export declare class EditorSession implements EditorViewContext {
     #private;
     /** Use EditorRegistry.open() to construct sessions from a captured host snapshot. */
-    constructor(definition: EditorDefinition, snapshot: BlockSnapshot, host: BlockEditorHost);
+    constructor(definition: EditorDefinition, snapshot: BlockSnapshot, host: BlockEditorHost, isRegistered?: () => boolean);
     /** Stable instance identity remains available after the session closes. */
     get reference(): BlockReference;
     getDraft(): JsonObject;

package/dist/session.js

@@ -9,13 +9,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EditorSession_instances, _EditorSession_draft, _EditorSession_status, _EditorSession_issues, _EditorSession_error, _EditorSession_listeners, _EditorSession_view, _EditorSession_definition, _EditorSession_snapshot, _EditorSession_host, _EditorSession_prepareChanges, _EditorSession_copyIssues, _EditorSession_copyDraft, _EditorSession_assertOpen, _EditorSession_finish, _EditorSession_notify, _EditorSession_reportObserverError;
+var _EditorSession_instances, _EditorSession_draft, _EditorSession_status, _EditorSession_issues, _EditorSession_error, _EditorSession_listeners, _EditorSession_view, _EditorSession_definition, _EditorSession_snapshot, _EditorSession_host, _EditorSession_isRegistered, _EditorSession_prepareChanges, _EditorSession_copyIssues, _EditorSession_copyDraft, _EditorSession_assertOpen, _EditorSession_finish, _EditorSession_notify, _EditorSession_reportObserverError;
 import { captureReference, captureSnapshot, cloneJson, isLiteral, sameSnapshot } from './data.js';
 import { BlockEditorConflictError } from './types.js';
 import { EditorView } from './view.js';
+import { isPreparedEditor, capturePreparedSave } from './prepared-save.js';
 export class EditorSession {
     /** Use EditorRegistry.open() to construct sessions from a captured host snapshot. */
-    constructor(definition, snapshot, host) {
+    constructor(definition, snapshot, host, isRegistered) {
         _EditorSession_instances.add(this);
         _EditorSession_draft.set(this, void 0);
         _EditorSession_status.set(this, 'editing');
@@ -26,6 +27,8 @@ export class EditorSession {
         _EditorSession_definition.set(this, void 0);
         _EditorSession_snapshot.set(this, void 0);
         _EditorSession_host.set(this, void 0);
+        _EditorSession_isRegistered.set(this, void 0);
+        __classPrivateFieldSet(this, _EditorSession_isRegistered, isRegistered, "f");
         __classPrivateFieldSet(this, _EditorSession_definition, definition, "f");
         __classPrivateFieldSet(this, _EditorSession_snapshot, captureSnapshot(snapshot, captureReference(snapshot)), "f");
         __classPrivateFieldSet(this, _EditorSession_host, host, "f");
@@ -77,18 +80,28 @@ export class EditorSession {
         __classPrivateFieldSet(this, _EditorSession_error, undefined, "f");
         __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_notify).call(this);
         try {
-            const issues = await __classPrivateFieldGet(this, _EditorSession_definition, "f").validate(cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f"));
+            if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this))
+                throw new BlockEditorConflictError('The source editor registration expired.');
+            const prepared = isPreparedEditor(__classPrivateFieldGet(this, _EditorSession_definition, "f"))
+                ? capturePreparedSave(__classPrivateFieldGet(this, _EditorSession_definition, "f"), cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f")) : undefined;
+            const issues = prepared ? (prepared.kind === 'invalid' ? prepared.issues : [])
+                : await __classPrivateFieldGet(this, _EditorSession_definition, "f").validate(cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f"));
             if (!Array.isArray(issues))
                 throw new TypeError('validate() must return an issue array.');
             if (issues.length > 0) {
                 __classPrivateFieldSet(this, _EditorSession_issues, __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_copyIssues).call(this, issues), "f");
                 return { status: 'invalid', issues: __classPrivateFieldGet(this, _EditorSession_issues, "f") };
             }
-            const changes = __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_prepareChanges).call(this, __classPrivateFieldGet(this, _EditorSession_definition, "f").createPatch(cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f")));
+            const changes = __classPrivateFieldGet(this, _EditorSession_instances, "m", _EditorSession_prepareChanges).call(this, (prepared === null || prepared === void 0 ? void 0 : prepared.kind) === 'ready' ? prepared.changes
+                : __classPrivateFieldGet(this, _EditorSession_definition, "f").createPatch(cloneJson(__classPrivateFieldGet(this, _EditorSession_draft, "f")), __classPrivateFieldGet(this, _EditorSession_snapshot, "f")));
+            if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this))
+                throw new BlockEditorConflictError('The source editor registration expired.');
             const current = __classPrivateFieldGet(this, _EditorSession_host, "f").readBlock(__classPrivateFieldGet(this, _EditorSession_snapshot, "f"));
             if (!current || !sameSnapshot(__classPrivateFieldGet(this, _EditorSession_snapshot, "f"), captureSnapshot(current, __classPrivateFieldGet(this, _EditorSession_snapshot, "f")))) {
                 throw new BlockEditorConflictError();
             }
+            if (__classPrivateFieldGet(this, _EditorSession_isRegistered, "f") && !__classPrivateFieldGet(this, _EditorSession_isRegistered, "f").call(this))
+                throw new BlockEditorConflictError('The source editor registration expired.');
             if (changes.length > 0) {
                 await __classPrivateFieldGet(this, _EditorSession_host, "f").commit(Object.freeze({ expected: __classPrivateFieldGet(this, _EditorSession_snapshot, "f"), changes }));
             }
@@ -122,7 +135,7 @@ export class EditorSession {
         return true;
     }
 }
-_EditorSession_draft = new WeakMap(), _EditorSession_status = new WeakMap(), _EditorSession_issues = new WeakMap(), _EditorSession_error = new WeakMap(), _EditorSession_listeners = new WeakMap(), _EditorSession_view = new WeakMap(), _EditorSession_definition = new WeakMap(), _EditorSession_snapshot = new WeakMap(), _EditorSession_host = new WeakMap(), _EditorSession_instances = new WeakSet(), _EditorSession_prepareChanges = function _EditorSession_prepareChanges(patch) {
+_EditorSession_draft = new WeakMap(), _EditorSession_status = new WeakMap(), _EditorSession_issues = new WeakMap(), _EditorSession_error = new WeakMap(), _EditorSession_listeners = new WeakMap(), _EditorSession_view = new WeakMap(), _EditorSession_definition = new WeakMap(), _EditorSession_snapshot = new WeakMap(), _EditorSession_host = new WeakMap(), _EditorSession_isRegistered = new WeakMap(), _EditorSession_instances = new WeakSet(), _EditorSession_prepareChanges = function _EditorSession_prepareChanges(patch) {
     if (!Array.isArray(patch))
         throw new TypeError('createPatch() must return an array.');
     const seen = new Set();

package/dist/source-document.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from './types.js';
+/** Patch only edited source ranges; unsupported lossless operations fail closed. */
+export declare function patchSource(source: string, format: 'json' | 'yaml', original: JsonValue, edited: JsonValue): string;