@wirebench/engine 2.1.1

package/dist/xsd/resolve-content.js

@@ -0,0 +1,242 @@
+import { qnameToString } from '../wsdl/qname.js';
+import { lookupBuiltin } from './builtins.js';
+/**
+ * Replaces every `groupRef` with the referenced group's compositor, carrying the
+ * ref's own occurrence constraints. `visited` breaks group-reference cycles.
+ */
+function expandGroups(particle, ctx, visited) {
+    switch (particle.kind) {
+        case 'groupRef': {
+            const key = qnameToString(particle.ref);
+            if (visited.has(key)) {
+                return undefined;
+            }
+            const group = ctx.lookupGroup(particle.ref);
+            if (group === undefined) {
+                return undefined;
+            }
+            const inner = expandGroups(group.particle, ctx, new Set([...visited, key]));
+            return inner === undefined ? undefined : { ...inner, occurs: particle.occurs };
+        }
+        case 'sequence':
+        case 'choice':
+        case 'all': {
+            const particles = particle.particles
+                .map((p) => expandGroups(p, ctx, visited))
+                .filter((p) => p !== undefined);
+            return { ...particle, particles };
+        }
+        default:
+            return particle;
+    }
+}
+const ONCE = { min: 1, max: 1 };
+/** True when a particle can be spliced into an enclosing synthetic sequence. */
+function isInlinableSequence(particle) {
+    return particle.kind === 'sequence' && particle.occurs.min === 1 && particle.occurs.max === 1;
+}
+/** Concatenates base-first particles into a single sequence, splicing plain sub-sequences. */
+function mergeParticles(parts) {
+    const flat = [];
+    for (const part of parts) {
+        if (isInlinableSequence(part)) {
+            flat.push(...part.particles);
+        }
+        else {
+            flat.push(part);
+        }
+    }
+    if (flat.length === 0) {
+        return undefined;
+    }
+    if (parts.length === 1 && !isInlinableSequence(parts[0])) {
+        return parts[0];
+    }
+    return { kind: 'sequence', particles: flat, occurs: ONCE };
+}
+function toResolvedAttribute(decl) {
+    return {
+        name: decl.name,
+        ...(decl.type !== undefined ? { type: decl.type } : {}),
+        ...(decl.anonymousType !== undefined ? { anonymousType: decl.anonymousType } : {}),
+        use: decl.use === 'required' ? 'required' : 'optional',
+        ...(decl.default !== undefined ? { default: decl.default } : {}),
+        ...(decl.fixed !== undefined ? { fixed: decl.fixed } : {}),
+    };
+}
+function collectAttributes(uses, ctx, acc, seenGroups) {
+    for (const use of uses) {
+        switch (use.kind) {
+            case 'attribute': {
+                const key = qnameToString(use.name);
+                if (use.use === 'prohibited') {
+                    acc.prohibited.add(key);
+                    acc.byName.delete(key);
+                }
+                else {
+                    acc.byName.set(key, toResolvedAttribute(use));
+                }
+                break;
+            }
+            case 'attributeRef': {
+                const key = qnameToString(use.ref);
+                if (use.use === 'prohibited') {
+                    acc.prohibited.add(key);
+                    acc.byName.delete(key);
+                    break;
+                }
+                const decl = ctx.lookupAttribute(use.ref);
+                const base = decl !== undefined ? toResolvedAttribute(decl) : { name: use.ref, use: 'optional' };
+                acc.byName.set(key, {
+                    ...base,
+                    use: use.use === 'required' ? 'required' : base.use,
+                    ...(use.default !== undefined ? { default: use.default } : {}),
+                    ...(use.fixed !== undefined ? { fixed: use.fixed } : {}),
+                    ...(use.arrayType !== undefined ? { arrayType: use.arrayType } : {}),
+                });
+                break;
+            }
+            case 'attributeGroupRef': {
+                const key = qnameToString(use.ref);
+                if (seenGroups.has(key)) {
+                    break;
+                }
+                seenGroups.add(key);
+                const group = ctx.lookupAttributeGroup(use.ref);
+                if (group !== undefined) {
+                    collectAttributes(group.attributes, ctx, acc, seenGroups);
+                }
+                break;
+            }
+            case 'anyAttribute':
+                acc.anyAttribute = { namespace: use.namespace, processContents: use.processContents };
+                break;
+        }
+    }
+}
+/** Walks a `simpleContent` derivation chain down to its ultimate simple base. */
+function ultimateSimpleBase(base, ctx, visited) {
+    const key = qnameToString(base);
+    if (visited.has(key) || lookupBuiltin(base) !== undefined) {
+        return base;
+    }
+    visited.add(key);
+    const type = ctx.lookupType(base);
+    if (type === undefined) {
+        return base;
+    }
+    if (type.kind === 'simpleType') {
+        return type.base !== undefined ? ultimateSimpleBase(type.base, ctx, visited) : base;
+    }
+    if (type.content.kind === 'simpleContent') {
+        return ultimateSimpleBase(type.content.base, ctx, visited);
+    }
+    return base;
+}
+/**
+ * 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 function resolveContent(type, ctx) {
+    const particles = [];
+    const acc = { byName: new Map(), prohibited: new Set() };
+    const visited = new Set();
+    let mixed = false;
+    let simpleContentBase;
+    // Walk the derivation chain to its root, collecting each level, then apply
+    // base-first so extensions append after what they extend.
+    const chain = [];
+    let current = type;
+    while (current !== undefined) {
+        const key = current.name !== undefined ? qnameToString(current.name) : undefined;
+        if (key !== undefined) {
+            if (visited.has(key)) {
+                break;
+            }
+            visited.add(key);
+        }
+        chain.unshift(current);
+        const content = current.content;
+        if (content.kind === 'complexContent') {
+            const base = ctx.lookupType(content.base);
+            current = base !== undefined && base.kind === 'complexType' ? base : undefined;
+            // A `restriction` restates the whole content model, so the base's particle
+            // is not inherited; only its attributes (and mixed/anyAttribute) are.
+            if (content.derivation === 'restriction') {
+                break;
+            }
+        }
+        else if (content.kind === 'simpleContent') {
+            // A simpleContent extension/restriction may still chain to a complex base
+            // that itself declares simpleContent (e.g. TaxedAmount extends Amount);
+            // follow it so the base's attributes are inherited. The chain ends once
+            // the base is a simple type or builtin (handled by ultimateSimpleBase).
+            const base = ctx.lookupType(content.base);
+            current = base !== undefined && base.kind === 'complexType' ? base : undefined;
+            if (content.derivation === 'restriction') {
+                break;
+            }
+        }
+        else {
+            current = undefined;
+        }
+    }
+    for (const level of chain) {
+        mixed = mixed || level.mixed;
+        const content = level.content;
+        if (content.kind === 'simpleContent') {
+            simpleContentBase = ultimateSimpleBase(content.base, ctx, new Set());
+        }
+        else if (content.kind === 'particle') {
+            particles.push(content.particle);
+        }
+        else if (content.kind === 'complexContent' && content.particle !== undefined) {
+            particles.push(content.particle);
+        }
+        collectAttributes(content.attributes, ctx, acc, new Set());
+    }
+    // Attributes (and, for complexContent, mixed/anyAttribute) of levels *above*
+    // a restriction cut-off are still inherited: a restriction restates the
+    // content model but not necessarily every attribute/mixed/anyAttribute.
+    const restrictionRoot = chain[0];
+    if (restrictionRoot !== undefined &&
+        (restrictionRoot.content.kind === 'complexContent' || restrictionRoot.content.kind === 'simpleContent') &&
+        restrictionRoot.content.derivation === 'restriction') {
+        const rootContent = restrictionRoot.content;
+        const inheritedType = ctx.lookupType(rootContent.base);
+        if (inheritedType !== undefined && inheritedType.kind === 'complexType') {
+            const inherited = resolveContent(inheritedType, ctx);
+            for (const attribute of inherited.attributes) {
+                const key = qnameToString(attribute.name);
+                if (!acc.prohibited.has(key) && !acc.byName.has(key)) {
+                    acc.byName.set(key, attribute);
+                }
+            }
+            if (rootContent.kind === 'complexContent') {
+                // The derived type inherits `mixed` from the base unless it declares
+                // its own (XSD 1.0: `mixed` is not required to be restated).
+                if (!restrictionRoot.mixed) {
+                    mixed = mixed || inherited.mixed;
+                }
+                // A restriction may narrow or drop `anyAttribute`; only fall back to
+                // the base's when the restriction itself declares none.
+                if (acc.anyAttribute === undefined && inherited.anyAttribute !== undefined) {
+                    acc.anyAttribute = inherited.anyAttribute;
+                }
+            }
+        }
+    }
+    const expanded = particles.map((p) => expandGroups(p, ctx, new Set())).filter((p) => p !== undefined);
+    const particle = mergeParticles(expanded);
+    return {
+        ...(particle !== undefined ? { particle } : {}),
+        attributes: [...acc.byName.values()],
+        mixed,
+        ...(simpleContentBase !== undefined ? { simpleContentBase } : {}),
+        ...(acc.anyAttribute !== undefined ? { anyAttribute: acc.anyAttribute } : {}),
+    };
+}

package/dist/xsd/sample-generator.d.ts

@@ -0,0 +1,51 @@
+import type { QName } from '../wsdl/qname.js';
+import type { SchemaSet } from './schema-set.js';
+/** How a sample fragment is generated. */
+export interface GenerateOptions {
+    /** Emit `minOccurs="0"` elements (preceded by `<!--Optional:-->`) and optional attributes. */
+    readonly includeOptional: boolean;
+    /** Emit type-appropriate example values instead of the `?` placeholder. */
+    readonly sampleValues: boolean;
+    /** Emit `<!--type: xs:int-->` comments on simple-typed leaves. */
+    readonly typeComments: boolean;
+    /** Nesting depth of complex elements after which generation is cut with a comment. */
+    readonly maxDepth: number;
+    /** Choice strategy; only `'first'` exists today (all alternatives are shown, the first is canonical). */
+    readonly choice: 'first';
+    /** Indent per level; three spaces by default. */
+    readonly indent?: string;
+    /** Preferred prefix per namespace URI; unlisted namespaces get `ns1`, `ns2`, … in first-use order. */
+    readonly prefixes?: Readonly<Record<string, string>>;
+}
+/** The defaults every generator entry point starts from. */
+export declare const DEFAULT_GENERATE_OPTIONS: GenerateOptions;
+/** A generated XML fragment plus the namespaces its root declares. */
+export interface GeneratedFragment {
+    /** The pretty-printed fragment; no XML declaration. */
+    readonly xml: string;
+    /** Prefix → namespace URI for every namespace the fragment actually uses. */
+    readonly namespaces: Readonly<Record<string, string>>;
+}
+/**
+ * Generates a sample XML fragment for a global element declaration, following
+ * the usual conventions: `?` placeholders (or typed sample values), comment
+ * markers for optional, repeating and choice particles, `xsi:type` for abstract
+ * types, and a recursion cut-off at {@link GenerateOptions.maxDepth}.
+ *
+ * Deterministic: identical inputs always produce byte-identical output.
+ *
+ * @throws {SchemaError} when `element` is not a global element in `schemaSet`
+ */
+export declare function generateElement(schemaSet: SchemaSet, element: QName, options?: Partial<GenerateOptions>): GeneratedFragment;
+/**
+ * Generates a sample fragment for an element named `elementName` whose content
+ * is described by `type` — the shape rpc-style message parts take, where the
+ * part declares a type rather than an element.
+ */
+export declare function generateType(schemaSet: SchemaSet, elementName: QName, type: QName, options?: Partial<GenerateOptions>): GeneratedFragment;
+/**
+ * Generates the wrapper for a SOAP-encoded array (rpc/encoded), carrying a
+ * `soapenc:arrayType` attribute and one `item` child:
+ * `<ns1:items soapenc:arrayType="xs:string[1]"><item>?</item></ns1:items>`.
+ */
+export declare function generateSoapEncArray(schemaSet: SchemaSet, elementName: QName, itemType: QName, options?: Partial<GenerateOptions>): GeneratedFragment;

package/dist/xsd/sample-generator.js

@@ -0,0 +1,291 @@
+import { SchemaError } from '../errors.js';
+import { NS } from '../xml/namespaces.js';
+import { qnameToString } from '../wsdl/qname.js';
+import { arrayTypeOf, firstConcreteDerived, resolveType } from './sample-types.js';
+import { PLACEHOLDER, sampleValueFor, typeCommentFor } from './sample-values.js';
+import { PrefixTable, comment, element as xmlElement, renderXml } from './xml-writer.js';
+/** The defaults every generator entry point starts from. */
+export const DEFAULT_GENERATE_OPTIONS = {
+    includeOptional: false,
+    sampleValues: false,
+    typeComments: false,
+    maxDepth: 5,
+    choice: 'first',
+    indent: '   ',
+};
+/**
+ * Fills `node` with the `soapenc:arrayType` attribute and a single `item`
+ * child. `itemType` is the array's item type; when it is unknown (a schema that
+ * declares no `wsdl:arrayType`) the array is reported as `xs:anyType[1]`.
+ */
+function fillSoapEncArray(ctx, node, itemType) {
+    const item = itemType ?? { namespaceUri: NS.XSD, localName: 'anyType' };
+    const label = ctx.prefixes.qualify(item, item.namespaceUri === NS.XSD ? 'xs' : undefined);
+    node.attributes.push({
+        name: `${ctx.prefixes.prefixFor(NS.SOAP11_ENC, 'soapenc')}:arrayType`,
+        // The declared bound is replaced by the number of items actually emitted.
+        value: `${label}[1]`,
+    });
+    const child = xmlElement('item');
+    child.text = itemType === undefined ? PLACEHOLDER : sampleValueFor(ctx.set, itemType, ctx.options);
+    node.children.push(child);
+}
+/**
+ * Interprets a `wsdl:arrayType` value such as `xs:string[]`. Only the local
+ * name survives in the schema model, so a built-in name is taken to be the XSD
+ * type of that name and anything else is left unresolved.
+ */
+function parseArrayItemType(ctx, rawArrayType) {
+    if (rawArrayType === undefined) {
+        return undefined;
+    }
+    const withoutBounds = rawArrayType.replace(/\[[^\]]*\]\s*$/, '').trim();
+    const local = withoutBounds.includes(':') ? withoutBounds.slice(withoutBounds.indexOf(':') + 1) : withoutBounds;
+    const candidate = { namespaceUri: NS.XSD, localName: local };
+    return ctx.set.builtin(candidate) !== undefined ? candidate : undefined;
+}
+/** Sets a leaf's text (and optional type comment), honouring a `fixed`/`default` value. */
+function fillLeaf(ctx, node, ref, forced) {
+    node.text = forced ?? sampleValueFor(ctx.set, ref, ctx.options);
+    if (ctx.options.typeComments) {
+        const text = typeCommentFor(ctx.set, ref);
+        if (text !== undefined) {
+            node.leadingComment = text;
+        }
+    }
+}
+function attributeValue(ctx, attribute) {
+    return (attribute.fixed ??
+        attribute.default ??
+        sampleValueFor(ctx.set, attribute.type ?? attribute.anonymousType, ctx.options));
+}
+/** Fills a complex-typed element: attributes, then simple content or child particles. */
+function fillComplex(ctx, node, complexType, depth) {
+    let effective = complexType;
+    if (complexType.abstract) {
+        const concrete = firstConcreteDerived(ctx.set, complexType);
+        if (concrete?.name !== undefined) {
+            effective = concrete;
+            node.attributes.push({
+                name: `${ctx.prefixes.prefixFor(NS.XSI, 'xsi')}:type`,
+                value: ctx.prefixes.qualify(concrete.name),
+            });
+        }
+    }
+    const resolved = ctx.set.resolveContent(effective);
+    if (effective.content.kind === 'complexContent' && ctx.set.builtin(effective.content.base)?.soapEncArray === true) {
+        fillSoapEncArray(ctx, node, parseArrayItemType(ctx, arrayTypeOf(resolved.attributes)));
+        return;
+    }
+    for (const attribute of resolved.attributes) {
+        if (attribute.use === 'optional' && !ctx.options.includeOptional) {
+            continue;
+        }
+        if (attribute.name.namespaceUri === NS.SOAP11_ENC) {
+            continue;
+        }
+        node.attributes.push({ name: ctx.prefixes.qualify(attribute.name), value: attributeValue(ctx, attribute) });
+    }
+    if (resolved.simpleContentBase !== undefined) {
+        fillLeaf(ctx, node, resolved.simpleContentBase, undefined);
+        return;
+    }
+    if (resolved.particle !== undefined) {
+        emitParticle(ctx, resolved.particle, node.children, depth + 1);
+    }
+}
+/** The comment introducing a particle's occurrence constraints, if any. */
+function occurrenceComment(occurs) {
+    if (occurs.max === 'unbounded' || occurs.max > 1) {
+        if (occurs.min === 0) {
+            return 'Zero or more repetitions:';
+        }
+        return occurs.min === 1 ? '1 or more repetitions:' : `${occurs.min} or more repetitions:`;
+    }
+    return occurs.min === 0 ? 'Optional:' : undefined;
+}
+/** Builds one element instance, or the recursion-cut comment when it is too deep. */
+function emitElement(ctx, decl, depth) {
+    // An abstract head element is never valid on the wire: emit the first
+    // concrete member of its substitution group instead.
+    let effective = decl;
+    if (decl.abstract) {
+        const member = ctx.set.substitutionsFor(decl.name).find((candidate) => !candidate.abstract);
+        if (member !== undefined) {
+            effective = member;
+        }
+    }
+    const resolved = resolveType(ctx.set, effective.type ?? effective.anonymousType);
+    if ((resolved.kind === 'complex' || resolved.kind === 'soapencArray') && depth > ctx.options.maxDepth) {
+        const label = resolved.kind === 'complex' && resolved.type.name !== undefined
+            ? ctx.prefixes.qualify(resolved.type.name)
+            : ctx.prefixes.qualify(effective.name);
+        return comment(`Recursion depth exceeded (${label})`);
+    }
+    const node = xmlElement(ctx.prefixes.qualify(effective.name));
+    const forced = effective.fixed ?? effective.default;
+    switch (resolved.kind) {
+        case 'complex':
+            fillComplex(ctx, node, resolved.type, depth);
+            break;
+        case 'soapencArray':
+            fillSoapEncArray(ctx, node, undefined);
+            break;
+        case 'anyType':
+            node.text = forced ?? PLACEHOLDER;
+            break;
+        default:
+            fillLeaf(ctx, node, resolved.ref, forced);
+    }
+    return node;
+}
+/**
+ * Emits one instance of an element particle, with its occurrence comment.
+ * `forceInclude` bypasses the `includeOptional` gate: it is set for a particle
+ * that is a direct alternative of a `choice` (every alternative is emitted
+ * regardless of options — the user picks one and deletes the rest).
+ */
+function emitElementParticle(ctx, decl, occurs, out, depth, forceInclude = false) {
+    if (!forceInclude && occurs.min === 0 && !ctx.options.includeOptional) {
+        return;
+    }
+    const node = emitElement(ctx, decl, depth);
+    // A cut-off element is replaced by its comment, so the occurrence comment
+    // that would introduce it is dropped rather than left dangling.
+    if (node.kind === 'element') {
+        const text = occurrenceComment(occurs);
+        if (text !== undefined) {
+            out.push(comment(text));
+        }
+    }
+    out.push(node);
+}
+/**
+ * Emits one particle. `forceInclude` bypasses the `includeOptional` gate for
+ * this particle only (not its descendants): it is set when this particle is a
+ * direct alternative of an enclosing `choice`, since every alternative of a
+ * choice is emitted regardless of options — the optional/occurrence
+ * gating of a compositor otherwise applies only outside a choice.
+ */
+function emitParticle(ctx, particle, out, depth, forceInclude = false) {
+    switch (particle.kind) {
+        case 'localElement':
+            emitElementParticle(ctx, particle.decl, particle.occurs, out, depth, forceInclude);
+            return;
+        case 'elementRef': {
+            const decl = ctx.set.lookupElement(particle.ref);
+            if (decl !== undefined) {
+                emitElementParticle(ctx, decl, particle.occurs, out, depth, forceInclude);
+            }
+            return;
+        }
+        case 'any':
+            out.push(comment('You may enter ANY elements at this point'));
+            return;
+        case 'groupRef': {
+            const group = ctx.set.lookupGroup(particle.ref);
+            if (group !== undefined) {
+                emitParticle(ctx, { ...group.particle, occurs: particle.occurs }, out, depth, forceInclude);
+            }
+            return;
+        }
+        default: {
+            if (!forceInclude && particle.occurs.min === 0 && !ctx.options.includeOptional) {
+                return;
+            }
+            const text = occurrenceComment(particle.occurs);
+            if (text !== undefined) {
+                out.push(comment(text));
+            }
+            if (particle.kind === 'choice') {
+                // The alternatives are announced and then every one of them is emitted,
+                // leaving the user to delete the ones they do not want. Every direct
+                // alternative is emitted regardless of `includeOptional` (the user
+                // picks one); optionality/occurrence gating still applies to content
+                // nested *inside* an alternative, and to the choice itself relative to
+                // its own parent (handled by the gate above).
+                out.push(comment(`You have a CHOICE of the next ${particle.particles.length} items at this level`));
+                for (const child of particle.particles) {
+                    emitParticle(ctx, child, out, depth, true);
+                }
+                return;
+            }
+            for (const child of particle.particles) {
+                emitParticle(ctx, child, out, depth);
+            }
+        }
+    }
+}
+function createContext(set, options) {
+    const merged = { ...DEFAULT_GENERATE_OPTIONS, ...options };
+    return { set, options: merged, prefixes: new PrefixTable(merged.prefixes ?? {}) };
+}
+function finish(ctx, node) {
+    const namespaces = ctx.prefixes.namespaces();
+    // Namespace declarations live on the fragment's root; the request builder
+    // hoists them onto the envelope later.
+    node.attributes = [
+        ...Object.entries(namespaces).map(([prefix, uri]) => ({ name: `xmlns:${prefix}`, value: uri })),
+        ...node.attributes,
+    ];
+    return { xml: renderXml(node, ctx.options.indent ?? '   '), namespaces };
+}
+/**
+ * Generates a sample XML fragment for a global element declaration, following
+ * the usual conventions: `?` placeholders (or typed sample values), comment
+ * markers for optional, repeating and choice particles, `xsi:type` for abstract
+ * types, and a recursion cut-off at {@link GenerateOptions.maxDepth}.
+ *
+ * Deterministic: identical inputs always produce byte-identical output.
+ *
+ * @throws {SchemaError} when `element` is not a global element in `schemaSet`
+ */
+export function generateElement(schemaSet, element, options) {
+    const decl = schemaSet.lookupElement(element);
+    if (decl === undefined) {
+        throw new SchemaError('schema/unknown-element', `No global element declaration for ${qnameToString(element)}`, {
+            details: { element: qnameToString(element) },
+        });
+    }
+    const ctx = createContext(schemaSet, options);
+    const node = emitElement(ctx, decl, 0);
+    if (node.kind !== 'element') {
+        throw new SchemaError('schema/unknown-element', `Could not generate a sample for ${qnameToString(element)}`);
+    }
+    return finish(ctx, node);
+}
+/**
+ * Generates a sample fragment for an element named `elementName` whose content
+ * is described by `type` — the shape rpc-style message parts take, where the
+ * part declares a type rather than an element.
+ */
+export function generateType(schemaSet, elementName, type, options) {
+    const ctx = createContext(schemaSet, options);
+    const node = xmlElement(ctx.prefixes.qualify(elementName));
+    const resolved = resolveType(ctx.set, type);
+    switch (resolved.kind) {
+        case 'complex':
+            fillComplex(ctx, node, resolved.type, 0);
+            break;
+        case 'soapencArray':
+            fillSoapEncArray(ctx, node, undefined);
+            break;
+        case 'anyType':
+            node.text = PLACEHOLDER;
+            break;
+        default:
+            fillLeaf(ctx, node, resolved.ref, undefined);
+    }
+    return finish(ctx, node);
+}
+/**
+ * Generates the wrapper for a SOAP-encoded array (rpc/encoded), carrying a
+ * `soapenc:arrayType` attribute and one `item` child:
+ * `<ns1:items soapenc:arrayType="xs:string[1]"><item>?</item></ns1:items>`.
+ */
+export function generateSoapEncArray(schemaSet, elementName, itemType, options) {
+    const ctx = createContext(schemaSet, options);
+    const node = xmlElement(ctx.prefixes.qualify(elementName));
+    fillSoapEncArray(ctx, node, itemType);
+    return finish(ctx, node);
+}

package/dist/xsd/sample-types.d.ts

@@ -0,0 +1,21 @@
+import type { QName } from '../wsdl/qname.js';
+import type { ComplexType, ResolvedAttribute, SimpleType } from './model.js';
+import type { SchemaSet } from './schema-set.js';
+import type { SimpleTypeRef } from './sample-values.js';
+/** The type a leaf or element resolves to, once names and built-ins are followed. */
+export type ResolvedType = {
+    readonly kind: 'complex';
+    readonly type: ComplexType;
+} | {
+    readonly kind: 'simple';
+    readonly ref: SimpleTypeRef;
+} | {
+    readonly kind: 'anyType';
+} | {
+    readonly kind: 'soapencArray';
+};
+export declare function resolveType(set: SchemaSet, ref: QName | ComplexType | SimpleType | undefined): ResolvedType;
+/** The first concrete type derived from an abstract one, in schema declaration order. */
+export declare function firstConcreteDerived(set: SchemaSet, abstractType: ComplexType): ComplexType | undefined;
+/** The `wsdl:arrayType` recorded on a SOAP-encoded array type, e.g. `xs:string[]`. */
+export declare function arrayTypeOf(attributes: readonly ResolvedAttribute[]): string | undefined;

package/dist/xsd/sample-types.js

@@ -0,0 +1,69 @@
+import { NS } from '../xml/namespaces.js';
+import { qnameEquals, qnameToString } from '../wsdl/qname.js';
+export function resolveType(set, ref) {
+    if (ref === undefined) {
+        return { kind: 'anyType' };
+    }
+    if ('kind' in ref) {
+        return ref.kind === 'complexType' ? { kind: 'complex', type: ref } : { kind: 'simple', ref };
+    }
+    const builtin = set.builtin(ref);
+    if (builtin !== undefined) {
+        if (builtin.soapEncArray === true) {
+            return { kind: 'soapencArray' };
+        }
+        return ref.namespaceUri === NS.XSD && (ref.localName === 'anyType' || ref.localName === 'anySimpleType')
+            ? { kind: 'anyType' }
+            : { kind: 'simple', ref };
+    }
+    const type = set.lookupType(ref);
+    if (type === undefined) {
+        // A dangling type reference is already reported by the schema set; fall
+        // back to a bare placeholder rather than failing the whole fragment.
+        return { kind: 'anyType' };
+    }
+    return type.kind === 'complexType' ? { kind: 'complex', type } : { kind: 'simple', ref };
+}
+/** True when `candidate` reaches `base` through its complexContent derivation chain. */
+function derivesFrom(set, candidate, base) {
+    const seen = new Set();
+    let current = candidate;
+    while (current !== undefined) {
+        if (current.content.kind !== 'complexContent' && current.content.kind !== 'simpleContent') {
+            return false;
+        }
+        const parent = current.content.base;
+        if (qnameEquals(parent, base)) {
+            return true;
+        }
+        const key = qnameToString(parent);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        const next = set.lookupType(parent);
+        current = next !== undefined && next.kind === 'complexType' ? next : undefined;
+    }
+    return false;
+}
+/** The first concrete type derived from an abstract one, in schema declaration order. */
+export function firstConcreteDerived(set, abstractType) {
+    if (abstractType.name === undefined) {
+        return undefined;
+    }
+    for (const type of set.types.values()) {
+        if (type.kind === 'complexType' && !type.abstract && derivesFrom(set, type, abstractType.name)) {
+            return type;
+        }
+    }
+    return undefined;
+}
+/** The `wsdl:arrayType` recorded on a SOAP-encoded array type, e.g. `xs:string[]`. */
+export function arrayTypeOf(attributes) {
+    for (const attribute of attributes) {
+        if (attribute.arrayType !== undefined) {
+            return attribute.arrayType;
+        }
+    }
+    return undefined;
+}