@wirebench/engine 2.2.0 → 3.1.0-rc.1

package/dist/xsd/form-model.js

@@ -94,10 +94,15 @@ class NameScope {
             this.byUri.set(uri, prefix);
         }
         this.fresh = new PrefixTable({});
+        // A prefix bound around the form is never invented again for another namespace.
+        for (const prefix of Object.values(prefixes)) {
+            this.fresh.reserve(prefix);
+        }
     }
     /** Records the prefixes an element declares, so its subtree can reuse them. */
     declare(declarations) {
         for (const [prefix, uri] of Object.entries(declarations)) {
+            this.fresh.reserve(prefix);
             if (!this.byUri.has(uri)) {
                 this.byUri.set(uri, prefix);
             }
@@ -122,8 +127,8 @@ class NameScope {
 function absolute(ctx, range) {
     return ctx.offset === 0 ? range : { start: range.start + ctx.offset, end: range.end + ctx.offset };
 }
-/** The unconsumed source children of one element, claimed by name as particles are walked. */
-class Pool {
+/** The unconsumed source children of one element, claimed by name as particles are walked (the JSON bridge reads with it too). */
+export class Pool {
     children;
     used;
     constructor(children) {
@@ -559,6 +564,13 @@ export function buildFormForType(schemaSet, elementName, type, xml, options) {
         abstract: false,
         source: { location: '<synthetic>' },
     };
+    return buildFormForDecl(schemaSet, decl, xml, options);
+}
+/**
+ * Builds the form tree for any element declaration, a local one included: what
+ * the JSON bridge expands where a form was cut at its depth limit.
+ */
+export function buildFormForDecl(schemaSet, decl, xml, options) {
     const scanned = xml !== undefined ? scanXml(xml, options?.inScope ?? {}) : undefined;
     const ctx = {
         set: schemaSet,

package/dist/xsd/json-bridge.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Between an XSD and JSON (#33 spec §3.1, §5): the JSON Schema a body element's content maps to, XML
+ * written from a JSON value through the form model, and JSON read back from XML.
+ *
+ * All three read a complex type's content the same way, as an ordered list of {@link Member}s with
+ * stable JSON keys, in the order the form model emits its nodes: so the property a value is written
+ * from is the one the schema names and the one the reader fills. Pure and synchronous.
+ */
+import type { QName } from '../wsdl/qname.js';
+import type { ComplexType, ElementDecl, Occurs, ResolvedAttribute, ResolvedContent } from './model.js';
+import type { ResolvedType } from './sample-types.js';
+import type { SimpleTypeRef } from './sample-values.js';
+import type { SchemaSet } from './schema-set.js';
+/** A JSON Schema, as plain JSON. */
+export type JsonSchemaObject = Record<string, unknown>;
+/** What the bridge maps: a global element, or an element named here whose content is a type (an rpc part). */
+export type BridgeTarget = {
+    readonly element: QName;
+} | {
+    readonly name: QName;
+    readonly type: QName;
+};
+export interface JsonSchemaOfResult {
+    readonly schema: JsonSchemaObject;
+    /** What the schema could not say: a pattern JSON Schema cannot express, an unresolved reference. */
+    readonly notes: readonly string[];
+}
+/** Several targets written against one `$defs`: an operation's parts. */
+export interface JsonSchemaWriter {
+    /** The target's own content, inline even when its type is named. */
+    schemaOf(target: BridgeTarget): JsonSchemaObject;
+    /** Every named complex type reached so far, keyed as the `$ref`s name them; undefined when none. */
+    defs(): JsonSchemaObject | undefined;
+    notes(): readonly string[];
+}
+/** A property's description is the element's documentation, cut to this many characters. */
+export declare const MAX_PROPERTY_DESCRIPTION = 200;
+export declare const ONCE: Occurs;
+/** One thing a complex type's content contributes to its JSON object, in particle order. */
+export type Member = {
+    readonly kind: 'element';
+    readonly key: string;
+    readonly decl: ElementDecl;
+    /** Every name that stands for it: the declaration's, and its substitution group's. */
+    readonly names: readonly QName[];
+    readonly occurs: Occurs;
+    readonly optional: boolean;
+} | {
+    readonly kind: 'any';
+    readonly key: string;
+    readonly occurs: Occurs;
+    readonly optional: boolean;
+} | {
+    readonly kind: 'choice';
+    readonly occurs: Occurs;
+    readonly optional: boolean;
+    readonly branches: readonly (readonly Member[])[];
+} | {
+    /** A compositor with `maxOccurs > 1`: an array of objects, each holding `members`. */
+    readonly kind: 'group';
+    readonly key: string;
+    readonly compositor: 'sequence' | 'all' | 'choice';
+    readonly occurs: Occurs;
+    readonly optional: boolean;
+    readonly members: readonly Member[];
+};
+/** A complex type's content as the bridge reads it. */
+export interface ContentShape {
+    readonly content: ResolvedContent;
+    readonly attributes: readonly {
+        readonly key: string;
+        readonly attribute: ResolvedAttribute;
+    }[];
+    readonly members: readonly Member[];
+}
+/** True when a particle may appear more than once. */
+export declare function repeats(occurs: Occurs): boolean;
+/** A complex type's attributes (SOAP-encoding bookkeeping left out, as the form does) and members. */
+export declare function contentShape(set: SchemaSet, type: ComplexType, notes: string[]): ContentShape;
+/** Every key a member puts in its object. */
+export declare function memberKeys(member: Member): string[];
+/** Every element name a list of members can claim. */
+export declare function namesOf(members: readonly Member[]): QName[];
+export declare function typeOfDecl(set: SchemaSet, decl: ElementDecl): ResolvedType;
+/** The type of a target's content, or undefined when its element is not in the schema. */
+export declare function targetType(set: SchemaSet, target: BridgeTarget): ResolvedType | undefined;
+export type JsonKind = 'integer' | 'number' | 'boolean' | 'string';
+/** The JSON type a simple type's values take. A list or union is a string. */
+export declare function jsonKind(set: SchemaSet, ref: SimpleTypeRef): JsonKind;
+/** A lexical value as its JSON type, or undefined when it is not lexically valid for it. */
+export declare function typedLexical(kind: JsonKind, text: string): unknown;
+export declare function createJsonSchemaWriter(schemaSet: SchemaSet): JsonSchemaWriter;
+/**
+ * The JSON Schema of `target`'s content: an object of its attributes (`@a`), its text (`#text`) and its
+ * child elements for a complex type, the value's own schema for a simple one. Named complex types the
+ * content reaches are `$defs` entries referenced with `$ref`, which also carries recursion.
+ */
+export declare function jsonSchemaOf(schemaSet: SchemaSet, target: BridgeTarget): JsonSchemaOfResult;
+export interface XmlFromJsonOptions {
+    /** The prefix already declared around the fragment, per namespace URI. */
+    readonly prefixes?: Readonly<Record<string, string>>;
+    /** The namespace URI per prefix declared around the fragment. */
+    readonly inScope?: Readonly<Record<string, string>>;
+}
+export interface XmlFromJsonResult {
+    readonly xml: string;
+    /** What was written differently from what was asked. */
+    readonly notes: readonly string[];
+    /** Why the value cannot be written: a fragment that is not well formed. When any, `xml` is empty. */
+    readonly problems: readonly string[];
+}
+/**
+ * How many times one path through a value may be expanded below the form's depth cut (spec revision
+ * R10), each expansion five levels deep. A value nested deeper is refused, never cut short.
+ */
+export declare const MAX_FILL_ROUNDS = 64;
+/**
+ * A JSON scalar as text: strings as they are, numbers and booleans with `String`, anything else as
+ * its JSON. The XML bridge writes element text with it; a REST tool argument's rows use it too.
+ */
+export declare function lexical(value: unknown): string;
+type LiteralSection = readonly [open: string, close: string];
+/**
+ * `text` without the given sections, in one linear pass. The text is untrusted (a tool argument or
+ * a response), so no backtracking regex walks it. An unterminated section is kept as it is: the
+ * XML parser reports it.
+ */
+export declare function withoutSections(text: string, sections: readonly LiteralSection[]): string;
+/**
+ * XML for `target` from a JSON value shaped by {@link jsonSchemaOf}: the form model is built, filled,
+ * and serialised, so names, prefixes and element order are the desktop form's. Where the value reaches
+ * below the form's depth cut, that element is built again from its declaration and filled in turn
+ * (spec revision R10), up to {@link MAX_FILL_ROUNDS} times along one path; deeper is a problem.
+ * Written with no indentation, so text values stay exact.
+ */
+export declare function xmlFromJson(schemaSet: SchemaSet, target: BridgeTarget, value: unknown, options?: XmlFromJsonOptions): XmlFromJsonResult;
+export interface JsonFromXmlResult {
+    readonly value: unknown;
+    /** Values that could not be typed, and elements the schema does not declare. */
+    readonly notes: readonly string[];
+}
+/** `name`, or `name_2`, `name_3`… when `out` already has that key: where an unread child is kept. */
+export declare function freeKey(out: Readonly<Record<string, unknown>>, name: string): string;
+/**
+ * JSON for `xml` (one element, `target`'s) by the mapping of {@link jsonSchemaOf}, in reverse: arrays
+ * from `maxOccurs` (one occurrence is still an array), numbers and booleans typed when lexically
+ * valid, an element the schema does not declare kept as its XML text with a note.
+ */
+export declare function jsonFromXml(schemaSet: SchemaSet, target: BridgeTarget, xml: string, options?: {
+    readonly inScope?: Readonly<Record<string, string>>;
+}): JsonFromXmlResult;
+export {};