@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/bipm/index.js

@@ -0,0 +1,434 @@
+import { match, str } from "../../grammar/engine.js";
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * 1:1 port of lib/pubid/bipm/ — 90 corpus rows across six families:
+ * committee documents (REC/RES/DECN/ACT/DECL in short and long EN/FR
+ * forms), meetings (EN ordinals, FR <sup>e</sup> réunion), the
+ * Metrologia journal, the SI Brochure and its derived products, mises
+ * en pratique (incl. Rapport BIPM-YYYY/NN), and CC guides. Historic
+ * group names (CCDS) and two-letter language codes (EN/FR) normalize
+ * at parse time and never reach the hash.
+ */
+const GROUPS = [
+    "CIPM", "CGPM", "JCRB", "CCTF", "CCQM", "CCT", "CCL", "CCAUV",
+    "CCU", "CCM", "CCEM", "CCPR", "CCRI",
+];
+const GROUP_ALIASES = { CCDS: "CCTF" };
+const PARSEABLE_GROUPS = [...GROUPS, ...Object.keys(GROUP_ALIASES)];
+const TYPE_CODES = ["REC", "RES", "DECN", "ACT", "DECL"];
+const TYPE_NAME_EN = {
+    REC: "Recommendation", RES: "Resolution", DECN: "Decision",
+    ACT: "Action", DECL: "Statement",
+};
+const TYPE_NAME_FR = {
+    REC: "Recommandation", RES: "Résolution", DECN: "Décision",
+    ACT: "Action", DECL: "Statement",
+};
+const TYPE_WORD_ALIASES = {
+    Declaration: "DECL", "Déclaration": "DECL",
+};
+const TYPE_WORD_TO_CODE = (() => {
+    const map = { ...TYPE_WORD_ALIASES };
+    for (const code of TYPE_CODES) {
+        map[code] = code;
+        map[TYPE_NAME_EN[code]] = code;
+        map[TYPE_NAME_FR[code]] = code;
+    }
+    return map;
+})();
+const LANGUAGE_ALIASES = { EN: "E", FR: "F" };
+/** Longest-first literal alternation, so "CCTF" beats "CCT". */
+function alternation(tokens) {
+    const sorted = [...tokens].sort((a, b) => b.length - a.length);
+    return sorted.map((t) => str(t)).reduce((a, b) => a.or(b));
+}
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    const space = str(" ");
+    const digits = match("[0-9]").repeat(1, Infinity);
+    const alnum = match("[0-9A-Za-z]").repeat(1, Infinity);
+    rule("number", () => digits.then(str("-").then(digits).repeat(0, Infinity)).as("number"));
+    rule("year", () => match("[0-9]").repeat(4, 4).as("year"));
+    // Two-letter consumer codes first, so "EN" is never a bare "E".
+    const lang = () => alternation(["EN", "FR", "E", "F"]).as("language");
+    rule("year_paren", () => str("(").then(rules["year"], str(", ").then(lang()).maybe(), str(")")));
+    rule("year_paren_nolang", () => str("(").then(rules["year"], str(")")));
+    rule("group", () => alternation(PARSEABLE_GROUPS).as("group"));
+    rule("type_abbrev", () => alternation([...TYPE_CODES]).as("type_word"));
+    rule("type_name_en", () => alternation([...new Set([...Object.values(TYPE_NAME_EN), "Declaration"])]).as("type_word"));
+    rule("type_name_fr", () => alternation([...new Set([...Object.values(TYPE_NAME_FR), "Déclaration"])]).as("type_word"));
+    const connective = () => str("de la").or(str("du"));
+    const ordinal = () => str("st").or(str("nd"), str("rd"), str("th"));
+    const meetingWordFr = () => str("Réunion").or(str("réunion"));
+    // The trailing date is optional so "CCTF REC 2" parses date-less.
+    rule("committee_short", () => rules["group"]
+        .then(space, rules["type_abbrev"], space.then(rules["number"]).maybe(), space.then(rules["year_paren"]).maybe())
+        .as("committee_short"));
+    rule("committee_long_en", () => rules["group"]
+        .then(space, rules["type_name_en"], space.then(rules["number"]).maybe(), space.then(rules["year_paren_nolang"]).maybe())
+        .as("committee_long_en"));
+    rule("committee_long_fr", () => rules["type_name_fr"]
+        .then(space.then(rules["number"]).maybe(), space, connective(), space, rules["group"], space.then(rules["year_paren_nolang"]).maybe())
+        .as("committee_long_fr"));
+    // Loose consumer form: a French type name in group-leading order.
+    rule("committee_group_fr", () => rules["group"]
+        .then(space, rules["type_name_fr"], space.then(rules["number"]).maybe(), space.then(rules["year_paren_nolang"]).maybe())
+        .as("committee_long_fr"));
+    // Bare MRA form: group + number, no type word ("CIPM 2005-06").
+    rule("committee_bare", () => rules["group"]
+        .then(space, rules["number"], space.then(rules["year_paren"]).maybe())
+        .as("committee_bare"));
+    rule("meeting_en", () => rules["group"]
+        .then(space, rules["number"], ordinal(), space, str("Meeting"), space.then(rules["year_paren"]).maybe())
+        .or(rules["group"].then(space, str("Meeting"), space, rules["number"], space.then(rules["year_paren"]).maybe()))
+        .as("meeting_en"));
+    rule("meeting_fr", () => rules["group"]
+        .then(space, rules["number"], str("<sup>e</sup>"), space, str("réunion"), space.then(rules["year_paren"]).maybe())
+        .or(rules["group"].then(space, rules["number"], str("e"), space, meetingWordFr(), space.then(rules["year_paren"]).maybe()), rules["group"].then(space, meetingWordFr(), space, rules["number"], space.then(rules["year_paren"]).maybe()))
+        .as("meeting_fr"));
+    rule("metrologia", () => str("Metrologia")
+        .then(space
+        .then(digits.as("volume"), space
+        .then(alnum.as("issue"), space.then(alnum.as("article")).maybe())
+        .maybe())
+        .maybe())
+        .as("metrologia"));
+    rule("edition", () => digits.then(str("e")).as("edition"));
+    rule("version", () => str("v").then(match("[0-9.]").repeat(1, Infinity)).as("version"));
+    rule("years", () => digits.then(str("/").then(digits).maybe()).as("years"));
+    rule("si_brochure", () => str("BIPM SI Brochure")
+        .or(str("SI Brochure"))
+        .then(space, str("sur le SI").then(space).maybe(), rules["edition"], space, rules["version"], space, str("("), rules["years"], str(", "), lang(), str(")"))
+        .as("si_brochure"));
+    rule("brochure_variant", () => str("Appendix")
+        .then(space, digits)
+        .or(str("Concise"), str("FAQ"))
+        .as("variant"));
+    rule("si_brochure_variant", () => str("BIPM SI Brochure")
+        .or(str("SI Brochure"))
+        .then(space, rules["brochure_variant"])
+        .as("si_brochure_variant"));
+    rule("si_brochure_section", () => str("BIPM SI Brochure")
+        .or(str("SI Brochure"))
+        .then(space.then(str("Part"), space, digits.as("part")).maybe())
+        .as("si_brochure_section"));
+    // Shared "Appendix N [Annex N] Part N[.M]" tail of MEPs and guides.
+    rule("appendix_part", () => str("Appendix").then(space, digits.as("appendix"), space.then(str("Annex"), space, digits.as("annex")).maybe(), space, str("Part"), space, digits.then(str(".").then(digits).maybe()).as("part")));
+    rule("mep_code", () => match("[0-9A-Za-z]").repeat(1, Infinity).as("mep_code"));
+    rule("report_code", () => str("BIPM-").then(digits, str("/"), digits).as("report_code"));
+    const mepBody = () => str("SI MEP").then(space, rules["mep_code"]).or(str("Rapport").then(space, rules["report_code"]));
+    rule("mep", () => str("BIPM")
+        .then(space, mepBody(), space, rules["appendix_part"])
+        .or(mepBody())
+        .as("mep"));
+    rule("guide_kind", () => str("MeP").or(str("RSI")).as("guide_kind"));
+    const guideBody = () => rules["group"].then(str("-GD-"), rules["guide_kind"], str("-"), digits.as("number"));
+    rule("guide", () => str("BIPM")
+        .then(space, guideBody(), space, rules["appendix_part"])
+        .or(guideBody())
+        .as("guide"));
+    rule("group_leading", () => rules["meeting_en"].or(rules["meeting_fr"], rules["committee_short"], rules["committee_long_en"], rules["committee_group_fr"], rules["committee_bare"]));
+    rule("identifier", () => rules["metrologia"].or(rules["si_brochure"], rules["si_brochure_variant"], rules["si_brochure_section"], rules["mep"], rules["guide"], rules["committee_long_fr"], rules["group_leading"]));
+    rule("root", () => rules["identifier"]);
+    return rules;
+}
+export const bipmGrammar = { rules: buildRules(), root: "root" };
+/** data/bipm/update_codes.yaml — full-line legacy spellings. */
+const UPDATE_CODES = {
+    "CIPM/2005-06(REV)": "CIPM 2005-06",
+    "CIPM 2005-06(REV)": "CIPM 2005-06",
+};
+// ---------------------------------------------------------------------------
+// Model
+// ---------------------------------------------------------------------------
+const BIPM_ATTRS = {
+    group: { type: "string" },
+    type_code: { type: "string" },
+    number: { type: "string" },
+    year: { type: "integer" },
+    language: { type: "string" },
+    form: { type: "string", default: "short" },
+    issue: { type: "string" },
+    article: { type: "string" },
+    edition: { type: "string" },
+    version: { type: "string" },
+    years: { type: "string" },
+    variant: { type: "string" },
+    mep_code: { type: "string" },
+    report_code: { type: "string" },
+    guide_kind: { type: "string" },
+    appendix: { type: "string" },
+    annex: { type: "string" },
+    part: { type: "string" },
+};
+const BIPM_MAPPINGS = keyValue({ wire: "group", to: "group" }, { wire: "type_code", to: "type_code" }, { wire: "number", to: "number" }, { wire: "year", to: "year" }, { wire: "language", to: "language" }, { wire: "form", to: "form" }, { wire: "issue", to: "issue" }, { wire: "article", to: "article" }, { wire: "edition", to: "edition" }, { wire: "version", to: "version" }, { wire: "years", to: "years" }, { wire: "variant", to: "variant" }, { wire: "mep_code", to: "mep_code" }, { wire: "report_code", to: "report_code" }, { wire: "guide_kind", to: "guide_kind" }, { wire: "appendix", to: "appendix" }, { wire: "annex", to: "annex" }, { wire: "part", to: "part" });
+/** Naive source-data ordinals: 1→st, 2→nd, 3→rd, else→th (11→"11st"). */
+function ordinalSuffix(number) {
+    const first = number.split("-")[0] ?? "";
+    const last = first.at(-1);
+    if (last === "1")
+        return "st";
+    if (last === "2")
+        return "nd";
+    if (last === "3")
+        return "rd";
+    return "th";
+}
+function frenchConnective(group) {
+    return group === "CGPM" ? "de la" : "du";
+}
+export class BipmIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, BIPM_ATTRS);
+    static mappings = BIPM_MAPPINGS;
+    numberSegment() {
+        return this.number === undefined ? "" : ` ${this.number}`;
+    }
+    yearSegment(lang = "") {
+        return this.year === undefined ? "" : ` (${this.year}${lang})`;
+    }
+    fullContentWrap(body) {
+        if (this.part === undefined)
+            return body;
+        const annex = this.annex === undefined ? "" : ` Annex ${this.annex}`;
+        return `BIPM ${body} Appendix ${this.appendix}${annex} Part ${this.part}`;
+    }
+}
+class BipmUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        if (id instanceof BipmCommitteeDocument) {
+            const parts = [
+                "urn", "bipm", id.group?.toLowerCase() ?? "",
+                id.type_code?.toLowerCase() ?? "", id.number ?? "",
+            ];
+            if (id.year !== undefined)
+                parts.push(String(id.year));
+            return parts.join(":");
+        }
+        if (id instanceof BipmMeeting) {
+            const parts = ["urn", "bipm", id.group?.toLowerCase() ?? "", "meeting", id.number ?? ""];
+            if (id.year !== undefined)
+                parts.push(String(id.year));
+            return parts.join(":");
+        }
+        if (id instanceof BipmMetrologiaArticle) {
+            const parts = ["urn", "bipm", "metrologia", String(id.volume())];
+            if (id.issue !== undefined)
+                parts.push(id.issue);
+            if (id.article !== undefined)
+                parts.push(id.article);
+            return parts.join(":");
+        }
+        if (id instanceof BipmSiBrochure) {
+            return [
+                "urn", "bipm", "si-brochure", id.language?.toLowerCase() ?? "",
+                id.edition ?? "", id.version ?? "", id.years ?? "",
+            ].join(":");
+        }
+        throw new ParseFailed(`Cannot build URN for BIPM identifier: ${id.constructor.polymorphicName}`, 0);
+    }
+}
+class BipmCommitteeDocument extends BipmIdentifier {
+    static polymorphicName = "pubid:bipm:committee-document";
+    static urnGenerator = BipmUrnGenerator;
+    render() {
+        if (this.form === "long") {
+            if (this.language === "F") {
+                const name = TYPE_NAME_FR[this.type_code ?? ""] ?? "";
+                return `${name}${this.numberSegment()} ${frenchConnective(this.group ?? "")} ${this.group}${this.yearSegment()}`;
+            }
+            const name = TYPE_NAME_EN[this.type_code ?? ""] ?? "";
+            return `${this.group ?? ""} ${name}${this.numberSegment()}${this.yearSegment()}`;
+        }
+        const lang = this.language === undefined ? "" : `, ${this.language}`;
+        const type = this.type_code === undefined ? "" : ` ${this.type_code}`;
+        return `${this.group ?? ""}${type}${this.numberSegment()}${this.yearSegment(lang)}`;
+    }
+}
+registerType(BipmCommitteeDocument);
+class BipmMeeting extends BipmIdentifier {
+    static polymorphicName = "pubid:bipm:meeting";
+    static urnGenerator = BipmUrnGenerator;
+    render() {
+        if (this.language === "F") {
+            return `${this.group ?? ""} ${this.number ?? ""}<sup>e</sup> réunion${this.yearSegment()}`;
+        }
+        return `${this.group ?? ""} ${this.number ?? ""}${ordinalSuffix(this.number ?? "")} Meeting${this.yearSegment()}`;
+    }
+}
+registerType(BipmMeeting);
+class BipmMetrologiaArticle extends BipmIdentifier {
+    static polymorphicName = "pubid:bipm:metrologia-article";
+    static urnGenerator = BipmUrnGenerator;
+    /** The volume IS the index key — derived from `number`, never stored. */
+    volume() {
+        return this.number === undefined ? undefined : Number(this.number);
+    }
+    render() {
+        let result = "Metrologia";
+        if (this.volume() !== undefined)
+            result += ` ${this.volume()}`;
+        if (this.issue !== undefined)
+            result += ` ${this.issue}`;
+        if (this.article !== undefined)
+            result += ` ${this.article}`;
+        return result;
+    }
+}
+registerType(BipmMetrologiaArticle);
+class BipmSiBrochure extends BipmIdentifier {
+    static polymorphicName = "pubid:bipm:si-brochure";
+    static urnGenerator = BipmUrnGenerator;
+    render() {
+        if (this.variant !== undefined)
+            return `BIPM SI Brochure ${this.variant}`;
+        if (this.edition === undefined) {
+            const part = this.part === undefined ? "" : ` Part ${this.part}`;
+            return `BIPM SI Brochure${part}`;
+        }
+        const phrase = this.language === "F" ? "sur le SI " : "";
+        const lang = this.language === undefined ? "" : `, ${this.language}`;
+        return `BIPM SI Brochure ${phrase}${this.edition} ${this.version} (${this.years}${lang})`;
+    }
+}
+registerType(BipmSiBrochure);
+class BipmMep extends BipmIdentifier {
+    static polymorphicName = "pubid:bipm:mep";
+    static urnGenerator = BipmUrnGenerator;
+    render() {
+        const body = this.report_code !== undefined
+            ? `Rapport ${this.report_code}`
+            : `SI MEP ${this.mep_code}`;
+        return this.fullContentWrap(body);
+    }
+}
+registerType(BipmMep);
+class BipmGuide extends BipmIdentifier {
+    static polymorphicName = "pubid:bipm:guide";
+    static urnGenerator = BipmUrnGenerator;
+    render() {
+        return this.fullContentWrap(`${this.group}-GD-${this.guide_kind}-${this.number}`);
+    }
+}
+registerType(BipmGuide);
+// ---------------------------------------------------------------------------
+// Builder
+// ---------------------------------------------------------------------------
+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;
+}
+const normalizeGroup = (token) => GROUP_ALIASES[token] ?? token;
+const normalizeLanguage = (token) => token === undefined ? undefined : LANGUAGE_ALIASES[token] ?? token;
+class BipmBuilder {
+    build(data) {
+        const tree = flatten(data);
+        const node = (key) => {
+            const v = tree[key];
+            return isObj(v) ? flatten(v) : {};
+        };
+        if (tree["committee_short"] !== undefined)
+            return this.buildCommittee(node("committee_short"), "short");
+        if (tree["committee_long_en"] !== undefined)
+            return this.buildCommittee(node("committee_long_en"), "long", "E");
+        if (tree["committee_bare"] !== undefined)
+            return this.buildCommittee(node("committee_bare"), "short");
+        if (tree["committee_long_fr"] !== undefined)
+            return this.buildCommittee(node("committee_long_fr"), "long", "F");
+        if (tree["meeting_en"] !== undefined)
+            return this.buildMeeting(node("meeting_en"));
+        if (tree["meeting_fr"] !== undefined)
+            return this.buildMeeting(node("meeting_fr"), "F");
+        if (tree["metrologia"] !== undefined) {
+            const n = node("metrologia");
+            return new BipmMetrologiaArticle({
+                number: s(n["volume"]),
+                issue: s(n["issue"]),
+                article: s(n["article"]),
+            });
+        }
+        if (tree["si_brochure"] !== undefined) {
+            const n = node("si_brochure");
+            const edition = s(n["edition"]);
+            return new BipmSiBrochure({
+                number: edition,
+                edition,
+                version: s(n["version"]),
+                years: s(n["years"]),
+                language: normalizeLanguage(s(n["language"])),
+            });
+        }
+        if (tree["si_brochure_variant"] !== undefined) {
+            const variant = s(node("si_brochure_variant")["variant"]);
+            return new BipmSiBrochure({ number: variant, variant });
+        }
+        if (tree["si_brochure_section"] !== undefined) {
+            const n = node("si_brochure_section");
+            return new BipmSiBrochure({ part: s(n["part"]) });
+        }
+        if (tree["mep"] !== undefined) {
+            const n = node("mep");
+            const mepCode = s(n["mep_code"]);
+            const reportCode = s(n["report_code"]);
+            return new BipmMep({
+                number: mepCode ?? reportCode,
+                mep_code: mepCode,
+                report_code: reportCode,
+                appendix: s(n["appendix"]),
+                annex: s(n["annex"]),
+                part: s(n["part"]),
+            });
+        }
+        if (tree["guide"] !== undefined) {
+            const n = node("guide");
+            return new BipmGuide({
+                group: normalizeGroup(s(n["group"])),
+                guide_kind: s(n["guide_kind"]),
+                number: s(n["number"]),
+                appendix: s(n["appendix"]),
+                part: s(n["part"]),
+            });
+        }
+        throw new ParseFailed(`Unrecognized BIPM parse tree: ${JSON.stringify(tree)}`, 0);
+    }
+    buildCommittee(n, form, language) {
+        const year = s(n["year"]);
+        return new BipmCommitteeDocument({
+            group: normalizeGroup(s(n["group"])),
+            type_code: TYPE_WORD_TO_CODE[s(n["type_word"]) ?? ""],
+            number: s(n["number"]),
+            ...(year !== undefined ? { year: Number(year) } : {}),
+            language: normalizeLanguage(language ?? s(n["language"])),
+            form,
+        });
+    }
+    buildMeeting(n, language) {
+        const year = s(n["year"]);
+        return new BipmMeeting({
+            group: normalizeGroup(s(n["group"])),
+            number: s(n["number"]),
+            ...(year !== undefined ? { year: Number(year) } : {}),
+            language: normalizeLanguage(language ?? s(n["language"])),
+        });
+    }
+}
+export function bipmGrammarImplementation() {
+    const builder = new BipmBuilder();
+    return {
+        parse(input) {
+            const normalized = UPDATE_CODES[input] ?? input;
+            const tree = parseGrammar(bipmGrammar, normalized);
+            if (typeof tree !== "object" || tree === null) {
+                throw new ParseFailed("BIPM: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const bsiGrammar: Grammar;
+/** Parser.parse normalization: "BSI " → "BS " except "BSI Flex". */
+export declare function preprocessBsi(input: string): string;