@pubid/pubid 0.1.24 → 0.1.26

package/dist/flavors/iso/index.js

@@ -426,6 +426,11 @@ function parseIsoUrn(urn) {
     if (parts[0] !== undefined && URN_TYPE_TOKENS.has(parts[0].toLowerCase())) {
         typeCode = parts.shift().toLowerCase();
     }
+    // RFC 5141 requires docnumber -- "urn:iso:std:iso" is not a valid
+    // NSS, and building it silently produced the identity-free "ISO "
+    // (mirrors lib/pubid/iso/urn_parser.rb)
+    if (parts.length === 0)
+        throw new Error(`missing docnumber: ${urn}`);
     let [number, part, subpart] = parseUrnNumberPart(parts.shift());
     let year;
     if (/^\d{4}$/.test(parts[0] ?? ""))
@@ -506,12 +511,25 @@ function parseIsoUrn(urn) {
             else
                 supp.number = parts.shift();
         }
-        if ((parts[0] ?? "").startsWith("v")) {
-            const version = parts.shift().slice(1);
-            supp.number = version.split(".")[0];
-        }
+        // The legacy year-overloaded wire ("amd:2007:v2" -- the number rode
+        // the version slot): a v-token with no preceding number carries the
+        // NUMBER. The RFC 5141-bis order ("amd:1:2007:v2") keeps the number
+        // in its own slot, so a v-token after a number is the true
+        // <supplversion>.
+        const consumeV = () => {
+            if ((parts[0] ?? "").startsWith("v")) {
+                const value = parts.shift().slice(1).split(".")[0];
+                if (supp.number === undefined)
+                    supp.number = value;
+                else
+                    supp.version = value;
+            }
+        };
+        consumeV();
         if (supp.year === undefined && /^\d{4}$/.test(parts[0] ?? ""))
             supp.year = parts.shift();
+        // a v-token after the year would otherwise start a type-less wrap
+        consumeV();
         if (parts[0] !== undefined && !/^\d+$/.test(parts[0]) &&
             !/^(amd|cor|sup|add|v\d+|stage-)/i.test(parts[0])) {
             supp.languages = parts.shift().split(",").map((l) => l.toUpperCase()).join("/");
@@ -577,18 +595,30 @@ function parseIsoUrn(urn) {
         }
         const suppTree = {};
         if (supp.stage !== undefined) {
-            const stage = ISO_TYPED_STAGES.find((s) => s.stageCode === supp.stage);
+            // A harmonized code resolves within the supplement's own type
+            // family -- the IS-family default would turn a staged Corrigendum
+            // into a plain IS (mirrors the gem's build_identifier).
+            const stage = /^\d\d\.\d\d$/.test(supp.stage)
+                ? ISO_TYPED_STAGES.find((st) => st.harmonized?.includes(supp.stage) && st.typeKey === supp.type) ??
+                    ISO_TYPED_STAGES.find((st) => st.harmonized?.includes(supp.stage) && st.typeKey === "is")
+                : ISO_TYPED_STAGES.find((st) => st.stageCode === supp.stage);
             suppTree["type_with_stage"] = stage !== undefined
                 ? stage.abbr[0] ?? ""
-                : supp.stage.toUpperCase();
+                : supp.type?.toUpperCase() ?? supp.stage.toUpperCase();
         }
         if (supp.type !== undefined && suppTree["type_with_stage"] === undefined) {
-            suppTree["type_with_stage"] = supp.type.toUpperCase();
+            // "sup" is the generic Supplement (type key "suppl") -- the raw
+            // "SUP" resolves the Directives Supplement row, whose render needs
+            // the supplement_publisher a guide chain never has
+            const typeToken = supp.type === "sup" ? "SUPPL" : supp.type.toUpperCase();
+            suppTree["type_with_stage"] = typeToken;
         }
         if (supp.number !== undefined)
             suppTree["number"] = supp.number;
         if (supp.year !== undefined)
             suppTree["date"] = supp.year;
+        if (supp.version !== undefined)
+            suppTree["supplement_version"] = supp.version;
         if (supp.languages !== undefined)
             suppTree["languages"] = supp.languages;
         tree = { base: tree, ...suppTree };

package/dist/flavors/iso/model.js

@@ -465,14 +465,9 @@ class IsoUrnGenerator extends BaseUrnGenerator {
         const stageCode = ts.entry.stageCode;
         if (stageCode === "published")
             return undefined;
-        const typeKey = id.typeKey();
-        const combinedKey = typeKey !== "is" ? `${stageCode}${typeKey}` : stageCode;
-        const stageAbbrUrn = TYPED_STAGE_MAP[combinedKey] ?? TYPED_STAGE_MAP[stageCode];
-        if (stageAbbrUrn !== undefined) {
-            if (id.stage_iteration !== undefined)
-                return `${stageAbbrUrn}.${id.stage_iteration.render() ?? ""}`;
-            return stageAbbrUrn;
-        }
+        // RFC 5141 carries the stage as the harmonized code only; the typed
+        // abbreviations live in the human face. Legacy abbreviation URNs are
+        // accepted on ingestion and re-canonicalized here.
         const harmonized = ts.entry.harmonized;
         if (harmonized === undefined || harmonized.length === 0)
             return undefined;
@@ -558,17 +553,15 @@ class IsoUrnGenerator extends BaseUrnGenerator {
                 parts.push(stageComp);
             parts.push(supp.typeKey() === "suppl" || supp.typeKey() === "add" ? "sup" : supp.typeKey());
             const iter = supp.typeKey() === "suppl" || supp.stage_iteration === undefined ? undefined : supp.stage_iteration.render();
+            // RFC 5141 supplement slots in order: number, year (the bis
+            // additive extension), then the published version.
+            if (supp.number !== undefined)
+                parts.push(supp.number);
             const d = urnDate(supp);
-            if (d !== undefined) {
+            if (d !== undefined)
                 parts.push(d);
-                if (supp.number !== undefined)
-                    parts.push(iter !== undefined ? `v${supp.number}.${iter}` : `v${supp.number}`);
-            }
-            else {
-                if (supp.number !== undefined)
-                    parts.push(supp.number);
-                parts.push(iter !== undefined ? `v1.${iter}` : "v1");
-            }
+            const version = supp.supplement_version ?? 1;
+            parts.push(iter !== undefined ? `v${version}.${iter}` : `v${version}`);
             if (supp.languages !== undefined && supp.languages.length > 0) {
                 parts.push(supp.languages.map((l) => l.code).join(","));
             }
@@ -616,10 +609,14 @@ const supplementPublisherMappings = () => [
         },
     },
 ];
-const SUPPLEMENT_MAPPINGS = keyValue(...ISO_MAPPINGS, ...supplementPublisherMappings(), stageMapping(), { wire: "base", to: "base" });
+const SUPPLEMENT_MAPPINGS = keyValue(...ISO_MAPPINGS, ...supplementPublisherMappings(), stageMapping(), { wire: "base", to: "base" }, 
+// omitted when unset, so parsed human faces keep their hashes
+{ wire: "supplement_version", to: "supplement_version" });
 export class IsoSupplementIdentifier extends IsoSingleIdentifier {
     static attributes = extendAttributes(IsoSingleIdentifier, {
         base: { type: IsoIdentifier },
+        // The RFC 5141 <supplversion> (corrected version of the supplement).
+        supplement_version: { type: "string" },
     });
     static mappings = SUPPLEMENT_MAPPINGS;
     render() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pubid/pubid",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "TypeScript PubID identifiers: resolution, normalization and canonical hashes for every identifier in the pubid-testsuite corpus (41 standards bodies), with a conformance runner mirroring the Ruby reference",
   "type": "module",
   "license": "MIT",