@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/iec/index.js

@@ -0,0 +1,507 @@
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { Language, PubidDate } from "../../model/component.js";
+import { iecGrammar, preprocessIec } from "./grammar.js";
+import { locateStage, IEC_CLASSES, } from "./model.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const s = (v) => v === undefined || v === null ? undefined : String(v);
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+/** Splits a number_with_part tree into number/part/subpart. */
+function numberComponents(tree) {
+    const obj = isObj(tree) ? tree : undefined;
+    const raw = obj === undefined ? s(tree) : s(obj["number"]);
+    if (raw === undefined)
+        return {};
+    const out = { number: raw };
+    const part = obj === undefined ? undefined : s(obj["part"]);
+    const subpart = obj === undefined ? undefined : s(obj["subpart"]);
+    if (part !== undefined)
+        out["part"] = part;
+    if (subpart !== undefined)
+        out["subpart"] = subpart;
+    return out;
+}
+function buildDate(tree) {
+    const dateStr = s(flatten(tree));
+    if (dateStr === undefined)
+        return undefined;
+    const parts = dateStr.split("-");
+    return new PubidDate({ year: parts[0], month: parts[1], day: parts[2] });
+}
+function parseLanguages(tree) {
+    const raw = s(tree);
+    if (raw === undefined)
+        return [];
+    const tokens = raw.split(",").flatMap((chunk) => chunk.split("/"));
+    return tokens
+        .map((token) => token.trim())
+        .filter((token) => token !== "")
+        .map((original) => {
+        const code = original.length === 1
+            ? (Language.CHAR_MAP[original] ?? original.toLowerCase())
+            : original;
+        return new Language({ code, originalCode: original });
+    });
+}
+class IecBuilder {
+    build(data) {
+        return this.buildInner(data);
+    }
+    buildInner(data) {
+        const tree = flatten(data);
+        // --- working programme / working document ---
+        if (tree["wp_stage"] !== undefined)
+            return this.buildWorkingProgramme(tree);
+        if (tree["technical_committee"] !== undefined && tree["wd_number"] !== undefined) {
+            return this.buildWorkingDocument(tree);
+        }
+        if (tree["technical_committee"] !== undefined) {
+            throw new ParseFailed("IEC: technical groups are not corpus-covered", 0);
+        }
+        // --- fragment of an amendment/corrigendum (third_part notation) ---
+        if (tree["fragment_type"] !== undefined && tree["base"] !== undefined) {
+            return this.buildFragment(tree);
+        }
+        // --- sheets ---
+        if (tree["base"] !== undefined && (tree["sheet_number"] !== undefined || tree["sheet_year"] !== undefined)) {
+            return this.buildSheet(tree);
+        }
+        // --- supplements (incl. supplement-of-supplement) ---
+        if (tree["base"] !== undefined)
+            return this.buildSupplement(tree);
+        return this.buildSingle(tree);
+    }
+    commonAttrs(tree, attrs) {
+        Object.assign(attrs, numberComponents(tree["number_with_part"]));
+        // Letters-prefixed numbers (IECEE "CAB", "AD") only take digit-first
+        // parts — "CAB-G01" rejects (Ruby parity; digit numbers like 61158-X
+        // keep letter parts).
+        const number = attrs["number"];
+        const part = attrs["part"];
+        if (number !== undefined && /^[A-Z]{2,4}$/.test(number) &&
+            part !== undefined && /^[A-Za-z]/.test(part)) {
+            throw new ParseFailed(`IEC: letter part ${part} after letters number ${number}`, 0);
+        }
+        const dateTree = tree["date"];
+        if (dateTree !== undefined) {
+            const date = buildDate(dateTree);
+            if (date)
+                attrs["date"] = date;
+        }
+        if (tree["undated_marker"] !== undefined)
+            attrs["date"] = new PubidDate({ undated: true });
+        const edition = s(tree["edition"]);
+        if (edition !== undefined)
+            attrs["edition"] = edition;
+        if (tree["languages"] !== undefined) {
+            attrs["languages"] = parseLanguages(tree["languages"]);
+        }
+        const publisher = s(tree["publisher"]);
+        if (publisher !== undefined)
+            attrs["publisher"] = publisher;
+        const copubTree = tree["copublishers"];
+        if (copubTree !== undefined && copubTree !== null && copubTree !== "") {
+            const list = Array.isArray(copubTree) ? copubTree : [copubTree];
+            const bodies = list
+                .map((c) => (isObj(c) ? String(c["copublisher"]) : String(c)))
+                .filter((b) => b !== "" && b !== "null" && b !== "undefined");
+            if (bodies.length > 0)
+                attrs["copublishers"] = bodies;
+        }
+        if (tree["all_parts"] !== undefined)
+            attrs["all_parts"] = true;
+        if (tree["database"] !== undefined)
+            attrs["database"] = true;
+    }
+    buildSingle(tree) {
+        const stageAbbr = s(tree["type_with_stage"]) ?? s(tree["type_with_stage_fr"]) ?? "";
+        const typedStage = locateStage(stageAbbr) ?? locateStage("IS");
+        const kind = typedStage.typeCode === "wp" ? "is" : typedStage.typeCode;
+        const attrs = {};
+        this.commonAttrs(tree, attrs);
+        // TRF with an embedded CISPR document: the CISPR number is runtime-only
+        // (hash carries just year/publisher; the URN names the CISPR document).
+        if (tree["trf_org"] !== undefined) {
+            const cisprComponents = numberComponents(tree["number_with_part"]);
+            attrs["cispr_number"] = cisprComponents["number"];
+            attrs["cispr_part"] = cisprComponents["part"];
+            delete attrs["number"];
+            delete attrs["part"];
+            delete attrs["subpart"];
+        }
+        // The supplement-of-supplement path stores the base separately.
+        const parsed = {
+            typedStage,
+            kind: kind,
+            attrs,
+        };
+        // Consolidated supplements (+AMD…+AMD…)
+        const consolidated = tree["consolidated_supplements"];
+        let identifier = this.construct(parsed, attrs);
+        if (consolidated !== undefined) {
+            identifier = this.wrapConsolidated(identifier, consolidated);
+        }
+        const vapSuffix = s(tree["vap_suffix"]);
+        if (vapSuffix !== undefined) {
+            identifier = this.wrapVap(identifier, vapSuffix);
+        }
+        return identifier;
+    }
+    construct(parsed, attrs) {
+        const klass = IEC_CLASSES.KIND_CLASSES[parsed.kind];
+        if (klass === undefined)
+            throw new ParseFailed(`IEC: unknown kind ${String(parsed.kind)}`, 0);
+        const identifier = new klass(attrs);
+        identifier.typedStage = parsed.typedStage;
+        // The wire "stage" is the draft stage code (published stages drop).
+        const ts = parsed.typedStage;
+        if (ts !== undefined && ts.stageCode !== "published") {
+            identifier["stage"] = ts.code;
+        }
+        return identifier;
+    }
+    wrapConsolidated(base, data) {
+        const list = Array.isArray(data) ? data : [data];
+        const members = [base];
+        for (const raw of list) {
+            if (!isObj(raw))
+                continue;
+            const type = s(raw["supplement_type"]);
+            const number = s(raw["supplement_number"]);
+            if (type === undefined || number === undefined)
+                continue;
+            const date = s(raw["supplement_year"]);
+            const attrs = {
+                number,
+                ...(date !== undefined ? { date: new PubidDate({ year: date }) } : {}),
+            };
+            const kind = type === "AMD" ? "amd" : "cor";
+            const member = this.construct({ kind: kind, attrs, typedStage: locateStage(type) }, attrs);
+            members.push(member);
+        }
+        return new IEC_CLASSES.CONSOLIDATED_CLASS({
+            identifiers: members,
+        });
+    }
+    wrapVap(base, vapSuffix) {
+        const vap = vapSuffix.split("-");
+        let edition;
+        // A consolidated base carries the edition on its FIRST member (Ruby).
+        const kind = base.constructor.polymorphicName.slice("pubid:iec:".length);
+        const holder = kind === "consolidated-identifier"
+            ? base.identifiers[0]
+            : base;
+        if (holder["edition"] !== undefined) {
+            edition = String(holder["edition"]);
+            delete holder["edition"];
+        }
+        return new IEC_CLASSES.VAP_CLASS({
+            base,
+            vap,
+            ...(edition !== undefined ? { edition } : {}),
+        });
+    }
+    buildSupplement(tree) {
+        const base = this.buildInner(tree["base"]);
+        const stageAbbr = s(tree["type_with_stage"]) ?? "";
+        const typedStage = locateStage(stageAbbr) ?? locateStage("AMD");
+        let kind;
+        if (typedStage.typeCode === "cor")
+            kind = "cor";
+        else if (typedStage.typeCode === "ish")
+            kind = "ish";
+        else if (typedStage.typeCode === "frag") {
+            // FRAG parses as a supplement stage; the class is the fragment.
+            const innerAttrs = {};
+            this.commonAttrs(tree, innerAttrs);
+            const number = innerAttrs["number"];
+            delete innerAttrs["number"];
+            const baseRec2 = base;
+            if (baseRec2["publisher"] !== undefined && baseRec2["publisher"] !== "IEC")
+                innerAttrs["publisher"] = baseRec2["publisher"];
+            const fragment = new IEC_CLASSES.FRAGMENT_CLASS({
+                base,
+                ...(number !== undefined ? { fragment_number: number } : {}),
+                ...innerAttrs,
+            });
+            return fragment;
+        }
+        else
+            kind = "amd";
+        const attrs = {};
+        this.commonAttrs(tree, attrs);
+        // Supplements copy the delegated publisher/copublishers level.
+        const baseRec = base;
+        if (attrs["publisher"] === undefined && baseRec["publisher"] !== undefined && baseRec["publisher"] !== "IEC") {
+            attrs["publisher"] = baseRec["publisher"];
+        }
+        if (attrs["copublishers"] === undefined && Array.isArray(baseRec["copublishers"]) && baseRec["copublishers"].length > 0) {
+            attrs["copublishers"] = baseRec["copublishers"];
+        }
+        const supplement = this.construct({ kind: kind, attrs, typedStage }, attrs);
+        const suppRec = supplement;
+        suppRec["base"] = base;
+        const vapSuffix = s(tree["vap_suffix"]);
+        if (vapSuffix !== undefined)
+            return this.wrapVap(supplement, vapSuffix);
+        return supplement;
+    }
+    buildSheet(tree) {
+        let base = this.buildInner(tree["base"]);
+        const sheet_number = s(tree["sheet_number"]);
+        const sheet_year = s(tree["sheet_year"]);
+        base = new IEC_CLASSES.SHEET_CLASS({
+            base,
+            ...(sheet_number !== undefined ? { sheet_number } : {}),
+            ...(sheet_year !== undefined ? { sheet_year } : {}),
+        });
+        // A supplement wrapping the sheet: IEC 60695-2-1/1:1994/COR1:1995.
+        if (tree["type_with_stage"] !== undefined) {
+            const stageAbbr = s(tree["type_with_stage"]) ?? "";
+            const typedStage = locateStage(stageAbbr) ?? locateStage("COR");
+            const kind = typedStage.typeCode === "cor" ? "cor" : "amd";
+            const attrs = {};
+            const numberObj = numberComponents(tree["number_with_part"]);
+            Object.assign(attrs, numberObj);
+            const dateTree = tree["date"];
+            if (dateTree !== undefined) {
+                const date = buildDate(dateTree);
+                if (date)
+                    attrs["date"] = date;
+            }
+            const supplement = this.construct({ kind: kind, attrs, typedStage }, attrs);
+            supplement["base"] = base;
+            return supplement;
+        }
+        return base;
+    }
+    buildFragment(tree) {
+        // fragment_notation on the outer identifier (third_part)
+        const innerTree = { ...tree };
+        delete innerTree["fragment_type"];
+        delete innerTree["fragment_number"];
+        const base = this.buildInner(innerTree);
+        const fragment_number = s(tree["fragment_number"]);
+        const edition = s(tree["edition"]);
+        return new IEC_CLASSES.FRAGMENT_CLASS({
+            base,
+            ...(fragment_number !== undefined ? { fragment_number } : {}),
+            ...(edition !== undefined ? { edition } : {}),
+        });
+    }
+    buildWorkingProgramme(tree) {
+        const attrs = {
+            wp_stage: s(tree["wp_stage"]),
+            wp_type: s(tree["wp_type"]),
+        };
+        if (tree["wp_raw"] !== undefined) {
+            // TC-style name ("SyCCOMM-1"): split the trailing number as the part.
+            const raw = String(tree["wp_raw"]).replaceAll("‑", "-").replaceAll("‐", "-");
+            const segments = raw.split("-").filter((seg) => seg !== "");
+            attrs["number"] = segments.shift();
+            if (segments.length > 0)
+                attrs["part"] = segments.shift();
+            if (segments.length > 0)
+                attrs["subpart"] = segments.join("-");
+        }
+        Object.assign(attrs, numberComponents(tree["number_with_part"]));
+        const edition = s(tree["edition"]);
+        if (edition !== undefined)
+            attrs["edition"] = edition;
+        const identifier = new IEC_CLASSES.KIND_CLASSES["wp"](attrs);
+        const ts = locateStage(s(tree["wp_stage"]) === "PNW" ? "PNW" : "PWI");
+        identifier.typedStage = ts;
+        if (ts !== undefined && ts.stageCode !== "published") {
+            identifier["stage"] = ts.code;
+        }
+        return identifier;
+    }
+    buildWorkingDocument(tree) {
+        const attrs = {
+            technical_committee: s(tree["technical_committee"]),
+            wd_number: s(tree["wd_number"]),
+            wd_language: s(tree["wd_language"]),
+            wd_stage: s(tree["wd_stage"]),
+        };
+        return new IEC_CLASSES.KIND_CLASSES["wp"](attrs);
+    }
+}
+/** --- URN: the positional-slot machine (lib/pubid/iec/urn_generator.rb) --- */
+const TYPE_SLOT_CODES = new Set(["tr", "ts", "pas", "srd", "guide", "tec", "wp"]);
+const DELIVERABLES = new Set(["cmv", "csv", "exv", "prv", "rlv", "ser"]);
+const ADJUNCT_TOKENS = {
+    amendment: "amd",
+    corrigendum: "cor",
+    "interpretation-sheet": "ish",
+};
+function idKind(id) {
+    return id.constructor.polymorphicName.slice("pubid:iec:".length);
+}
+function maybeOf(id, attr) {
+    return id[attr];
+}
+function findDown(id, attr) {
+    let current = id;
+    while (current !== undefined) {
+        const value = maybeOf(current, attr);
+        if (value !== undefined && !(Array.isArray(value) && value.length === 0) && value !== "") {
+            return value;
+        }
+        current =
+            maybeOf(current, "base") ??
+                maybeOf(current, "identifiers")?.[0];
+    }
+    return undefined;
+}
+function rootOf(id) {
+    let current = id;
+    while (true) {
+        const base = maybeOf(current, "base");
+        if (base !== undefined) {
+            current = base;
+            continue;
+        }
+        const ids = maybeOf(current, "identifiers");
+        if (ids !== undefined && ids.length > 0 && ids[0] !== current) {
+            current = ids[0];
+            continue;
+        }
+        return current;
+    }
+}
+function adjunctFields(id, plus) {
+    const kind = idKind(id);
+    const token = ADJUNCT_TOKENS[kind];
+    if (token === undefined)
+        return [];
+    const date = maybeOf(id, "date");
+    return [
+        plus ? "plus" : "",
+        token,
+        String(maybeOf(id, "number") ?? ""),
+        date !== undefined ? (date.render() ?? "") : "",
+    ];
+}
+function adjunctSlots(id) {
+    if (id === undefined)
+        return [];
+    const kind = idKind(id);
+    if (kind === "consolidated-identifier") {
+        const members = maybeOf(id, "identifiers") ?? [];
+        return [
+            ...adjunctSlots(members[0]),
+            ...members.slice(1).flatMap((m) => adjunctFields(m, true)),
+        ];
+    }
+    const recursed = adjunctSlots(maybeOf(id, "base"));
+    if (ADJUNCT_TOKENS[kind] !== undefined) {
+        return [...recursed, ...adjunctFields(id, false)];
+    }
+    return recursed;
+}
+export function iecToUrn(identifier) {
+    // The document the URN names: the origin standard with wrappers peeled.
+    const doc = rootOf(identifier);
+    const trf = doc;
+    let docWithNumber;
+    if (maybeOf(trf, "number") === undefined && maybeOf(trf, "cispr_number") !== undefined) {
+        // TRF: read number/part from the runtime CISPR columns.
+        docWithNumber = {
+            get number() { return maybeOf(trf, "cispr_number"); },
+            get part() { return maybeOf(trf, "cispr_part"); },
+            get subpart() { return undefined; },
+            get publisher() { return "CISPR"; },
+            get copublishers() { return []; },
+            get date() { return undefined; },
+            get typedStage() { return trf.typedStage; },
+        };
+    }
+    else {
+        docWithNumber = maybeOf(doc, "number") !== undefined
+            ? doc
+            : maybeOf(doc, "cispr_identifier") ?? doc;
+    }
+    const number = maybeOf(docWithNumber, "number");
+    if (number === undefined)
+        return "urn:iec:std:";
+    const numSegment = [number, maybeOf(docWithNumber, "part"), maybeOf(docWithNumber, "subpart")]
+        .filter((v) => v !== undefined && v !== "")
+        .join("-")
+        .replace(/\s+/g, "-");
+    if (numSegment === "")
+        return "urn:iec:std:";
+    const publishers = [
+        maybeOf(docWithNumber, "publisher") ?? "IEC",
+        ...(maybeOf(docWithNumber, "copublishers") ?? []),
+    ]
+        .filter((p) => p !== undefined && p !== "")
+        .map((p) => p.split(/\s+/).at(-1))
+        .filter((p) => p !== "");
+    const authority = publishers.join("-");
+    const date = maybeOf(docWithNumber, "date");
+    const dateSlot = date !== undefined ? (date.render() ?? "") : "";
+    const ts = docWithNumber.typedStage;
+    const typeToken = ts !== undefined && TYPE_SLOT_CODES.has(ts.typeCode) ? ts.typeCode : "";
+    const stageToken = ts !== undefined && ts.stageCode !== "published"
+        ? `stage-${ts.harmonized ?? ts.stageCode}`
+        : "";
+    const stageOrType = [typeToken, stageToken].filter((t) => t !== "").join("-");
+    const vap = findDown(identifier, "vap");
+    const vapCodes = (vap ?? [])
+        .map((c) => c.toLowerCase())
+        .filter((c) => DELIVERABLES.has(c));
+    let deliverable = vapCodes.join("-");
+    if (deliverable === "") {
+        const edition = findDown(identifier, "edition");
+        deliverable = edition !== undefined ? `ed-${edition}` : "";
+    }
+    const langs = maybeOf(identifier, "languages") ?? [];
+    const language = langs.map((l) => l.code).join("-");
+    const slots = ["urn", "iec", "std", authority, numSegment, dateSlot, stageOrType, deliverable];
+    const adjuncts = adjunctSlots(identifier);
+    const bareSeries = slots.at(-1) === "ser" &&
+        slots.slice(5, 7).every((x) => x === "") &&
+        adjuncts.length === 0 &&
+        language === "";
+    if (!bareSeries)
+        slots.push(language);
+    return [...slots, ...adjuncts].join(":").toLowerCase();
+}
+// Attach the URN generator to every registered IEC class (the base
+// toUrn resolves constructor.urnGenerator).
+class IecUrnGenerator {
+    identifier;
+    constructor(identifier) {
+        this.identifier = identifier;
+    }
+    generate() {
+        return iecToUrn(this.identifier);
+    }
+}
+for (const klass of [
+    ...Object.values(IEC_CLASSES.KIND_CLASSES),
+    IEC_CLASSES.SHEET_CLASS,
+    IEC_CLASSES.VAP_CLASS,
+    IEC_CLASSES.CONSOLIDATED_CLASS,
+    IEC_CLASSES.FRAGMENT_CLASS,
+]) {
+    if (klass !== undefined) {
+        klass.urnGenerator = IecUrnGenerator;
+    }
+}
+export function iecGrammarImplementation() {
+    const builder = new IecBuilder();
+    return {
+        parse(input) {
+            let tree;
+            try {
+                tree = parseGrammar(iecGrammar, preprocessIec(input));
+            }
+            catch {
+                throw new ParseFailed("IEC: parse failed", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

package/dist/flavors/iec/model.d.ts

@@ -0,0 +1,54 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import type { IdentifierStatic } from "../../model/identifier.js";
+import { Language, PubidDate } from "../../model/component.js";
+/**
+ * IEC model classes (lib/pubid/iec/identifiers/*). The typed stage is a
+ * runtime attribute driving type derivation and the URN stage slot; the
+ * wire hash carries only the stage CODE for non-published drafts.
+ */
+export type IecTypeCode = "is" | "tr" | "ts" | "pas" | "srd" | "od" | "guide" | "ish" | "frag" | "trf" | "tec" | "wp" | "sttr" | "amd" | "cor";
+export interface TypedStage {
+    code: string;
+    stageCode: string;
+    typeCode: IecTypeCode;
+    abbr: string;
+    /** Harmonized stage code for the URN "stage-…" slot (drafts only). */
+    harmonized?: string | undefined;
+    /** Grammar tokens that resolve to this stage (defaults to [abbr]). */
+    tokens?: string[] | undefined;
+}
+export declare const TYPED_STAGES: TypedStage[];
+export declare function stageTokens(): string[];
+export declare function locateStage(token: string): TypedStage | undefined;
+export declare abstract class IecIdentifier extends BaseIdentifier {
+    readonly number: string | undefined;
+    /** Walk the supplement chain to the base document (BSI's URN
+     * generator reaches the root identity of adopted bases). */
+    root(): IecIdentifier;
+    readonly part: string | undefined;
+    readonly subpart: string | undefined;
+    readonly date: PubidDate | undefined;
+    readonly edition: string | undefined;
+    readonly languages: Language[];
+    readonly publisher: string | undefined;
+    readonly copublishers: string[];
+    readonly stage: string | undefined;
+    readonly all_parts: boolean | undefined;
+    readonly database: boolean | undefined;
+    readonly base: IecIdentifier | undefined;
+    /** The runtime typed stage — never serialized directly. */
+    typedStage: TypedStage | undefined;
+    /** Ruby SingleIdentifier#publisher_portion. */
+    publisherPortion(): string;
+    /** Ruby SingleIdentifier#number_portion. */
+    numberPortion(): string;
+    stageIterationValue(): string | undefined;
+    languagePortion(): string;
+}
+export declare const IEC_CLASSES: {
+    readonly KIND_CLASSES: Partial<Record<IecTypeCode, IdentifierStatic>>;
+    readonly SHEET_CLASS: IdentifierStatic;
+    readonly VAP_CLASS: IdentifierStatic;
+    readonly CONSOLIDATED_CLASS: IdentifierStatic;
+    readonly FRAGMENT_CLASS: IdentifierStatic;
+};