@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/cie/index.js

@@ -0,0 +1,311 @@
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { cieGrammar, preprocessCie } from "./grammar.js";
+import { CieBundle, CieConference, CieCorrigendum, CieDualPublished, CieIdentical, CieJointPublished, CieLanguage, CieProceedings, CieStandard, CieSupplement, CieTutorialBundle, } from "./model.js";
+/**
+ * Port of lib/pubid/cie/builder.rb — class dispatch, attribute
+ * extraction with era/style derivation, and the bundle/corrigendum/
+ * supplement wrappers.
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const s = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    const str = Array.isArray(v) ? v.join("") : String(v);
+    const trimmed = str.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+function langFromGroup(group) {
+    const parenYear = group["language_paren_year"];
+    if (isObj(parenYear)) {
+        const d = flatten(parenYear);
+        return new CieLanguage({
+            code: s(d["lang_code"]),
+            format: "paren_year",
+            ...(s(d["trans_year"]) !== undefined ? { translation_year: s(d["trans_year"]) } : {}),
+        });
+    }
+    const paren = group["language_paren"];
+    if (isObj(paren)) {
+        const d = flatten(paren);
+        return new CieLanguage({ code: s(d["lang_code"]), format: "paren" });
+    }
+    const slashLang = group["language_slash"];
+    if (isObj(slashLang)) {
+        const d = flatten(slashLang);
+        return new CieLanguage({ code: s(d["lang_code"]), format: "slash" });
+    }
+    return undefined;
+}
+function detectStyleFallback(tree) {
+    const yearDirect = s(tree["year"]);
+    if (yearDirect !== undefined)
+        return Number(yearDirect) <= 2001 ? "legacy" : "current";
+    for (const key of ["current_date", "legacy_date"]) {
+        if (isObj(tree[key])) {
+            const year = s(flatten(tree[key])["year"]);
+            if (year !== undefined)
+                return Number(year) <= 2001 ? "legacy" : "current";
+        }
+    }
+    return "current";
+}
+/** Builder#extract_attributes — one hash for every type, filtered later. */
+function extractAttributes(tree) {
+    const attributes = {};
+    let yearValue;
+    let dateSep;
+    if (tree["date_then_lang"] !== undefined && isObj(tree["date_then_lang"])) {
+        const dateData = flatten(tree["date_then_lang"]);
+        if (isObj(dateData["current_date"])) {
+            yearValue = s(flatten(dateData["current_date"])["year"]);
+            dateSep = "colon";
+        }
+        else if (isObj(dateData["legacy_date"])) {
+            yearValue = s(flatten(dateData["legacy_date"])["year"]);
+            dateSep = "dash";
+        }
+        const lang = langFromGroup(dateData);
+        if (lang !== undefined)
+            attributes["language"] = lang;
+    }
+    else if (tree["lang_before"] !== undefined && isObj(tree["lang_before"])) {
+        const langData = flatten(tree["lang_before"]);
+        const lang = langFromGroup(langData);
+        if (lang !== undefined)
+            attributes["language"] = lang;
+        if (isObj(langData["current_date"])) {
+            yearValue = s(flatten(langData["current_date"])["year"]);
+            dateSep = "colon";
+        }
+        else if (isObj(langData["legacy_date"])) {
+            yearValue = s(flatten(langData["legacy_date"])["year"]);
+            dateSep = "dash";
+        }
+    }
+    else if (isObj(tree["current_date"])) {
+        yearValue = s(flatten(tree["current_date"])["year"]);
+        dateSep = "colon";
+    }
+    else if (isObj(tree["legacy_date"])) {
+        yearValue = s(flatten(tree["legacy_date"])["year"]);
+        dateSep = "dash";
+    }
+    else if (tree["year"] !== undefined) {
+        yearValue = s(tree["year"]);
+        if (tree["copublisher"] !== undefined) {
+            // IEC joins the year with a dash, ISO with a colon.
+            dateSep = s(tree["copublisher"]) === "IEC" ? "dash" : "colon";
+        }
+        else if (tree["trailing_lang"] !== undefined) {
+            dateSep = "dash";
+        }
+        else {
+            dateSep = Number(yearValue) <= 2001 ? "dash" : "colon";
+        }
+    }
+    else if (tree["slash_year"] !== undefined) {
+        yearValue = s(tree["slash_year"]);
+        dateSep = "slash";
+    }
+    attributes["style"] =
+        dateSep === "colon" ? "current" : dateSep === "dash" ? "legacy" : dateSep === "slash" ? "slash" : detectStyleFallback(tree);
+    if (yearValue !== undefined)
+        attributes["year"] = yearValue;
+    if (tree["number"] !== undefined) {
+        attributes["number"] = s(tree["number"]);
+        if (tree["part"] !== undefined)
+            attributes["part"] = s(tree["part"]);
+        if (tree["iteration"] !== undefined)
+            attributes["iteration"] = s(tree["iteration"]);
+        if (tree["slash_sep"] !== undefined)
+            attributes["part_separator"] = "slash";
+        else if (tree["dash_sep"] !== undefined)
+            attributes["part_separator"] = "dash";
+    }
+    if (tree["conf_number"] !== undefined)
+        attributes["number"] = s(tree["conf_number"]);
+    // The paper itself is the document: its identity is the flat number.
+    if (tree["paper_code"] !== undefined) {
+        attributes["number"] = `${s(tree["paper_code"]) ?? ""}${s(tree["paper_number"]) ?? ""}`;
+        if (tree["conf_number"] !== undefined)
+            attributes["conference"] = s(tree["conf_number"]);
+    }
+    if (tree["page_range"] !== undefined)
+        attributes["page"] = s(tree["page_range"]);
+    if (tree["variant"] !== undefined)
+        attributes["variant"] = s(tree["variant"]);
+    if (tree["d_prefix"] !== undefined)
+        attributes["d_prefix"] = true;
+    const directLang = langFromGroup(tree);
+    if (directLang !== undefined) {
+        attributes["language"] = directLang;
+    }
+    else if (tree["lang_code"] !== undefined) {
+        // Direct /E:YYYY (or preprocessed /EYYYY) form.
+        attributes["language"] = new CieLanguage({
+            code: s(tree["lang_code"]),
+            format: tree["lang_colon"] !== undefined ? "slash_colon" : "slash",
+        });
+    }
+    attributes["s_prefix"] = tree["s_prefix"] !== undefined && tree["s_prefix"] !== null;
+    if (tree["stage"] !== undefined)
+        attributes["stage"] = s(tree["stage"]);
+    if (tree["doc_type"] !== undefined)
+        attributes["doc_type"] = s(tree["doc_type"]);
+    if (tree["copublisher"] !== undefined)
+        attributes["copublisher"] = s(tree["copublisher"]);
+    if (tree["iso_reference"] !== undefined)
+        attributes["iso_reference"] = s(tree["iso_reference"]);
+    if (tree["iec_identifier"] !== undefined)
+        attributes["iec_identifier"] = s(tree["iec_identifier"]);
+    if (tree["supplement_number"] !== undefined) {
+        attributes["supplement_number"] = s(tree["supplement_number"]);
+        if (tree["supplement_part"] !== undefined)
+            attributes["supplement_part"] = s(tree["supplement_part"]);
+        if (tree["base_number"] !== undefined)
+            attributes["base_number"] = s(tree["base_number"]);
+    }
+    if (tree["cor_number"] !== undefined) {
+        attributes["cor_number"] = s(tree["cor_number"]);
+        attributes["cor_year"] = s(tree["cor_year"]);
+        attributes["base_number"] = s(tree["base_number"]);
+        attributes["base_year"] = s(tree["base_year"]);
+        if (tree["base_supplement"] !== undefined)
+            attributes["base_supplement"] = s(tree["base_supplement"]);
+        if (tree["base_supplement_part"] !== undefined) {
+            attributes["base_supplement_part"] = s(tree["base_supplement_part"]);
+        }
+    }
+    if (tree["amd_number"] !== undefined)
+        attributes["amendment_number"] = s(tree["amd_number"]);
+    if (tree["bundle_number"] !== undefined)
+        attributes["number"] = s(tree["bundle_number"]);
+    // The trailing "(RU-2021)" of the legacy code-with-year form.
+    if (isObj(tree["trailing_lang"])) {
+        const lang = langFromGroup(flatten(tree["trailing_lang"]));
+        if (lang !== undefined)
+            attributes["language"] = lang;
+    }
+    return attributes;
+}
+class CieBuilder {
+    parse(input) {
+        const tree = parseGrammar(cieGrammar, preprocessCie(input));
+        if (typeof tree !== "object" || tree === null) {
+            throw new ParseFailed("CIE: unexpected parse tree", 0);
+        }
+        return this.build(tree, input);
+    }
+    build(data, originalString) {
+        const tree = flatten(data);
+        if (isObj(tree["trailing_lang"]) === false && tree["trailing_lang"] === "") {
+            // trailing_lang "" is the no-language marker; nothing to do here.
+        }
+        // Corrigendum and Supplement wrap a nested base.
+        if (tree["cor_number"] !== undefined)
+            return this.buildCorrigendum(tree);
+        if (tree["supplement_number"] !== undefined)
+            return this.buildSupplement(tree);
+        const attributes = extractAttributes(tree);
+        let klass;
+        if (tree["bundle_number"] !== undefined && tree["first_number"] === undefined) {
+            klass = CieTutorialBundle;
+        }
+        else if (tree["bundle_items"] !== undefined) {
+            klass = CieBundle;
+            Object.assign(attributes, this.buildBundle(originalString));
+        }
+        else if (tree["paper_code"] !== undefined) {
+            klass = CieProceedings;
+        }
+        else if (tree["conference"] !== undefined) {
+            klass = CieConference;
+        }
+        else if (tree["iec_identifier"] !== undefined) {
+            klass = CieDualPublished;
+        }
+        else if (tree["iso_reference"] !== undefined) {
+            klass = CieIdentical;
+        }
+        else if (tree["copublisher"] !== undefined) {
+            klass = CieJointPublished;
+        }
+        else {
+            klass = CieStandard;
+        }
+        // One attribute hash serves every type; keep only the keys the
+        // chosen class declares (the constructor-refusal mirror).
+        const declared = klass.attributes;
+        const filtered = {};
+        for (const [key, value] of Object.entries(attributes)) {
+            if (key in declared)
+                filtered[key] = value;
+        }
+        return new klass(filtered);
+    }
+    /** Parse each comma member, hoist the shared base onto the bundle. */
+    buildBundle(originalString) {
+        const members = originalString
+            .split(",")
+            .map((item, i) => this.parse(i === 0 ? item.trim() : `CIE ${item.trim()}`));
+        const bases = members.map((m) => m.base);
+        if (bases.some((b) => b === undefined))
+            return { ids: members };
+        const first = JSON.stringify(bases[0].toHash());
+        const shared = bases.every((b) => JSON.stringify(b.toHash()) === first) ? bases[0] : undefined;
+        if (shared === undefined)
+            return { ids: members };
+        return {
+            base: shared,
+            ids: members.map((m) => new CieSupplement({ number: m.number, part: m.part })),
+        };
+    }
+    buildSupplement(tree) {
+        const a = extractAttributes(tree);
+        const base = new CieStandard({
+            number: a["base_number"],
+            stage: a["stage"],
+            s_prefix: a["s_prefix"] ?? false,
+            language: a["language"],
+            year: a["year"],
+            // Supplements always use the colon style.
+            style: "current",
+        });
+        return new CieSupplement({
+            base,
+            number: a["supplement_number"],
+            part: a["supplement_part"],
+        });
+    }
+    buildCorrigendum(tree) {
+        const a = extractAttributes(tree);
+        const baseStd = new CieStandard({
+            number: a["base_number"],
+            year: a["base_year"],
+            style: "current",
+        });
+        const base = a["base_supplement"] !== undefined
+            ? new CieSupplement({
+                base: baseStd,
+                number: a["base_supplement"],
+                part: a["base_supplement_part"],
+            })
+            : baseStd;
+        return new CieCorrigendum({
+            base,
+            number: a["cor_number"],
+            year: a["cor_year"],
+        });
+    }
+}
+export function cieGrammarImplementation() {
+    const builder = new CieBuilder();
+    return {
+        parse(input) {
+            return builder.parse(input);
+        },
+    };
+}

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

@@ -0,0 +1,122 @@
+import { BaseIdentifier } from "../../model/identifier.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 declare class CieLanguage extends Component {
+    readonly code?: string | undefined;
+    readonly format?: string | undefined;
+    readonly translation_year?: string | undefined;
+    constructor(attrs: Record<string, unknown>);
+    render(): string;
+    toWire(): Record<string, unknown>;
+}
+export declare abstract class CieIdentifier extends BaseIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly style: string | undefined;
+    constructor(attrs?: Record<string, unknown>);
+    dateSepChar(): string;
+    codeString(): string | undefined;
+}
+export declare abstract class CieSingleIdentifier extends CieIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly year: string | undefined;
+}
+export declare class CieUrnGenerator extends BaseUrnGenerator<CieIdentifier> {
+    generate(): string;
+    /** Base#maybe: reads a DECLARED attribute only. */
+    private maybeAttr;
+    private specialIdentifierTypeComponent;
+    private publisherComponent;
+}
+export declare class CieStandard extends CieSingleIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly s_prefix: boolean | undefined;
+    readonly d_prefix: boolean | undefined;
+    readonly language: CieLanguage | undefined;
+    readonly stage: string | undefined;
+    readonly number: string | undefined;
+    render(): string;
+}
+export declare class CieJointPublished extends CieSingleIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly copublisher: string | undefined;
+    readonly language: CieLanguage | undefined;
+    readonly doc_type: string | undefined;
+    readonly stage: string | undefined;
+    readonly number: string | undefined;
+    readonly part: string | undefined;
+    render(): string;
+}
+export declare class CieDualPublished extends CieSingleIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly s_prefix: boolean | undefined;
+    readonly iec_identifier: string | undefined;
+    readonly number: string | undefined;
+    render(): string;
+}
+export declare class CieIdentical extends CieSingleIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly s_prefix: boolean | undefined;
+    readonly language: CieLanguage | undefined;
+    readonly iso_reference: string | undefined;
+    readonly number: string | undefined;
+    render(): string;
+}
+export declare class CieConference extends CieSingleIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly number: string | undefined;
+    readonly amendment_number: string | undefined;
+    readonly variant: string | undefined;
+    render(): string;
+}
+export declare class CieProceedings extends CieSingleIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly number: string | undefined;
+    readonly conference: string | undefined;
+    readonly page: string | undefined;
+    render(): string;
+}
+export declare class CieTutorialBundle extends CieSingleIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly number: string | undefined;
+    render(): string;
+}
+export declare abstract class CieSupplementIdentifier extends CieIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly base: CieIdentifier | undefined;
+    readonly number: string | undefined;
+}
+export declare class CieSupplement extends CieSupplementIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly part: string | undefined;
+    render(): string;
+}
+export declare class CieCorrigendum extends CieSupplementIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly year: string | undefined;
+    render(): string;
+}
+export declare class CieBundle extends CieSingleIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly base: CieIdentifier | undefined;
+    readonly ids: CieIdentifier[];
+    render(): string;
+    private rebased;
+}