@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/cie/model.js

@@ -0,0 +1,464 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes } from "../../model/attribute.js";
+import { Component } from "../../model/component.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/cie/identifiers/* + components/language.rb.
+ * The wire hash is the raw attribute table (CIE declares no key_value
+ * block): number/part/iteration/part_separator flat, `language` a
+ * nested {code, format[, translation_year]} hash, publisher ("CIE")
+ * and style ("current") dropped as defaults.
+ */
+/** The CIE Language component: four printed formats. */
+export class CieLanguage extends Component {
+    code;
+    format;
+    translation_year;
+    constructor(attrs) {
+        super();
+        this.code = attrs["code"];
+        this.format = attrs["format"];
+        this.translation_year = attrs["translation_year"];
+    }
+    render() {
+        switch (this.format) {
+            case "slash":
+            case "slash_colon":
+                return `/${this.code ?? ""}`;
+            case "paren_year":
+                return ` (${this.code}-${this.translation_year})`;
+            default:
+                return `(${this.code ?? ""})`;
+        }
+    }
+    toWire() {
+        return {
+            code: this.code,
+            format: this.format,
+            ...(this.translation_year !== undefined ? { translation_year: this.translation_year } : {}),
+        };
+    }
+}
+export class CieIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, {
+        style: { type: "string", default: "current" },
+    });
+    constructor(attrs = {}) {
+        super(attrs);
+        // Materialize the default the way lutaml does (runtime readers see
+        // "current" for an undated identifier; toHash still drops it).
+        if (this["style"] === undefined) {
+            this["style"] = "current";
+        }
+    }
+    dateSepChar() {
+        if (this.style === "legacy")
+            return "-";
+        if (this.style === "slash")
+            return "/";
+        return ":";
+    }
+    codeString() {
+        const self = this;
+        const number = self["number"];
+        if (number === undefined)
+            return undefined;
+        const part = self["part"];
+        const iteration = self["iteration"];
+        const partSeparator = self["part_separator"];
+        let result = number;
+        if (part !== undefined && iteration !== undefined) {
+            result += `/${part}.${iteration}`;
+        }
+        else if (iteration !== undefined) {
+            result += `.${iteration}`;
+        }
+        else if (part !== undefined) {
+            const separator = partSeparator === "slash" ? "/" : partSeparator === "dash" ? "-" : this.style === "current" ? "-" : "/";
+            result += `${separator}${part}`;
+        }
+        return result;
+    }
+}
+export class CieSingleIdentifier extends CieIdentifier {
+    static attributes = extendAttributes(CieIdentifier, {
+        publisher: { type: "string", default: "CIE" },
+        year: { type: "string" },
+    });
+}
+const CODE_ATTRS = {
+    number: { type: "string" },
+    part: { type: "string" },
+    iteration: { type: "string" },
+    part_separator: { type: "string" },
+};
+// ---------------------------------------------------------------------------
+// URN generation (lib/pubid/cie/urn_generator.rb).
+// ---------------------------------------------------------------------------
+export class CieUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const parts = ["urn", "cie"];
+        const special = this.specialIdentifierTypeComponent();
+        if (special !== undefined)
+            parts.push(special);
+        if (this.maybeAttr("s_prefix") === true)
+            parts.push("s");
+        parts.push(this.publisherComponent());
+        // Only the CodeAttributes classes carry a code_string (Conference,
+        // Proceedings, Bundle and the supplements deliberately do not).
+        if (id instanceof CieStandard ||
+            id instanceof CieJointPublished ||
+            id instanceof CieDualPublished ||
+            id instanceof CieIdentical) {
+            const codeString = id.codeString();
+            if (codeString !== undefined)
+                parts.push(codeString);
+        }
+        const year = this.maybeAttr("year");
+        if (year !== undefined)
+            parts.push(String(year));
+        const language = this.maybeAttr("language");
+        if (language instanceof CieLanguage) {
+            if (language.code !== undefined) {
+                parts.push(language.code.toLowerCase());
+                if (language.format !== undefined)
+                    parts.push(language.format.toLowerCase());
+            }
+            else {
+                parts.push(language.render().toLowerCase());
+            }
+        }
+        const stage = this.maybeAttr("stage");
+        if (stage !== undefined)
+            parts.push(String(stage).toLowerCase());
+        // style is the sole separator field; record it for dated identifiers.
+        if (year !== undefined)
+            parts.push(`sep.${this.maybeAttr("style")}`);
+        const iecIdentifier = this.maybeAttr("iec_identifier");
+        if (iecIdentifier !== undefined)
+            parts.push(`iec.${String(iecIdentifier)}`);
+        const isoReference = this.maybeAttr("iso_reference");
+        if (isoReference !== undefined)
+            parts.push(`iso.${String(isoReference)}`);
+        const docType = this.maybeAttr("doc_type");
+        if (docType !== undefined)
+            parts.push(`doctype.${String(docType)}`);
+        const ids = this.maybeAttr("ids");
+        if (Array.isArray(ids) && ids.length > 0) {
+            parts.push(`bundle.${id.toHuman()}`);
+        }
+        if (id instanceof CieTutorialBundle && id.number !== undefined) {
+            parts.push(`tut-bundle.${id.number}`);
+        }
+        return parts.join(":");
+    }
+    /** Base#maybe: reads a DECLARED attribute only. */
+    maybeAttr(name) {
+        const attributes = this.identifier.constructor.attributes;
+        if (attributes === undefined || !(name in attributes))
+            return undefined;
+        return this.identifier[name];
+    }
+    specialIdentifierTypeComponent() {
+        const name = this.identifier.constructor.polymorphicName;
+        // Mirrors the Ruby class-name regex order: /Bundle$/ also claims
+        // TutorialBundle, so the /TutorialBundle/ arm is unreachable.
+        if (name.endsWith("dual-published"))
+            return "dual-pub";
+        if (name.endsWith("identical"))
+            return "identical";
+        if (name.endsWith("joint-published"))
+            return "joint-pub";
+        if (name.endsWith("bundle"))
+            return "bundle";
+        return undefined;
+    }
+    publisherComponent() {
+        let pub = "cie";
+        const publisher = this.maybeAttr("publisher");
+        if (publisher !== undefined)
+            pub = String(publisher).toLowerCase();
+        const copublisher = this.maybeAttr("copublisher");
+        if (copublisher !== undefined) {
+            pub = `${pub}-${String(copublisher).toLowerCase()}`;
+        }
+        else {
+            const copubs = this.maybeAttr("copublishers");
+            if (Array.isArray(copubs) && copubs.length > 0) {
+                pub = `${pub}-${copubs.join("-").toLowerCase()}`;
+            }
+        }
+        return pub;
+    }
+}
+function attachUrn(klass) {
+    klass["urnGenerator"] = CieUrnGenerator;
+}
+// ---------------------------------------------------------------------------
+// The concrete classes.
+// ---------------------------------------------------------------------------
+export class CieStandard extends CieSingleIdentifier {
+    static polymorphicName = "pubid:cie:standard";
+    static attributes = extendAttributes(CieSingleIdentifier, {
+        ...CODE_ATTRS,
+        s_prefix: { type: "boolean", default: false },
+        d_prefix: { type: "boolean", default: false },
+        language: { type: CieLanguage },
+        stage: { type: "string" },
+    });
+    render() {
+        const parts = ["CIE"];
+        if (this.stage !== undefined)
+            parts.push(this.stage);
+        if (this.d_prefix === true) {
+            parts.push(`D${this.codeString() ?? ""}`);
+        }
+        else {
+            if (this.s_prefix === true)
+                parts.push("S");
+            if (this.number !== undefined)
+                parts.push(this.codeString() ?? "");
+        }
+        let result = parts.join(" ");
+        if (this.language?.format === "slash") {
+            result += `/${this.language.code}`;
+        }
+        if (this.language?.format === "slash_colon") {
+            return result + `/${this.language.code}:${this.year}`;
+        }
+        if (this.year !== undefined && this.style === "slash") {
+            return result + `/${this.year}`;
+        }
+        if (this.year !== undefined) {
+            result += `${this.dateSepChar()}${this.year}`;
+        }
+        if (this.language !== undefined &&
+            this.language.format !== "slash" &&
+            this.language.format !== "slash_colon") {
+            result += this.language.render();
+        }
+        return result;
+    }
+}
+registerType(CieStandard);
+attachUrn(CieStandard);
+export class CieJointPublished extends CieSingleIdentifier {
+    static polymorphicName = "pubid:cie:joint-published";
+    static attributes = extendAttributes(CieSingleIdentifier, {
+        ...CODE_ATTRS,
+        copublisher: { type: "string" },
+        language: { type: CieLanguage },
+        doc_type: { type: "string" },
+        stage: { type: "string" },
+    });
+    render() {
+        const parts = ["CIE", this.copublisher ?? ""];
+        if (this.doc_type !== undefined)
+            parts.push(this.doc_type);
+        if (this.stage !== undefined)
+            parts.push(this.stage);
+        if (this.number !== undefined) {
+            let codeStr = this.codeString() ?? "";
+            if (this.copublisher === "IEC" && this.part !== undefined) {
+                codeStr = `${this.number}.${this.part}`;
+            }
+            parts.push(codeStr);
+        }
+        let result = parts.join(" ");
+        if (this.year !== undefined)
+            result += `${this.dateSepChar()}${this.year}`;
+        if (this.language !== undefined)
+            result += this.language.render();
+        return result;
+    }
+}
+registerType(CieJointPublished);
+attachUrn(CieJointPublished);
+export class CieDualPublished extends CieSingleIdentifier {
+    static polymorphicName = "pubid:cie:dual-published";
+    static attributes = extendAttributes(CieSingleIdentifier, {
+        ...CODE_ATTRS,
+        s_prefix: { type: "boolean", default: false },
+        iec_identifier: { type: "string" },
+    });
+    render() {
+        const parts = ["CIE"];
+        if (this.s_prefix === true)
+            parts.push("S");
+        if (this.number !== undefined)
+            parts.push(this.codeString() ?? "");
+        let result = parts.join(" ");
+        if (this.year !== undefined)
+            result += `${this.dateSepChar()}${this.year}`;
+        if (this.iec_identifier !== undefined)
+            result += `/IEC ${this.iec_identifier}`;
+        return result;
+    }
+}
+registerType(CieDualPublished);
+attachUrn(CieDualPublished);
+export class CieIdentical extends CieSingleIdentifier {
+    static polymorphicName = "pubid:cie:identical";
+    static attributes = extendAttributes(CieSingleIdentifier, {
+        ...CODE_ATTRS,
+        s_prefix: { type: "boolean", default: false },
+        language: { type: CieLanguage },
+        iso_reference: { type: "string" },
+    });
+    render() {
+        const parts = ["CIE"];
+        if (this.s_prefix === true)
+            parts.push("S");
+        if (this.number !== undefined)
+            parts.push(this.codeString() ?? "");
+        let result = parts.join(" ");
+        if (this.language !== undefined &&
+            (this.language.format === "slash_colon" ||
+                (this.language.format === "slash" && this.year !== undefined && this.style !== "slash"))) {
+            result +=
+                this.language.format === "slash_colon"
+                    ? `/${this.language.code}:${this.year}`
+                    : `/${this.language.code}${this.year}`;
+        }
+        else if (this.language?.format === "slash") {
+            result += `/${this.language.code}`;
+        }
+        else if (this.year !== undefined && this.style === "slash") {
+            result += `/${this.year}`;
+        }
+        else if (this.year !== undefined) {
+            result += `${this.dateSepChar()}${this.year}`;
+        }
+        if (this.language !== undefined &&
+            this.language.format !== "slash" &&
+            this.language.format !== "slash_colon") {
+            result += this.language.render();
+        }
+        if (this.iso_reference !== undefined)
+            result += ` (ISO ${this.iso_reference})`;
+        return result;
+    }
+}
+registerType(CieIdentical);
+attachUrn(CieIdentical);
+export class CieConference extends CieSingleIdentifier {
+    static polymorphicName = "pubid:cie:conference";
+    static attributes = extendAttributes(CieSingleIdentifier, {
+        number: { type: "string" },
+        amendment_number: { type: "string" },
+        variant: { type: "string" },
+    });
+    render() {
+        let result = `CIE x${this.number ?? ""}`;
+        if (this.year !== undefined)
+            result += `${this.dateSepChar()}${this.year}`;
+        if (this.amendment_number !== undefined)
+            result += ` Amendment ${this.amendment_number}`;
+        if (this.variant !== undefined)
+            result += `/${this.variant}`;
+        return result;
+    }
+}
+registerType(CieConference);
+attachUrn(CieConference);
+export class CieProceedings extends CieSingleIdentifier {
+    static polymorphicName = "pubid:cie:proceedings";
+    static attributes = extendAttributes(CieSingleIdentifier, {
+        number: { type: "string" },
+        conference: { type: "string" },
+        page: { type: "string" },
+    });
+    render() {
+        return this.conference !== undefined
+            ? `CIE x${this.conference}-${this.number}`
+            : `CIE ${this.number} ${this.page}`;
+    }
+}
+registerType(CieProceedings);
+attachUrn(CieProceedings);
+export class CieTutorialBundle extends CieSingleIdentifier {
+    static polymorphicName = "pubid:cie:tutorial-bundle";
+    static attributes = extendAttributes(CieSingleIdentifier, {
+        number: { type: "string" },
+    });
+    render() {
+        return `CIE Tutorials Bundle ${this.number ?? ""}`;
+    }
+}
+registerType(CieTutorialBundle);
+attachUrn(CieTutorialBundle);
+// --- Supplement seam (SupplementIdentifier) ---------------------------------
+export class CieSupplementIdentifier extends CieIdentifier {
+    static attributes = extendAttributes(CieIdentifier, {
+        base: { type: CieIdentifier },
+        number: { type: "string" },
+    });
+}
+export class CieSupplement extends CieSupplementIdentifier {
+    static polymorphicName = "pubid:cie:supplement";
+    static attributes = extendAttributes(CieSupplementIdentifier, {
+        part: { type: "string" },
+    });
+    render() {
+        const b = this.base;
+        const parts = ["CIE"];
+        if (b["stage"] !== undefined && b["stage"] !== null)
+            parts.push(String(b["stage"]));
+        let core = `${b["number"] ?? ""}-SP${this.number ?? ""}`;
+        if (this.part !== undefined)
+            core += `.${this.part}`;
+        parts.push(core);
+        let result = parts.join(" ");
+        const language = b["language"];
+        if (language?.format === "slash_colon") {
+            result += `/${language.code}`;
+        }
+        if (b["year"] !== undefined && b["year"] !== null)
+            result += `:${String(b["year"])}`;
+        return result;
+    }
+}
+registerType(CieSupplement);
+attachUrn(CieSupplement);
+export class CieCorrigendum extends CieSupplementIdentifier {
+    static polymorphicName = "pubid:cie:corrigendum";
+    static attributes = extendAttributes(CieSupplementIdentifier, {
+        year: { type: "string" },
+    });
+    render() {
+        return `${this.base?.toHuman()}/Cor${this.number}:${this.year}`;
+    }
+}
+registerType(CieCorrigendum);
+attachUrn(CieCorrigendum);
+export class CieBundle extends CieSingleIdentifier {
+    static polymorphicName = "pubid:cie:bundle";
+    static attributes = extendAttributes(CieSingleIdentifier, {
+        base: { type: CieIdentifier },
+        ids: { type: CieIdentifier, collection: true, initializeEmpty: true },
+    });
+    render() {
+        if (this.ids.length === 0)
+            return "";
+        return this.ids
+            .map((id, i) => {
+            const member = id["base"] !== undefined
+                ? id
+                : this.rebased(id);
+            const str = member.toHuman();
+            return i === 0 ? str : str.replace(/^CIE /, "");
+        })
+            .join(",");
+    }
+    rebased(id) {
+        const rec = id;
+        return new CieSupplement({
+            base: this.base,
+            number: rec["number"],
+            part: rec["part"],
+        });
+    }
+}
+registerType(CieBundle);
+attachUrn(CieBundle);

package/dist/flavors/csa/grammar.d.ts

@@ -0,0 +1,6 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const csaGrammar: Grammar;
+/** Parser#parse normalization (parser.rb): CONSOLIDATED, (R spacing, CEI. */
+export declare function normalizeCsa(input: string): string;
+/** The original publisher prefix the normalized input printed. */
+export declare function csaPublisherPrefix(normalized: string): string | undefined;