@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/oiml/grammar.js

@@ -0,0 +1,206 @@
+import { match, ref, str, } from "../../grammar/engine.js";
+/**
+ * 1:1 port of lib/pubid/oiml/parser.rb (including CommonParseRules).
+ * Rule names match the Ruby rule names so the two files can be diffed
+ * side by side while porting.
+ */
+function buildRules() {
+    const rules = {};
+    const rule = (name, build) => {
+        rules[name] = build();
+    };
+    // --- CommonParseRules ---
+    rule("space", () => str(" "));
+    rule("space?", () => ref(rules, "space").maybe());
+    rule("digits", () => match("\\d").repeat(1));
+    rule("year", () => match("\\d").repeat(4, 4).as("year"));
+    rule("comma", () => str(", "));
+    rule("comma?", () => ref(rules, "comma").maybe());
+    rule("comma_space", () => ref(rules, "comma").or(ref(rules, "space")));
+    rule("dash", () => str("-"));
+    rule("dot", () => str("."));
+    rule("words_digits", () => match("[\\dA-Za-z]").repeat(1));
+    rule("words", () => match("[A-Za-z]").repeat(1));
+    rule("words?", () => ref(rules, "words").maybe());
+    rule("year_digits", () => str("19").or(str("20")).then(match("\\d").repeat(2, 2), ref(rules, "digits").absent()));
+    rule("month_digits", () => match("\\d").repeat(2, 2));
+    rule("day_digits", () => match("\\d").repeat(2, 2));
+    rule("originator", () => ref(rules, "organization")
+        .as("publisher")
+        .then(ref(rules, "space?")
+        .then(str("/"), ref(rules, "organization").as("copublisher"))
+        .repeat(0)));
+    rule("comma_month_year", () => ref(rules, "comma").then(ref(rules, "words").as("month"), str(" "), ref(rules, "year_digits").as("year")));
+    rule("year_month", () => ref(rules, "year_digits").then(ref(rules, "dash"), ref(rules, "month_digits")));
+    // organization: OIML's parser never uses it (publisher is the literal
+    // "OIML"); provide a minimal definition so refs resolve.
+    rule("organization", () => str("OIML"));
+    // --- Additional basic rules not in CommonParseRules ---
+    rule("colon", () => str(":"));
+    rule("lparen", () => str("("));
+    rule("rparen", () => str(")"));
+    rule("slash", () => str("/"));
+    // Main identifier pattern - check supplements first
+    rule("identifier", () => ref(rules, "amendment_identifier")
+        .or(ref(rules, "amendment_short"))
+        .or(ref(rules, "annex_letter_identifier"))
+        .or(ref(rules, "annex_identifier"))
+        .or(ref(rules, "plus_supplement_identifier"))
+        .or(ref(rules, "trailing_supplement_identifier"))
+        .or(ref(rules, "cs_identifier"))
+        .or(ref(rules, "bulletin_identifier"))
+        .or(ref(rules, "base")));
+    // Publisher - always "OIML"
+    rule("publisher", () => str("OIML").as("publisher").then(ref(rules, "space")));
+    // Document type - single letter. Strict family set: OIML publishes
+    // R D B G E V S documents (the estate grammar's family letters);
+    // any other letter is a rejection, not a flavor.
+    rule("doc_type", () => match("[BDEGRSV]").as("type").then(ref(rules, "space")));
+    // Bulletin locator - structured YYYY[-II[-SS]]
+    rule("bulletin_date", () => ref(rules, "space")
+        .then(ref(rules, "year_digits").as("year"))
+        .then(ref(rules, "dash").then(ref(rules, "two_digits").as("issue")).maybe())
+        .then(ref(rules, "dash").then(ref(rules, "two_digits").as("sequence")).maybe()));
+    rule("two_digits", () => match("\\d").repeat(2, 2));
+    rule("roman_numeral", () => match("[IVXLCDM]").repeat(1).as("volume_roman"));
+    // Citation form: LXVII(2) 20260211
+    rule("bulletin_citation", () => ref(rules, "space")
+        .then(ref(rules, "roman_numeral"))
+        .then(ref(rules, "lparen"), ref(rules, "digits").as("issue_arabic"), ref(rules, "rparen"))
+        .then(str(" "), match("\\d").repeat(8, 8).as("article_id")));
+    rule("bulletin_identifier", () => ref(rules, "publisher")
+        .then(str("Bulletin").as("type"))
+        .then(ref(rules, "bulletin_citation").or(ref(rules, "bulletin_date")).maybe())
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("number_only", () => ref(rules, "digits").as("number"));
+    rule("part_number", () => ref(rules, "dash").then(ref(rules, "digits")
+        .then(ref(rules, "slash").then(ref(rules, "dash"), ref(rules, "digits")).repeat(0))
+        .as("part")));
+    rule("subpart_number", () => ref(rules, "dash").then(ref(rules, "digits").as("subpart")));
+    rule("named_suffix", () => ref(rules, "dash")
+        .then(str("GUM")
+        .then(ref(rules, "space"), ref(rules, "digits"))
+        .or(match("[A-Za-z]").repeat(1).then(str("_").maybe(), ref(rules, "digits")).repeat(0))
+        .as("code_suffix"))
+        .or(str(" ").then(str("Brochure").as("code_suffix"), str("").as("space_suffix"))));
+    rule("full_number", () => ref(rules, "number_only")
+        .then(ref(rules, "part_number"), ref(rules, "subpart_number"), ref(rules, "named_suffix").maybe())
+        .or(ref(rules, "number_only").then(ref(rules, "part_number"), ref(rules, "named_suffix").maybe()))
+        .or(ref(rules, "number_only").then(ref(rules, "named_suffix").maybe())));
+    rule("edition_number", () => str("6th")
+        .or(str("5th"))
+        .or(str("4th"))
+        .or(str("3rd"))
+        .or(str("2nd"))
+        .or(str("1st"))
+        .or(match("\\d").repeat(1).then(str("th").or(str("nd")).or(str("rd")).or(str("st"))))
+        .as("edition"));
+    rule("edition_text", () => str("Edition").or(str("edition")));
+    rule("edition_portion", () => str(", ")
+        .or(ref(rules, "space"))
+        .then(ref(rules, "edition_number").maybe(), ref(rules, "space?"), ref(rules, "edition_text"), ref(rules, "space?"), ref(rules, "year_digits").as("year"))
+        .as("edition_format"));
+    rule("date", () => ref(rules, "edition_portion")
+        // pubid#403: both sides of the colon are whitespace-tolerant
+        .or(ref(rules, "space?").then(ref(rules, "colon"), ref(rules, "space?"), ref(rules, "year_digits").as("year")))
+        .or(ref(rules, "space?").then(ref(rules, "lparen"), ref(rules, "year_digits").as("year"), ref(rules, "rparen"))));
+    rule("stage_iteration", () => match("\\d").repeat(1).then(str("."), match("\\d").repeat(1)).or(match("\\d").repeat(1)).as("iteration"));
+    rule("stage_abbr", () => str("WD").or(str("CD")).as("stage"));
+    rule("draft_stage", () => ref(rules, "space").then(ref(rules, "stage_iteration").maybe(), ref(rules, "stage_abbr")));
+    // Language codes: two-letter OIML codes before the single letters
+    rule("lang_single", () => match("[EFRXDSCAU]"));
+    rule("lang_multi_oiml", () => str("PO").or(str("PT")).or(str("PE")).or(str("SR")));
+    rule("lang_multi", () => match("[a-z]").repeat(2, 2));
+    // Full-word language markers as OIML prints them ("(Fra)", "(Eng)"),
+    // three or more letters, any case. Kept verbatim on the identifier;
+    // the URN lowercases.
+    rule("lang_word", () => match("[A-Za-z]").repeat(3));
+    rule("language_code", () => ref(rules, "lang_single")
+        .then(ref(rules, "slash"), ref(rules, "lang_single"))
+        .or(ref(rules, "lang_multi_oiml"))
+        .or(ref(rules, "lang_word"))
+        .or(ref(rules, "lang_single"))
+        .or(ref(rules, "lang_multi"))
+        .as("language"));
+    rule("language_with_space", () => ref(rules, "space")
+        .then(ref(rules, "lparen"), ref(rules, "language_code"), ref(rules, "rparen"))
+        .then(str("").as("space_before_lang")));
+    rule("language_without_space", () => ref(rules, "lparen").then(ref(rules, "language_code"), ref(rules, "rparen")));
+    rule("language_portion", () => ref(rules, "language_with_space").or(ref(rules, "language_without_space")));
+    // Amendment identifier - "Amendment (YYYY) to BASE"
+    rule("amendment_identifier", () => str("Amendment")
+        .then(ref(rules, "space"), ref(rules, "lparen"), ref(rules, "year_digits").as("year"), ref(rules, "rparen"))
+        .then(str(" "), str("to"), str(" "))
+        .then(ref(rules, "base_without_language").as("base"))
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("amendment_short", () => ref(rules, "publisher")
+        .then(ref(rules, "doc_type"))
+        .then(ref(rules, "full_number").as("base_code"))
+        .then(str(" "), str("Amendment").as("amd_marker"))
+        .then(str(" ")
+        .then(ref(rules, "edition_text"), ref(rules, "space?"), ref(rules, "year_digits").as("year"))
+        .as("edition_format")
+        .or(ref(rules, "colon").then(ref(rules, "space?"), ref(rules, "year_digits").as("year"))))
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("trailing_supplement_identifier", () => ref(rules, "base_without_language")
+        .as("base")
+        .then(str(" "), str("Amendment").or(str("Errata")).as("trailing_marker"))
+        .then(str(" ").then(ref(rules, "digits").as("number")).maybe(), ref(rules, "language_portion").maybe().as("language")));
+    // OIML-CS certification-system documents. Two head spellings
+    // ("OIML-CS" / "OIML CS") and two family-number separators
+    // ("PD-05" / "PD 05"), an "Edition N" instead of a year, and an
+    // optional parenthesized trailing amendment - "(Amendment 1)".
+    rule("cs_identifier", () => str("OIML")
+        .as("publisher")
+        .then(ref(rules, "dash")
+        .then(str("CS"))
+        .or(str(" ").then(str("CS")))
+        .as("cs_series"))
+        .then(ref(rules, "space"))
+        .then(str("PD").or(str("OD")).or(str("CID")).as("cs_family"))
+        .then(ref(rules, "dash").or(str(" ")).as("cs_separator"))
+        .then(ref(rules, "digits").as("number"))
+        .then(str(" "), str("Edition"), str(" "), ref(rules, "digits").as("edition"))
+        .then(str(" ")
+        .then(ref(rules, "lparen"), str("Amendment"), str(" "), ref(rules, "digits").as("cs_amendment"), ref(rules, "rparen"))
+        .maybe()));
+    rule("plus_supplement_identifier", () => ref(rules, "base_without_language")
+        .as("base")
+        .then(str("+"), str("Amendment").or(str("Errata")).as("plus_marker"))
+        .then(ref(rules, "colon").then(ref(rules, "year_digits").as("year")).maybe())
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("annex_identifier", () => ref(rules, "base_without_language")
+        .as("base")
+        .then(str(" "), str("Annexes").as("annex_marker"))
+        .then(str(" ")
+        .then(ref(rules, "edition_text"), str(" "), ref(rules, "year_digits").as("year"))
+        .as("edition_format")
+        .or(ref(rules, "colon").then(ref(rules, "year_digits").as("year")))
+        .maybe())
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("annex_letter_value", () => match("[A-Z]").then(ref(rules, "dash").then(match("[A-Z]")).maybe()).as("annex_letter"));
+    rule("annex_letter_identifier", () => ref(rules, "base_without_language")
+        .as("base")
+        .then(str(" "), str("Annex"), str(" "), ref(rules, "annex_letter_value"))
+        .then(str(" ")
+        .then(ref(rules, "edition_text"), str(" "), ref(rules, "year_digits").as("year"))
+        .or(ref(rules, "colon").then(ref(rules, "year_digits").as("year")))
+        .maybe())
+        .then(ref(rules, "language_portion").maybe().as("language")));
+    rule("base_without_language", () => ref(rules, "publisher")
+        .then(ref(rules, "doc_type"))
+        .then(ref(rules, "full_number"))
+        .then(ref(rules, "date").maybe())
+        .then(ref(rules, "draft_stage").maybe()));
+    rule("base", () => ref(rules, "publisher")
+        .then(ref(rules, "doc_type"))
+        .then(ref(rules, "full_number"))
+        .then(ref(rules, "date").maybe())
+        .then(ref(rules, "draft_stage").maybe())
+        .then(ref(rules, "language_portion").maybe()));
+    return rules;
+}
+export const oimlGrammar = {
+    rules: buildRules(),
+    root: "identifier",
+};

package/dist/flavors/oiml/implementation.d.ts

@@ -0,0 +1,9 @@
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { ParseFailed } from "../../grammar/engine.js";
+/**
+ * Grammar-backed OIML on the unified model: the model classes are
+ * BaseIdentifier subclasses, so they satisfy the Identifier adapter
+ * directly (toHash/toHuman/toUrn/fromHash come from the model).
+ */
+export declare function oimlGrammarImplementation(): FlavorImplementation;
+export { ParseFailed };

package/dist/flavors/oiml/implementation.js

@@ -0,0 +1,45 @@
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { oimlGrammar } from "./grammar.js";
+import { buildOimlIdentifier, OimlDualPublished } from "./model.js";
+import { grammarImplementation } from "../index.js";
+// The co-publisher prefix (only ISO confirmed so far; the gem routes via
+// Pubid.parse's prefix table).
+function flavorOf(input) {
+    return input.toUpperCase().startsWith("ISO ") ? "iso" : "iso";
+}
+/**
+ * Grammar-backed OIML on the unified model: the model classes are
+ * BaseIdentifier subclasses, so they satisfy the Identifier adapter
+ * directly (toHash/toHuman/toUrn/fromHash come from the model).
+ */
+export function oimlGrammarImplementation() {
+    return {
+        parse(input) {
+            // The co-published form carries both identifiers joined by "|":
+            // "ISO 4064-1:2024|OIML R 49-1:2024". The first side is another
+            // flavor's identifier (routed by prefix, the Ruby Pubid.parse
+            // counterpart); the second is the OIML side.
+            if (input.includes("|") && !input.startsWith("|") && !input.endsWith("|")) {
+                // Each side may be either flavor ("ISO …|OIML R …" and the
+                // reversed print): the OIML side parses through this grammar, the
+                // co-publisher's through its own (routed by prefix).
+                const parts = input.split("|");
+                const members = parts.map((part) => {
+                    const s = part.trim();
+                    if (s.toUpperCase().startsWith("OIML")) {
+                        return buildOimlIdentifier(parseGrammar(oimlGrammar, s));
+                    }
+                    const impl = grammarImplementation(flavorOf(s));
+                    if (impl === undefined)
+                        throw new ParseFailed(`OIML: no flavor for ${s}`, 0);
+                    return impl.parse(s);
+                });
+                if (members.length === 2 && members[0] !== undefined && members[1] !== undefined) {
+                    return new OimlDualPublished({ first: members[0], second: members[1] });
+                }
+            }
+            return buildOimlIdentifier(parseGrammar(oimlGrammar, input));
+        },
+    };
+}
+export { ParseFailed };

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

@@ -0,0 +1,23 @@
+import type { Tree } from "../../grammar/engine.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+import type { AttributeTable } from "../../model/attribute.js";
+declare abstract class OimlBase extends BaseIdentifier {
+    readonly publisher: string | undefined;
+    readonly language: string | undefined;
+    readonly parsed_format: string | undefined;
+    effectiveFormat(): "long" | "short";
+}
+/** ---- builder (lib/pubid/oiml/builder.rb) ---- */
+export declare class OimlDualPublished extends OimlBase {
+    static polymorphicName: string;
+    static get attributes(): AttributeTable;
+    static get mappings(): never[];
+    readonly first: BaseIdentifier;
+    readonly second: BaseIdentifier;
+    constructor(attrs?: Record<string, unknown>);
+    render(): string;
+    toUrn(): string;
+    root(): BaseIdentifier;
+}
+export declare function buildOimlIdentifier(tree: Tree): BaseIdentifier;
+export {};