@wirebench/engine 2.1.1

package/dist/xsd/parse-particles.js

@@ -0,0 +1,320 @@
+import { NS } from '../xml/namespaces.js';
+import { getPosition } from '../xml/parse.js';
+import { childElements, firstChildElement, optionalAttribute } from '../wsdl/dom-utils.js';
+import { parseQName } from '../wsdl/qname.js';
+/** Builds a {@link SourceRef} for `el` within `ctx`'s document. */
+export function sourceRef(el, ctx) {
+    const pos = getPosition(el);
+    return { location: ctx.location, ...(pos !== undefined ? pos : {}) };
+}
+/** Records a non-fatal problem positioned at `el`. */
+export function addProblem(ctx, code, message, el) {
+    const pos = getPosition(el);
+    ctx.problems.push({ code, message, location: ctx.location, ...(pos !== undefined ? pos : {}) });
+}
+/**
+ * Reads a QName-valued attribute.
+ *
+ * Unprefixed values resolve to the in-scope XML default namespace (`xmlns="…"`)
+ * and, when none is declared, to no namespace — never to the schema's
+ * `targetNamespace`. That is the XSD rule, and differs from the lenient WSDL
+ * fallback, so `''` is passed as {@link parseQName}'s `defaultNamespace`.
+ */
+export function readQName(el, attribute, ctx) {
+    const raw = optionalAttribute(el, attribute);
+    if (raw === undefined) {
+        return undefined;
+    }
+    try {
+        return parseQName(raw, el, '');
+    }
+    catch (error) {
+        addProblem(ctx, 'invalid-schema', `Cannot resolve QName "${raw}": ${String(error)}`, el);
+        return undefined;
+    }
+}
+/** Reads `minOccurs`/`maxOccurs`, defaulting both to 1. */
+export function readOccurs(el) {
+    const minRaw = optionalAttribute(el, 'minOccurs');
+    const maxRaw = optionalAttribute(el, 'maxOccurs');
+    const min = minRaw === undefined ? 1 : Number.parseInt(minRaw, 10);
+    const max = maxRaw === undefined ? 1 : maxRaw === 'unbounded' ? 'unbounded' : Number.parseInt(maxRaw, 10);
+    return {
+        min: Number.isFinite(min) ? min : 1,
+        max: max === 'unbounded' || Number.isFinite(max) ? max : 1,
+    };
+}
+/** Reads the trimmed text of an `xs:annotation/xs:documentation` child, if present. */
+export function readAnnotation(el) {
+    const annotation = firstChildElement(el, NS.XSD, 'annotation');
+    if (annotation === undefined) {
+        return undefined;
+    }
+    const doc = firstChildElement(annotation, NS.XSD, 'documentation');
+    const text = (doc?.textContent ?? '').trim();
+    return text.length > 0 ? text : undefined;
+}
+const NUMERIC_FACETS = new Set(['length', 'minLength', 'maxLength', 'totalDigits', 'fractionDigits']);
+const LEXICAL_FACETS = new Set(['minInclusive', 'maxInclusive', 'minExclusive', 'maxExclusive']);
+const WHITESPACE_VALUES = new Set(['preserve', 'replace', 'collapse']);
+/** Collects the facet children of an `xs:restriction`, merging repeated enumerations. */
+export function parseFacets(restriction) {
+    const facets = [];
+    const enumeration = [];
+    let child = restriction.firstChild;
+    while (child !== null) {
+        if (child.nodeType === 1) {
+            const el = child;
+            if (el.namespaceURI === NS.XSD) {
+                const value = optionalAttribute(el, 'value') ?? '';
+                const localName = el.localName ?? '';
+                if (localName === 'enumeration') {
+                    enumeration.push(value);
+                }
+                else if (NUMERIC_FACETS.has(localName)) {
+                    facets.push({ kind: localName, value: Number.parseInt(value, 10) });
+                }
+                else if (LEXICAL_FACETS.has(localName)) {
+                    facets.push({ kind: localName, value });
+                }
+                else if (el.localName === 'pattern') {
+                    facets.push({ kind: 'pattern', value });
+                }
+                else if (el.localName === 'whiteSpace' && WHITESPACE_VALUES.has(value)) {
+                    facets.push({ kind: 'whiteSpace', value: value });
+                }
+            }
+        }
+        child = child.nextSibling;
+    }
+    if (enumeration.length > 0) {
+        facets.unshift({ kind: 'enumeration', values: enumeration });
+    }
+    return facets;
+}
+/** Parses an `xs:simpleType` element (named or anonymous). */
+export function parseSimpleType(el, ctx, name) {
+    const documentation = readAnnotation(el);
+    const common = {
+        kind: 'simpleType',
+        ...(name !== undefined ? { name } : {}),
+        ...(documentation !== undefined ? { documentation } : {}),
+        source: sourceRef(el, ctx),
+    };
+    const list = firstChildElement(el, NS.XSD, 'list');
+    if (list !== undefined) {
+        const itemTypeRef = readQName(list, 'itemType', ctx);
+        const inline = firstChildElement(list, NS.XSD, 'simpleType');
+        const itemType = itemTypeRef ?? (inline !== undefined ? parseSimpleType(inline, ctx) : undefined);
+        return { ...common, variety: 'list', ...(itemType !== undefined ? { itemType } : {}), facets: [] };
+    }
+    const union = firstChildElement(el, NS.XSD, 'union');
+    if (union !== undefined) {
+        const raw = optionalAttribute(union, 'memberTypes') ?? '';
+        const members = [];
+        for (const token of raw.split(/\s+/).filter((t) => t.length > 0)) {
+            try {
+                members.push(parseQName(token, union, ''));
+            }
+            catch (error) {
+                addProblem(ctx, 'invalid-schema', `Cannot resolve union member "${token}": ${String(error)}`, union);
+            }
+        }
+        for (const inline of childElements(union, NS.XSD, 'simpleType')) {
+            members.push(parseSimpleType(inline, ctx));
+        }
+        return { ...common, variety: 'union', memberTypes: members, facets: [] };
+    }
+    const restriction = firstChildElement(el, NS.XSD, 'restriction');
+    if (restriction === undefined) {
+        return { ...common, variety: 'atomic', facets: [] };
+    }
+    const base = readQName(restriction, 'base', ctx);
+    const inlineBase = firstChildElement(restriction, NS.XSD, 'simpleType');
+    return {
+        ...common,
+        variety: 'atomic',
+        ...(base !== undefined ? { base } : {}),
+        ...(base === undefined && inlineBase !== undefined ? { baseType: parseSimpleType(inlineBase, ctx) } : {}),
+        facets: parseFacets(restriction),
+    };
+}
+function readUse(el) {
+    const raw = optionalAttribute(el, 'use');
+    return raw === 'required' || raw === 'prohibited' ? raw : 'optional';
+}
+/** Parses a single `xs:attribute` element into a declaration or a ref. */
+export function parseAttribute(el, ctx, global) {
+    const use = readUse(el);
+    const defaultValue = optionalAttribute(el, 'default');
+    const fixedValue = optionalAttribute(el, 'fixed');
+    const ref = global ? undefined : readQName(el, 'ref', ctx);
+    if (ref !== undefined) {
+        // `wsdl:arrayType` on a `soapenc:arrayType` ref is the only record of an
+        // encoded array's item type, so it is preserved verbatim.
+        const arrayType = el.getAttributeNS(NS.WSDL, 'arrayType') ?? undefined;
+        return {
+            kind: 'attributeRef',
+            ref,
+            use,
+            ...(defaultValue !== undefined ? { default: defaultValue } : {}),
+            ...(fixedValue !== undefined ? { fixed: fixedValue } : {}),
+            ...(arrayType !== undefined && arrayType !== '' ? { arrayType } : {}),
+        };
+    }
+    const localName = optionalAttribute(el, 'name') ?? '';
+    const form = optionalAttribute(el, 'form');
+    const qualified = global || form === 'qualified' || (form === undefined && ctx.attributeFormDefault === 'qualified');
+    const type = readQName(el, 'type', ctx);
+    const inline = firstChildElement(el, NS.XSD, 'simpleType');
+    const documentation = readAnnotation(el);
+    const decl = {
+        kind: 'attribute',
+        name: { namespaceUri: qualified ? ctx.targetNamespace : '', localName },
+        ...(type !== undefined ? { type } : {}),
+        ...(type === undefined && inline !== undefined ? { anonymousType: parseSimpleType(inline, ctx) } : {}),
+        use,
+        ...(defaultValue !== undefined ? { default: defaultValue } : {}),
+        ...(fixedValue !== undefined ? { fixed: fixedValue } : {}),
+        ...(documentation !== undefined ? { documentation } : {}),
+        source: sourceRef(el, ctx),
+    };
+    return decl;
+}
+function readProcessContents(el) {
+    const raw = optionalAttribute(el, 'processContents');
+    return raw === 'lax' || raw === 'skip' ? raw : 'strict';
+}
+function parseAnyAttribute(el) {
+    return {
+        kind: 'anyAttribute',
+        namespace: optionalAttribute(el, 'namespace') ?? '##any',
+        processContents: readProcessContents(el),
+    };
+}
+/** Collects every `attribute`/`attributeGroup ref`/`anyAttribute` child of `parent`, in order. */
+export function parseAttributeUses(parent, ctx) {
+    const uses = [];
+    let child = parent.firstChild;
+    while (child !== null) {
+        if (child.nodeType === 1) {
+            const el = child;
+            if (el.namespaceURI === NS.XSD) {
+                if (el.localName === 'attribute') {
+                    uses.push(parseAttribute(el, ctx, false));
+                }
+                else if (el.localName === 'attributeGroup') {
+                    const ref = readQName(el, 'ref', ctx);
+                    if (ref !== undefined) {
+                        uses.push({ kind: 'attributeGroupRef', ref });
+                    }
+                }
+                else if (el.localName === 'anyAttribute') {
+                    uses.push(parseAnyAttribute(el));
+                }
+            }
+        }
+        child = child.nextSibling;
+    }
+    return uses;
+}
+/** Parses an `xs:element` declaration; `global` elements always take the target namespace. */
+export function parseElementDecl(el, ctx, global, parseComplexType) {
+    const localName = optionalAttribute(el, 'name') ?? '';
+    const form = optionalAttribute(el, 'form');
+    const qualified = global || form === 'qualified' || (form === undefined && ctx.elementFormDefault === 'qualified');
+    const type = readQName(el, 'type', ctx);
+    const inlineComplex = firstChildElement(el, NS.XSD, 'complexType');
+    const inlineSimple = firstChildElement(el, NS.XSD, 'simpleType');
+    const substitutionGroup = readQName(el, 'substitutionGroup', ctx);
+    const defaultValue = optionalAttribute(el, 'default');
+    const fixedValue = optionalAttribute(el, 'fixed');
+    const documentation = readAnnotation(el);
+    const anonymousType = type !== undefined
+        ? undefined
+        : inlineComplex !== undefined
+            ? parseComplexType(inlineComplex, ctx)
+            : inlineSimple !== undefined
+                ? parseSimpleType(inlineSimple, ctx)
+                : undefined;
+    return {
+        kind: 'element',
+        name: { namespaceUri: qualified ? ctx.targetNamespace : '', localName },
+        ...(type !== undefined ? { type } : {}),
+        ...(anonymousType !== undefined ? { anonymousType } : {}),
+        nillable: optionalAttribute(el, 'nillable') === 'true',
+        abstract: optionalAttribute(el, 'abstract') === 'true',
+        ...(substitutionGroup !== undefined ? { substitutionGroup } : {}),
+        ...(defaultValue !== undefined ? { default: defaultValue } : {}),
+        ...(fixedValue !== undefined ? { fixed: fixedValue } : {}),
+        ...(documentation !== undefined ? { documentation } : {}),
+        source: sourceRef(el, ctx),
+    };
+}
+/** Parses a compositor (`sequence`/`choice`/`all`) or any other particle element. */
+export function parseParticle(el, ctx, parseComplexType) {
+    const occurs = readOccurs(el);
+    switch (el.localName) {
+        case 'sequence':
+        case 'choice':
+        case 'all':
+            return {
+                kind: el.localName,
+                particles: parseParticleChildren(el, ctx, parseComplexType),
+                occurs,
+            };
+        case 'group': {
+            const ref = readQName(el, 'ref', ctx);
+            return ref !== undefined ? { kind: 'groupRef', ref, occurs } : undefined;
+        }
+        case 'any':
+            return {
+                kind: 'any',
+                namespace: optionalAttribute(el, 'namespace') ?? '##any',
+                processContents: readProcessContents(el),
+                occurs,
+            };
+        case 'element': {
+            const ref = readQName(el, 'ref', ctx);
+            if (ref !== undefined) {
+                return { kind: 'elementRef', ref, occurs };
+            }
+            return { kind: 'localElement', decl: parseElementDecl(el, ctx, false, parseComplexType), occurs };
+        }
+        default:
+            return undefined;
+    }
+}
+/** Parses every particle child of `parent`, skipping annotations and unknown elements. */
+export function parseParticleChildren(parent, ctx, parseComplexType) {
+    const particles = [];
+    let child = parent.firstChild;
+    while (child !== null) {
+        if (child.nodeType === 1) {
+            const el = child;
+            if (el.namespaceURI === NS.XSD) {
+                const particle = parseParticle(el, ctx, parseComplexType);
+                if (particle !== undefined) {
+                    particles.push(particle);
+                }
+            }
+        }
+        child = child.nextSibling;
+    }
+    return particles;
+}
+/** Finds the first compositor child (`sequence`/`choice`/`all`/`group ref`) of `parent`. */
+export function firstParticleChild(parent) {
+    let child = parent.firstChild;
+    while (child !== null) {
+        if (child.nodeType === 1) {
+            const el = child;
+            if (el.namespaceURI === NS.XSD &&
+                (el.localName === 'sequence' || el.localName === 'choice' || el.localName === 'all' || el.localName === 'group')) {
+                return el;
+            }
+        }
+        child = child.nextSibling;
+    }
+    return undefined;
+}

package/dist/xsd/parse-schema.d.ts

@@ -0,0 +1,21 @@
+import type { Element } from '@xmldom/xmldom';
+import type { QName } from '../wsdl/qname.js';
+import type { AttributeDecl, AttributeGroup, ComplexType, ElementDecl, Group, SimpleType } from './model.js';
+import type { SchemaContext } from './parse-particles.js';
+/** The global components declared by one `xs:schema` element. */
+export interface SchemaComponents {
+    readonly elements: readonly ElementDecl[];
+    readonly types: readonly (ComplexType | SimpleType)[];
+    readonly groups: readonly Group[];
+    readonly attributeGroups: readonly AttributeGroup[];
+    readonly attributes: readonly AttributeDecl[];
+}
+/** Parses an `xs:complexType` element (named when `name` is given, anonymous otherwise). */
+export declare function parseComplexType(el: Element, ctx: SchemaContext, name?: QName): ComplexType;
+/**
+ * Parses the global components of one `xs:schema` element.
+ *
+ * `xs:import`/`xs:include` are ignored (the bundle already resolved them);
+ * `xs:redefine` records an `unsupported` problem and its content is skipped.
+ */
+export declare function parseSchemaElement(schemaEl: Element, ctx: SchemaContext): SchemaComponents;

package/dist/xsd/parse-schema.js

@@ -0,0 +1,143 @@
+import { NS } from '../xml/namespaces.js';
+import { childElements, firstChildElement, optionalAttribute } from '../wsdl/dom-utils.js';
+import { addProblem, parseAttribute, firstParticleChild, parseAttributeUses, parseElementDecl, parseFacets, parseParticle, parseSimpleType, readAnnotation, readQName, sourceRef, } from './parse-particles.js';
+function parseDerivedContent(derivationEl, ctx, wrapper, derivation) {
+    const base = readQName(derivationEl, 'base', ctx) ?? { namespaceUri: '', localName: '' };
+    const attributes = parseAttributeUses(derivationEl, ctx);
+    if (wrapper === 'simpleContent') {
+        const facets = derivation === 'restriction' ? parseFacets(derivationEl) : [];
+        return {
+            kind: 'simpleContent',
+            derivation,
+            base,
+            attributes,
+            ...(facets.length > 0 ? { facets } : {}),
+        };
+    }
+    const particleEl = firstParticleChild(derivationEl);
+    const particle = particleEl !== undefined ? parseParticle(particleEl, ctx, parseComplexType) : undefined;
+    return {
+        kind: 'complexContent',
+        derivation,
+        base,
+        ...(particle !== undefined ? { particle } : {}),
+        attributes,
+    };
+}
+/** Parses an `xs:complexType` element (named when `name` is given, anonymous otherwise). */
+export function parseComplexType(el, ctx, name) {
+    const documentation = readAnnotation(el);
+    const common = {
+        kind: 'complexType',
+        ...(name !== undefined ? { name } : {}),
+        abstract: optionalAttribute(el, 'abstract') === 'true',
+        mixed: optionalAttribute(el, 'mixed') === 'true',
+        ...(documentation !== undefined ? { documentation } : {}),
+        source: sourceRef(el, ctx),
+    };
+    for (const wrapper of ['complexContent', 'simpleContent']) {
+        const wrapperEl = firstChildElement(el, NS.XSD, wrapper);
+        if (wrapperEl === undefined) {
+            continue;
+        }
+        // `mixed` may also be declared on `xs:complexContent`.
+        const mixed = common.mixed || optionalAttribute(wrapperEl, 'mixed') === 'true';
+        for (const derivation of ['extension', 'restriction']) {
+            const derivationEl = firstChildElement(wrapperEl, NS.XSD, derivation);
+            if (derivationEl !== undefined) {
+                return { ...common, mixed, content: parseDerivedContent(derivationEl, ctx, wrapper, derivation) };
+            }
+        }
+        addProblem(ctx, 'invalid-schema', `<xs:${wrapper}> without extension or restriction`, wrapperEl);
+        return { ...common, mixed, content: { kind: 'empty', attributes: [] } };
+    }
+    const attributes = parseAttributeUses(el, ctx);
+    const particleEl = firstParticleChild(el);
+    const particle = particleEl !== undefined ? parseParticle(particleEl, ctx, parseComplexType) : undefined;
+    if (particle === undefined) {
+        return { ...common, content: { kind: 'empty', attributes } };
+    }
+    return { ...common, content: { kind: 'particle', particle, attributes } };
+}
+function parseGroup(el, ctx, name) {
+    const particleEl = firstParticleChild(el);
+    const particle = particleEl !== undefined ? parseParticle(particleEl, ctx, parseComplexType) : undefined;
+    if (particle === undefined || particle.kind === 'groupRef') {
+        addProblem(ctx, 'invalid-schema', `<xs:group name="${name.localName}"> has no compositor child`, el);
+        return undefined;
+    }
+    const documentation = readAnnotation(el);
+    return {
+        kind: 'group',
+        name,
+        particle: particle,
+        ...(documentation !== undefined ? { documentation } : {}),
+        source: sourceRef(el, ctx),
+    };
+}
+/**
+ * Parses the global components of one `xs:schema` element.
+ *
+ * `xs:import`/`xs:include` are ignored (the bundle already resolved them);
+ * `xs:redefine` records an `unsupported` problem and its content is skipped.
+ */
+export function parseSchemaElement(schemaEl, ctx) {
+    const elements = [];
+    const types = [];
+    const groups = [];
+    const attributeGroups = [];
+    const attributes = [];
+    for (const child of childElements(schemaEl, NS.XSD, 'redefine')) {
+        addProblem(ctx, 'unsupported', 'xs:redefine is not supported; its content is ignored', child);
+    }
+    let child = schemaEl.firstChild;
+    while (child !== null) {
+        if (child.nodeType === 1) {
+            const el = child;
+            if (el.namespaceURI === NS.XSD) {
+                const localName = optionalAttribute(el, 'name');
+                const name = { namespaceUri: ctx.targetNamespace, localName: localName ?? '' };
+                switch (el.localName) {
+                    case 'element':
+                        elements.push(parseElementDecl(el, ctx, true, parseComplexType));
+                        break;
+                    case 'complexType':
+                        types.push(parseComplexType(el, ctx, name));
+                        break;
+                    case 'simpleType':
+                        types.push(parseSimpleType(el, ctx, name));
+                        break;
+                    case 'group': {
+                        const group = parseGroup(el, ctx, name);
+                        if (group !== undefined) {
+                            groups.push(group);
+                        }
+                        break;
+                    }
+                    case 'attributeGroup': {
+                        const documentation = readAnnotation(el);
+                        attributeGroups.push({
+                            kind: 'attributeGroup',
+                            name,
+                            attributes: parseAttributeUses(el, ctx),
+                            ...(documentation !== undefined ? { documentation } : {}),
+                            source: sourceRef(el, ctx),
+                        });
+                        break;
+                    }
+                    case 'attribute': {
+                        const parsed = parseAttribute(el, ctx, true);
+                        if (parsed.kind === 'attribute') {
+                            attributes.push(parsed);
+                        }
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        }
+        child = child.nextSibling;
+    }
+    return { elements, types, groups, attributeGroups, attributes };
+}

package/dist/xsd/resolve-content.d.ts

@@ -0,0 +1,18 @@
+import type { QName } from '../wsdl/qname.js';
+import type { AttributeGroup, ComplexType, Group, ResolvedContent, TypeDefinition } from './model.js';
+/** The lookups {@link resolveContent} needs; satisfied by the built `SchemaSet`. */
+export interface ResolutionContext {
+    lookupType(name: QName): TypeDefinition | undefined;
+    lookupGroup(name: QName): Group | undefined;
+    lookupAttributeGroup(name: QName): AttributeGroup | undefined;
+    lookupAttribute(name: QName): import('./model.js').AttributeDecl | undefined;
+}
+/**
+ * Computes a complex type's effective content: extension chains flattened
+ * base-first, `groupRef`s expanded in place, attribute groups and inherited
+ * attributes merged (later declarations win, `prohibited` ones removed).
+ *
+ * Cycle-safe: a base chain that loops back on itself stops at the repeat, and
+ * recursive element declarations are left as references rather than expanded.
+ */
+export declare function resolveContent(type: ComplexType, ctx: ResolutionContext): ResolvedContent;