@pubid/pubid 0.1.4 → 0.1.6

package/dist/flavors/oiml/model.js

@@ -1,5 +1,5 @@
 import { ParseFailed } from "../../grammar/engine.js";
-import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { BaseIdentifier, registerType, resolveType } from "../../model/identifier.js";
 import { extendAttributes, keyValue } from "../../model/attribute.js";
 import { BaseUrnGenerator } from "../../model/urn-generator.js";
 const KIND_BY_TYPE = {
@@ -13,6 +13,7 @@ const KIND_BY_TYPE = {
 };
 const TYPE_STRINGS = {
     "basic-publication": "B",
+    "certification-system": "CS",
     document: "D",
     "expert-report": "E",
     guide: "G",
@@ -108,6 +109,29 @@ class OimlSingle extends OimlBase {
         return result;
     }
 }
+/** ---- OIML-CS certification-system documents ---- */
+const CS_ATTRS = {
+    ...SINGLE_ATTRS,
+    family: { type: "string" },
+    amendment: { type: "string" },
+    space_separator: { type: "boolean", default: false },
+};
+const CS_MAPPINGS = keyValue(...Object.keys(CS_ATTRS).map((name) => ({ wire: name, to: name })));
+// "OIML-CS PD-05 Edition 6 (Amendment 1)": the number keeps its printed
+// zero padding; the print states an edition instead of a year.
+class OimlCertificationSystem extends OimlSingle {
+    static polymorphicName = "pubid:oiml:certification-system";
+    static attributes = extendAttributes(BaseIdentifier, CS_ATTRS);
+    static mappings = CS_MAPPINGS;
+    render() {
+        let result = `${this.publisher}-CS ${this.family}` +
+            `${this.space_separator ? " " : "-"}${this.number} Edition ${this.edition}`;
+        if (this.amendment)
+            result += ` (Amendment ${this.amendment})`;
+        return result;
+    }
+}
+registerType(OimlCertificationSystem);
 function oimlSingleClass(kind) {
     const isBulletin = kind === "bulletin";
     class OimlSingleIdentifier extends OimlSingle {
@@ -146,12 +170,13 @@ const SUPP_ATTRS = {
     parsed_format: { type: "string", default: "short" },
     base: { type: OimlSingle },
     supp_year: { type: "string" },
+    number: { type: "string" },
     trailing: { type: "boolean", default: false },
     joined: { type: "boolean", default: false },
     letter: { type: "string" },
     year_on_base: { type: "boolean", default: false },
 };
-const SUPP_MAPPINGS = keyValue({ wire: "language", to: "language" }, { wire: "parsed_format", to: "parsed_format" }, { wire: "base", to: "base" }, { wire: "year", to: "supp_year" }, { wire: "trailing", to: "trailing" }, { wire: "joined", to: "joined" }, { wire: "letter", to: "letter" }, { wire: "year_on_base", to: "year_on_base" });
+const SUPP_MAPPINGS = keyValue({ wire: "language", to: "language" }, { wire: "parsed_format", to: "parsed_format" }, { wire: "base", to: "base" }, { wire: "year", to: "supp_year" }, { wire: "number", to: "number" }, { wire: "trailing", to: "trailing" }, { wire: "joined", to: "joined" }, { wire: "letter", to: "letter" }, { wire: "year_on_base", to: "year_on_base" });
 /** ---- supplements (Amendment / Errata) and Annex ---- */
 class OimlSupplement extends OimlBase {
     supplementType() {
@@ -178,6 +203,8 @@ class OimlSupplement extends OimlBase {
         }
         if (this.trailing) {
             let result = `${stripLanguage(this.base.render())} ${this.supplementType()}`;
+            if (this.number)
+                result += ` ${this.number}`;
             if (this.language)
                 result += ` (${this.language})`;
             return result;
@@ -247,6 +274,7 @@ for (const kind of [
 ]) {
     KIND_CLASSES[kind] = oimlSingleClass(kind);
 }
+KIND_CLASSES["certification-system"] = OimlCertificationSystem;
 KIND_CLASSES["amendment"] = oimlSupplementClass("amendment");
 KIND_CLASSES["errata"] = oimlSupplementClass("errata");
 KIND_CLASSES["annex"] = oimlSupplementClass("annex");
@@ -270,6 +298,13 @@ class OimlUrnGenerator extends BaseUrnGenerator {
                 parts.push(id.language.toLowerCase());
             return parts.join(":");
         }
+        // Certification-system documents: the family-number pair is the
+        // document identity ("cs:pd-05"); the printed edition and trailing
+        // amendment are print states, not URN segments.
+        if (kind === "certification-system") {
+            const cs = id;
+            return ["urn", "oiml", "cs", `${(cs.family ?? "").toLowerCase()}-${cs.number ?? ""}`].join(":");
+        }
         const isSupp = kind === "amendment" || kind === "errata" || kind === "annex";
         const single = (isSupp ? id.base : id);
         const parts = ["urn", "oiml"];
@@ -280,8 +315,12 @@ class OimlUrnGenerator extends BaseUrnGenerator {
         const code = single.composedCode();
         if (code)
             parts.push(code);
+        // The trailing-word form keeps the publication year on the base
+        // ("R 138:2009 Amendment 1"); the supplement itself carries only the
+        // ordinal.
         const year = id.year ??
-            id.supp_year;
+            id.supp_year ??
+            (isSupp ? single.year : undefined);
         if (year)
             parts.push(year);
         const stage = id.stage;
@@ -292,6 +331,12 @@ class OimlUrnGenerator extends BaseUrnGenerator {
             parts.push(iteration);
         if (id.language)
             parts.push(id.language.toLowerCase());
+        // Ruby's supplement branch appends the ordinal after the language.
+        if (isSupp) {
+            const ordinal = id.number;
+            if (ordinal)
+                parts.push(ordinal);
+        }
         return parts.join(":");
     }
 }
@@ -299,15 +344,97 @@ for (const klass of Object.values(KIND_CLASSES)) {
     klass.urnGenerator = OimlUrnGenerator;
 }
 /** ---- builder (lib/pubid/oiml/builder.rb) ---- */
+// OIML co-publishes some documents jointly with another SDO (ISO so
+// far); the printed reference carries both identifiers joined by "|":
+// "ISO 4064-1:2024|OIML R 49-1:2024". The URN is the OIML side's.
+export class OimlDualPublished extends OimlBase {
+    static polymorphicName = "pubid:oiml:dual-published";
+    static get attributes() {
+        return extendAttributes(OimlBase, {
+            // "string" keeps objects passing through the scalar coercion
+            // untouched (the ieee AdoptedStandard precedent for cross-flavor
+            // members); the constructor coerces bare hashes via the registry.
+            first: { type: "string" },
+            second: { type: "string" },
+        });
+    }
+    static get mappings() {
+        return [
+            { wire: "first", to: "first" },
+            { wire: "second", to: "second" },
+        ];
+    }
+    constructor(attrs = {}) {
+        super(attrs);
+        // The members are cross-flavor (the co-publisher's side arrives as a
+        // bare hash with _type); coerce through the registry - the abstract
+        // BaseIdentifier attribute type cannot dispatch polymorphically.
+        const coerceMember = (v) => {
+            if (v instanceof BaseIdentifier)
+                return v;
+            if (typeof v === "object" && v !== null && "_type" in v) {
+                const klass = resolveType(v["_type"]);
+                if (klass !== undefined) {
+                    return klass.fromHash(v);
+                }
+            }
+            return undefined;
+        };
+        const self = this;
+        const f = coerceMember(self["first"]);
+        const s = coerceMember(self["second"]);
+        if (f !== undefined)
+            self["first"] = f;
+        if (s !== undefined)
+            self["second"] = s;
+    }
+    render() {
+        return `${this.first.toHuman()}|${this.second.toHuman()}`;
+    }
+    toUrn() {
+        // The URN is the OIML side's, whichever position it prints in.
+        const oimlSide = this.second instanceof OimlBase ? this.second : this.first;
+        return oimlSide.toUrn();
+    }
+    root() {
+        return this.second instanceof OimlBase ? this.second : this.first;
+    }
+}
+registerType(OimlDualPublished);
 export function buildOimlIdentifier(tree) {
     if (!isObj(tree))
         throw new ParseFailed("OIML: unexpected parse tree", 0);
+    if (tree["cs_series"] !== undefined)
+        return buildCs(tree);
     if (tree["amd_marker"] !== undefined)
         return buildShortAmendment(tree);
     if (tree["base"] !== undefined)
         return buildSupplement(tree);
     return buildBaseDocument(tree);
 }
+// OIML-CS documents: family (PD/OD/CID), zero-padded number, the
+// printed "Edition N", and an optional parenthesized trailing
+// amendment. The family-number separator is a spelling flag.
+function buildCs(tree) {
+    const attrs = {
+        publisher: str(tree["publisher"]) ?? "OIML",
+        parsed_format: "short",
+    };
+    const family = str(tree["cs_family"]);
+    if (family !== undefined)
+        attrs["family"] = family;
+    const number = str(tree["number"]);
+    if (number !== undefined)
+        attrs["number"] = number;
+    const edition = str(tree["edition"]);
+    if (edition !== undefined)
+        attrs["edition"] = edition;
+    const amendment = str(tree["cs_amendment"]);
+    if (amendment !== undefined)
+        attrs["amendment"] = amendment;
+    attrs["space_separator"] = tree["cs_separator"] === " ";
+    return new KIND_CLASSES["certification-system"](attrs);
+}
 function buildShortAmendment(tree) {
     const baseCode = isObj(tree["base_code"]) ? tree["base_code"] : undefined;
     const base = buildBaseDocument({
@@ -359,6 +486,9 @@ function buildSupplement(tree) {
     const language = extractLanguage(tree["language"]);
     if (language !== undefined)
         attrs["language"] = language;
+    const ordinal = str(tree["number"]);
+    if (ordinal !== undefined)
+        attrs["number"] = ordinal;
     if (marker !== undefined)
         attrs["trailing"] = true;
     if (plusMarker !== undefined)

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export type { FlavorImplementation, Identifier, ImplementationRegistry } from ".
 export { PendingRegistry } from "./conformance/pending.js";
 export { checkCase, runFlavor, runCorpus } from "./conformance/runner.js";
 export { corpusModeImplementation, CorpusBackedIdentifier } from "./implementations/corpus-mode.js";
+export { grammarImplementation } from "./flavors/index.js";

package/dist/index.js

@@ -4,3 +4,6 @@ export { buildArtifact, loadBundledCorpus, parseArtifact, } from "./corpus/artif
 export { PendingRegistry } from "./conformance/pending.js";
 export { checkCase, runFlavor, runCorpus } from "./conformance/runner.js";
 export { corpusModeImplementation, CorpusBackedIdentifier } from "./implementations/corpus-mode.js";
+// Root re-export so consumers needn't deep-import flavor modules
+// (pubid/pubid-ts#63 - the estate serving codec).
+export { grammarImplementation } from "./flavors/index.js";

package/dist/model/identifier.d.ts

@@ -39,6 +39,7 @@ export type UrnGeneratorCtor = new (identifier: BaseIdentifier) => {
 };
 /** Register a concrete identifier class under its polymorphic _type (the *_TYPE_MAP role). */
 export declare function registerType(klass: IdentifierStatic): void;
+export declare function resolveType(type: string): IdentifierStatic | undefined;
 export declare abstract class BaseIdentifier {
     static polymorphicName: string;
     /** The human renderer body — the one method every flavor writes. */

package/dist/model/identifier.js

@@ -25,7 +25,7 @@ const TYPE_REGISTRY = new Map();
 export function registerType(klass) {
     TYPE_REGISTRY.set(klass.polymorphicName, klass);
 }
-function resolveType(type) {
+export function resolveType(type) {
     return TYPE_REGISTRY.get(type);
 }
 function isScalarType(t) {

package/dist/urn/parsers.d.ts

@@ -0,0 +1,5 @@
+import type { Identifier } from "../conformance/implementation.js";
+import { type UrnParserDef } from "./types.js";
+export declare const URN_PARSERS: Record<string, UrnParserDef>;
+export declare function lookupUrnParser(flavor: string): UrnParserDef | undefined;
+export declare function parseUrnFor(def: UrnParserDef, urn: string, parse: (text: string) => Identifier): Identifier;