@wirebench/engine 2.1.1

package/dist/xsd/locate.d.ts

@@ -0,0 +1,42 @@
+import type { QName } from '../wsdl/qname.js';
+import type { ElementDecl, ResolvedAttribute, SourceRef } from './model.js';
+import type { SchemaSet } from './schema-set.js';
+/** A half-open character range in a text document. */
+export interface TextRange {
+    readonly start: number;
+    readonly end: number;
+}
+/** What the completion provider needs to offer children of the element the cursor is in. */
+export interface CompletionContext {
+    /** Ancestor chain of the element that would contain the completed child, outermost first. */
+    readonly path: readonly QName[];
+    /** The (possibly empty) element name typed so far after `<`, including any prefix. */
+    readonly partial: string;
+    /** Namespace prefixes in scope at the cursor. */
+    readonly prefixes: Readonly<Record<string, string>>;
+    /** The range of `partial` in the document, to replace with the accepted completion. */
+    readonly replaceRange: TextRange;
+}
+/**
+ * Ancestor chain (outermost first) of the element containing `offset`,
+ * resolved to expanded QNames via the `xmlns` declarations in scope at that
+ * point in the text.
+ */
+export declare function elementPathAt(text: string, offset: number): QName[];
+/**
+ * Pure text analysis for the completion provider: detects an in-progress
+ * `<partial` element-name token ending at `offset` and reports the ancestor
+ * path, in-scope prefixes and the range to replace with the accepted item.
+ * Returns `undefined` when the cursor is not positioned right after an open
+ * `<` (e.g. mid-attribute, or not inside a tag at all).
+ */
+export declare function completionContextAt(text: string, offset: number): CompletionContext | undefined;
+/** Element declarations legal as children of the element at `path`, in schema order (substitution members included). */
+export declare function childrenAllowedAt(schemaSet: SchemaSet, path: readonly QName[]): ElementDecl[];
+/** Attributes legal on the element at `path`. */
+export declare function attributesAllowedAt(schemaSet: SchemaSet, path: readonly QName[]): readonly ResolvedAttribute[];
+/** The declaration and source location of the element at `path`, or `undefined` when unresolvable. */
+export declare function declarationOf(schemaSet: SchemaSet, path: readonly QName[]): {
+    readonly element: ElementDecl;
+    readonly source: SourceRef;
+} | undefined;

package/dist/xsd/locate.js

@@ -0,0 +1,249 @@
+import { qnameEquals } from '../wsdl/qname.js';
+const OPEN_TAG_RE = /<([^\s/!?>][^\s/>]*)((?:\s+[^<>]*)?)\s*(\/?)>/g;
+const ATTR_RE = /([:\w.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+const XML_PREFIX = 'xml';
+const XML_NS = 'http://www.w3.org/XML/1998/namespace';
+/** Extracts `xmlns`/`xmlns:prefix` declarations from a tag's raw attribute text. */
+function xmlnsDeclarations(rawAttrs) {
+    const decls = {};
+    const re = new RegExp(ATTR_RE);
+    let m;
+    while ((m = re.exec(rawAttrs)) !== null) {
+        const attrName = m[1];
+        const value = m[2] ?? m[3] ?? '';
+        if (attrName === 'xmlns') {
+            decls[''] = value;
+        }
+        else if (attrName.startsWith('xmlns:')) {
+            decls[attrName.slice('xmlns:'.length)] = value;
+        }
+    }
+    return decls;
+}
+function resolvePrefixed(name, prefixes) {
+    const colon = name.indexOf(':');
+    if (colon === -1) {
+        return { namespaceUri: prefixes[''] ?? '', localName: name };
+    }
+    const prefix = name.slice(0, colon);
+    const localName = name.slice(colon + 1);
+    if (prefix === XML_PREFIX) {
+        return { namespaceUri: XML_NS, localName };
+    }
+    return { namespaceUri: prefixes[prefix] ?? '', localName };
+}
+/**
+ * Walks open/close tags textually (never a DOM parse) to find the in-scope
+ * ancestor stack ending just before `offset`. Tolerant of an unfinished tag
+ * at the cursor: a `<…` with no closing `>` yet in the text simply does not
+ * match and is ignored.
+ */
+function scopeStackAt(text, offset) {
+    const stack = [];
+    const re = new RegExp(OPEN_TAG_RE);
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const matchEnd = m.index + m[0].length;
+        if (matchEnd > offset) {
+            break;
+        }
+        const raw = m[0];
+        if (raw.startsWith('</')) {
+            // Tolerant of stray/mismatched close tags: just pop, since the source text
+            // up to the cursor is assumed well-formed for the purpose of this walk.
+            if (stack.length > 0) {
+                stack.pop();
+            }
+            continue;
+        }
+        const name = m[1].replace(/^\//, '');
+        const rawAttrs = m[2] ?? '';
+        const selfClosing = m[3] === '/';
+        const parentPrefixes = stack.length > 0 ? stack[stack.length - 1].prefixes : {};
+        const ownDecls = xmlnsDeclarations(rawAttrs);
+        const prefixes = Object.keys(ownDecls).length > 0 ? { ...parentPrefixes, ...ownDecls } : parentPrefixes;
+        const qname = resolvePrefixed(name, prefixes);
+        if (!selfClosing) {
+            stack.push({ qname, prefixes });
+        }
+    }
+    return stack;
+}
+/**
+ * Ancestor chain (outermost first) of the element containing `offset`,
+ * resolved to expanded QNames via the `xmlns` declarations in scope at that
+ * point in the text.
+ */
+export function elementPathAt(text, offset) {
+    return scopeStackAt(text, offset).map((s) => s.qname);
+}
+/**
+ * Pure text analysis for the completion provider: detects an in-progress
+ * `<partial` element-name token ending at `offset` and reports the ancestor
+ * path, in-scope prefixes and the range to replace with the accepted item.
+ * Returns `undefined` when the cursor is not positioned right after an open
+ * `<` (e.g. mid-attribute, or not inside a tag at all).
+ */
+export function completionContextAt(text, offset) {
+    const before = text.slice(0, offset);
+    const ltIndex = before.lastIndexOf('<');
+    if (ltIndex === -1) {
+        return undefined;
+    }
+    const between = text.slice(ltIndex + 1, offset);
+    if (/[\s>/]/.test(between) || between.startsWith('/')) {
+        return undefined;
+    }
+    let end = offset;
+    while (end < text.length && /[\w:.-]/.test(text[end])) {
+        end += 1;
+    }
+    const path = elementPathAt(text, ltIndex);
+    const scope = scopeStackAt(text, ltIndex);
+    const prefixes = scope.length > 0 ? scope[scope.length - 1].prefixes : {};
+    return {
+        path,
+        partial: between,
+        prefixes,
+        replaceRange: { start: ltIndex + 1, end },
+    };
+}
+function resolveDeclType(schemaSet, decl) {
+    if (decl.type !== undefined) {
+        const type = schemaSet.lookupType(decl.type);
+        return type?.kind === 'complexType' ? type : undefined;
+    }
+    return decl.anonymousType?.kind === 'complexType' ? decl.anonymousType : undefined;
+}
+function findChildDecl(particle, schemaSet, name) {
+    switch (particle.kind) {
+        case 'localElement':
+            return qnameEquals(particle.decl.name, name) ? particle.decl : undefined;
+        case 'elementRef': {
+            const head = schemaSet.lookupElement(particle.ref);
+            if (head !== undefined && qnameEquals(head.name, name)) {
+                return head;
+            }
+            for (const sub of schemaSet.substitutionsFor(particle.ref)) {
+                if (qnameEquals(sub.name, name)) {
+                    return sub;
+                }
+            }
+            return undefined;
+        }
+        case 'sequence':
+        case 'choice':
+        case 'all':
+            for (const p of particle.particles) {
+                const found = findChildDecl(p, schemaSet, name);
+                if (found !== undefined) {
+                    return found;
+                }
+            }
+            return undefined;
+        case 'groupRef': {
+            const group = schemaSet.lookupGroup(particle.ref);
+            return group !== undefined ? findChildDecl(group.particle, schemaSet, name) : undefined;
+        }
+        case 'any':
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+function collectChildElements(particle, schemaSet, out) {
+    switch (particle.kind) {
+        case 'localElement':
+            out.push(particle.decl);
+            return;
+        case 'elementRef': {
+            const head = schemaSet.lookupElement(particle.ref);
+            if (head !== undefined) {
+                out.push(head);
+            }
+            for (const sub of schemaSet.substitutionsFor(particle.ref)) {
+                out.push(sub);
+            }
+            return;
+        }
+        case 'sequence':
+        case 'choice':
+        case 'all':
+            for (const p of particle.particles) {
+                collectChildElements(p, schemaSet, out);
+            }
+            return;
+        case 'groupRef': {
+            const group = schemaSet.lookupGroup(particle.ref);
+            if (group !== undefined) {
+                collectChildElements(group.particle, schemaSet, out);
+            }
+            return;
+        }
+        case 'any':
+            return;
+        default:
+            return;
+    }
+}
+/** Resolves the element declaration at the end of `path` by walking global elements through their content models. */
+function resolveElementAt(schemaSet, path) {
+    if (path.length === 0) {
+        return undefined;
+    }
+    let decl = schemaSet.lookupElement(path[0]);
+    if (decl === undefined) {
+        return undefined;
+    }
+    for (let i = 1; i < path.length; i += 1) {
+        const type = resolveDeclType(schemaSet, decl);
+        if (type === undefined) {
+            return undefined;
+        }
+        const content = schemaSet.resolveContent(type);
+        if (content.particle === undefined) {
+            return undefined;
+        }
+        const child = findChildDecl(content.particle, schemaSet, path[i]);
+        if (child === undefined) {
+            return undefined;
+        }
+        decl = child;
+    }
+    return decl;
+}
+/** Element declarations legal as children of the element at `path`, in schema order (substitution members included). */
+export function childrenAllowedAt(schemaSet, path) {
+    const decl = resolveElementAt(schemaSet, path);
+    if (decl === undefined) {
+        return [];
+    }
+    const type = resolveDeclType(schemaSet, decl);
+    if (type === undefined) {
+        return [];
+    }
+    const content = schemaSet.resolveContent(type);
+    if (content.particle === undefined) {
+        return [];
+    }
+    const out = [];
+    collectChildElements(content.particle, schemaSet, out);
+    return out;
+}
+/** Attributes legal on the element at `path`. */
+export function attributesAllowedAt(schemaSet, path) {
+    const decl = resolveElementAt(schemaSet, path);
+    if (decl === undefined) {
+        return [];
+    }
+    const type = resolveDeclType(schemaSet, decl);
+    if (type === undefined) {
+        return [];
+    }
+    return schemaSet.resolveContent(type).attributes;
+}
+/** The declaration and source location of the element at `path`, or `undefined` when unresolvable. */
+export function declarationOf(schemaSet, path) {
+    const decl = resolveElementAt(schemaSet, path);
+    return decl === undefined ? undefined : { element: decl, source: decl.source };
+}

package/dist/xsd/model.d.ts

@@ -0,0 +1,249 @@
+import type { QName } from '../wsdl/qname.js';
+/**
+ * Occurrence constraints of a particle (`minOccurs`/`maxOccurs`). Both default
+ * to `1`; `maxOccurs="unbounded"` is modelled as the literal `'unbounded'`.
+ */
+export interface Occurs {
+    readonly min: number;
+    readonly max: number | 'unbounded';
+}
+/** Where a schema component was declared, for diagnostics and "jump to source". */
+export interface SourceRef {
+    /** Document location, or `'<inline>'` when the caller supplied bare schema elements. */
+    readonly location: string;
+    readonly line?: number;
+    readonly column?: number;
+}
+/** A wildcard's `processContents` mode. Defaults to `'strict'` in XSD 1.0. */
+export type ProcessContents = 'strict' | 'lax' | 'skip';
+/** How an attribute may appear on an element. */
+export type AttributeUseKind = 'optional' | 'required' | 'prohibited';
+/** A constraining facet on a simple type. */
+export type Facet = {
+    readonly kind: 'enumeration';
+    readonly values: readonly string[];
+} | {
+    readonly kind: 'pattern';
+    readonly value: string;
+} | {
+    readonly kind: 'length' | 'minLength' | 'maxLength' | 'totalDigits' | 'fractionDigits';
+    readonly value: number;
+} | {
+    readonly kind: 'minInclusive' | 'maxInclusive' | 'minExclusive' | 'maxExclusive';
+    readonly value: string;
+} | {
+    readonly kind: 'whiteSpace';
+    readonly value: 'preserve' | 'replace' | 'collapse';
+};
+/** A simple type definition (named or anonymous). */
+export interface SimpleType {
+    readonly kind: 'simpleType';
+    /** Absent for an anonymous type declared inline in an element/attribute/list/union. */
+    readonly name?: QName;
+    readonly variety: 'atomic' | 'list' | 'union';
+    /** The `xs:restriction` base, for atomic varieties. */
+    readonly base?: QName;
+    /** An inline `xs:simpleType` used as the restriction base instead of `base`. */
+    readonly baseType?: SimpleType;
+    /** The list item type: a named reference or an inline definition. */
+    readonly itemType?: QName | SimpleType;
+    /** Union members, in declaration order: `memberTypes` first, then inline definitions. */
+    readonly memberTypes?: readonly (QName | SimpleType)[];
+    readonly facets: readonly Facet[];
+    readonly documentation?: string;
+    readonly source: SourceRef;
+}
+/** A global or local element declaration. */
+export interface ElementDecl {
+    readonly kind: 'element';
+    readonly name: QName;
+    /** A reference to a named type; mutually exclusive with {@link ElementDecl.anonymousType}. */
+    readonly type?: QName;
+    /** An inline `xs:complexType`/`xs:simpleType`. */
+    readonly anonymousType?: ComplexType | SimpleType;
+    readonly nillable: boolean;
+    readonly abstract: boolean;
+    readonly substitutionGroup?: QName;
+    readonly default?: string;
+    readonly fixed?: string;
+    readonly documentation?: string;
+    readonly source: SourceRef;
+}
+/** An element declared inline inside a particle. */
+export interface LocalElement {
+    readonly kind: 'localElement';
+    readonly decl: ElementDecl;
+    readonly occurs: Occurs;
+}
+/** An `<xs:element ref="…"/>` particle pointing at a global element declaration. */
+export interface ElementRef {
+    readonly kind: 'elementRef';
+    readonly ref: QName;
+    readonly occurs: Occurs;
+}
+/** An `<xs:any/>` element wildcard. */
+export interface AnyParticle {
+    readonly kind: 'any';
+    /** Raw `namespace` attribute, e.g. `##any`, `##other`, or a space-separated URI list. */
+    readonly namespace: string;
+    readonly processContents: ProcessContents;
+    readonly occurs: Occurs;
+}
+/** An `<xs:sequence>` compositor. */
+export interface Sequence {
+    readonly kind: 'sequence';
+    readonly particles: readonly Particle[];
+    readonly occurs: Occurs;
+}
+/** An `<xs:choice>` compositor. */
+export interface Choice {
+    readonly kind: 'choice';
+    readonly particles: readonly Particle[];
+    readonly occurs: Occurs;
+}
+/** An `<xs:all>` compositor. */
+export interface All {
+    readonly kind: 'all';
+    readonly particles: readonly Particle[];
+    readonly occurs: Occurs;
+}
+/** An `<xs:group ref="…"/>` particle. */
+export interface GroupRef {
+    readonly kind: 'groupRef';
+    readonly ref: QName;
+    readonly occurs: Occurs;
+}
+/** Any content-model particle. */
+export type Particle = LocalElement | ElementRef | AnyParticle | Sequence | Choice | All | GroupRef;
+/** A compositor particle (the only thing a named `xs:group` may contain). */
+export type Compositor = Sequence | Choice | All;
+/** A global or local attribute declaration. */
+export interface AttributeDecl {
+    readonly kind: 'attribute';
+    readonly name: QName;
+    readonly type?: QName;
+    readonly anonymousType?: SimpleType;
+    readonly use: AttributeUseKind;
+    readonly default?: string;
+    readonly fixed?: string;
+    readonly documentation?: string;
+    readonly source: SourceRef;
+}
+/** An `<xs:attribute ref="…"/>` pointing at a global attribute declaration. */
+export interface AttributeRef {
+    readonly kind: 'attributeRef';
+    readonly ref: QName;
+    readonly use: AttributeUseKind;
+    readonly default?: string;
+    readonly fixed?: string;
+    /**
+     * The raw `wsdl:arrayType` value (e.g. `xs:string[]`) written on a
+     * `soapenc:arrayType` reference inside a SOAP-encoded array type. Kept
+     * verbatim because it is the only place the array's item type is recorded.
+     */
+    readonly arrayType?: string;
+}
+/** An `<xs:attributeGroup ref="…"/>`. */
+export interface AttributeGroupRef {
+    readonly kind: 'attributeGroupRef';
+    readonly ref: QName;
+}
+/** An `<xs:anyAttribute/>` wildcard. */
+export interface AnyAttribute {
+    readonly kind: 'anyAttribute';
+    readonly namespace: string;
+    readonly processContents: ProcessContents;
+}
+/** Anything that may appear in a complex type's attribute list. */
+export type AttributeUse = AttributeDecl | AttributeRef | AttributeGroupRef | AnyAttribute;
+/** The content model of a complex type, discriminated by how it was declared. */
+export type ComplexContentModel = {
+    readonly kind: 'empty';
+    readonly attributes: readonly AttributeUse[];
+}
+/** An implicit complex content: a compositor written directly under `xs:complexType`. */
+ | {
+    readonly kind: 'particle';
+    readonly particle: Particle;
+    readonly attributes: readonly AttributeUse[];
+} | {
+    readonly kind: 'complexContent';
+    readonly derivation: 'extension' | 'restriction';
+    readonly base: QName;
+    readonly particle?: Particle;
+    readonly attributes: readonly AttributeUse[];
+} | {
+    readonly kind: 'simpleContent';
+    readonly derivation: 'extension' | 'restriction';
+    readonly base: QName;
+    readonly attributes: readonly AttributeUse[];
+    /** Facets on a `simpleContent restriction`. */
+    readonly facets?: readonly Facet[];
+};
+/** A complex type definition (named or anonymous). */
+export interface ComplexType {
+    readonly kind: 'complexType';
+    /** Absent for an anonymous type declared inline in an element declaration. */
+    readonly name?: QName;
+    readonly abstract: boolean;
+    readonly mixed: boolean;
+    readonly content: ComplexContentModel;
+    readonly documentation?: string;
+    readonly source: SourceRef;
+}
+/** Either kind of type definition. */
+export type TypeDefinition = ComplexType | SimpleType;
+/** A named model group (`xs:group`). */
+export interface Group {
+    readonly kind: 'group';
+    readonly name: QName;
+    readonly particle: Compositor;
+    readonly documentation?: string;
+    readonly source: SourceRef;
+}
+/** A named attribute group (`xs:attributeGroup`). */
+export interface AttributeGroup {
+    readonly kind: 'attributeGroup';
+    readonly name: QName;
+    readonly attributes: readonly AttributeUse[];
+    readonly documentation?: string;
+    readonly source: SourceRef;
+}
+/** A non-fatal problem found while building a {@link SchemaSet}. */
+export interface SchemaProblem {
+    readonly code: 'unresolved-ref' | 'duplicate-component' | 'unsupported' | 'invalid-schema';
+    readonly message: string;
+    readonly location: string;
+    readonly line?: number;
+    readonly column?: number;
+}
+/** A single attribute after attribute groups and inheritance have been flattened. */
+export interface ResolvedAttribute {
+    readonly name: QName;
+    readonly type?: QName;
+    readonly anonymousType?: SimpleType;
+    readonly use: 'optional' | 'required';
+    readonly default?: string;
+    readonly fixed?: string;
+    /** The `wsdl:arrayType` value carried by a `soapenc:arrayType` reference, if any. */
+    readonly arrayType?: string;
+}
+/** A complex type's effective content after derivation, groups and attribute groups are flattened. */
+export interface ResolvedContent {
+    /**
+     * The effective particle: extension chains flattened base-first (wrapped in a
+     * synthetic `sequence` when needed), `groupRef`s expanded in place, and
+     * `all`/`choice` compositors kept as declared. Absent for empty content.
+     */
+    readonly particle?: Particle;
+    /** Attributes from the whole derivation chain, deduped by name; prohibited ones removed. */
+    readonly attributes: readonly ResolvedAttribute[];
+    readonly mixed: boolean;
+    /** For `simpleContent` types: the ultimate simple base of the derivation chain. */
+    readonly simpleContentBase?: QName;
+    /** The effective attribute wildcard, if any level of the chain declares one. */
+    readonly anyAttribute?: {
+        readonly namespace: string;
+        readonly processContents: ProcessContents;
+    };
+}

package/dist/xsd/model.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,48 @@
+import type { Element } from '@xmldom/xmldom';
+import type { QName } from '../wsdl/qname.js';
+import type { AttributeUse, ElementDecl, Facet, Occurs, Particle, ComplexType, SchemaProblem, SimpleType, SourceRef } from './model.js';
+/** Parses an `xs:complexType` element; injected to break the particle/type parsing cycle. */
+export type ParseComplexType = (element: Element, ctx: SchemaContext, name?: QName) => ComplexType;
+/** Per-schema state threaded through parsing: where we are and how names qualify. */
+export interface SchemaContext {
+    /** The document location the schema element came from, or `'<inline>'`. */
+    readonly location: string;
+    readonly targetNamespace: string;
+    readonly elementFormDefault: 'qualified' | 'unqualified';
+    readonly attributeFormDefault: 'qualified' | 'unqualified';
+    /** Sink for non-fatal problems; mutated during the build. */
+    readonly problems: SchemaProblem[];
+}
+/** Builds a {@link SourceRef} for `el` within `ctx`'s document. */
+export declare function sourceRef(el: Element, ctx: SchemaContext): SourceRef;
+/** Records a non-fatal problem positioned at `el`. */
+export declare function addProblem(ctx: SchemaContext, code: SchemaProblem['code'], message: string, el: Element): void;
+/**
+ * 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 declare function readQName(el: Element, attribute: string, ctx: SchemaContext): QName | undefined;
+/** Reads `minOccurs`/`maxOccurs`, defaulting both to 1. */
+export declare function readOccurs(el: Element): Occurs;
+/** Reads the trimmed text of an `xs:annotation/xs:documentation` child, if present. */
+export declare function readAnnotation(el: Element): string | undefined;
+/** Collects the facet children of an `xs:restriction`, merging repeated enumerations. */
+export declare function parseFacets(restriction: Element): Facet[];
+/** Parses an `xs:simpleType` element (named or anonymous). */
+export declare function parseSimpleType(el: Element, ctx: SchemaContext, name?: QName): SimpleType;
+/** Parses a single `xs:attribute` element into a declaration or a ref. */
+export declare function parseAttribute(el: Element, ctx: SchemaContext, global: boolean): AttributeUse;
+/** Collects every `attribute`/`attributeGroup ref`/`anyAttribute` child of `parent`, in order. */
+export declare function parseAttributeUses(parent: Element, ctx: SchemaContext): AttributeUse[];
+/** Parses an `xs:element` declaration; `global` elements always take the target namespace. */
+export declare function parseElementDecl(el: Element, ctx: SchemaContext, global: boolean, parseComplexType: ParseComplexType): ElementDecl;
+/** Parses a compositor (`sequence`/`choice`/`all`) or any other particle element. */
+export declare function parseParticle(el: Element, ctx: SchemaContext, parseComplexType: ParseComplexType): Particle | undefined;
+/** Parses every particle child of `parent`, skipping annotations and unknown elements. */
+export declare function parseParticleChildren(parent: Element, ctx: SchemaContext, parseComplexType: ParseComplexType): Particle[];
+/** Finds the first compositor child (`sequence`/`choice`/`all`/`group ref`) of `parent`. */
+export declare function firstParticleChild(parent: Element): Element | undefined;