@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/astm/model.js

@@ -0,0 +1,263 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { extendAttributes, keyValue } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/astm: the CodeNumber split columns (letter/number/
+ * suffix/subseries/dual_m) on every concrete class, the renderer family
+ * and the URN generator. Adjunct stores its designation directly in
+ * `number`.
+ */
+export class AstmCode {
+    letter;
+    number;
+    suffix;
+    subseries;
+    dualM;
+    constructor(attrs) {
+        this.letter = attrs["letter"];
+        this.number = attrs["number"];
+        this.suffix = attrs["suffix"];
+        this.subseries = attrs["subseries"];
+        this.dualM = attrs["dual_m"] === true;
+    }
+    render() {
+        if (this.letter !== undefined) {
+            let result = [this.letter, this.number, this.suffix]
+                .filter((s) => s !== undefined)
+                .join("");
+            if (this.subseries !== undefined)
+                result += `-S${this.subseries}`;
+            if (this.dualM)
+                result += "M";
+            return result;
+        }
+        let result = this.number ?? "";
+        if (this.suffix !== undefined)
+            result += this.suffix;
+        if (this.subseries !== undefined)
+            result += `-S${this.subseries}`;
+        return result;
+    }
+}
+const CODE_COLUMN_DEFS = {
+    number: { type: "string" },
+    letter: { type: "string" },
+    suffix: { type: "string" },
+    subseries: { type: "string" },
+    dual_m: { type: "boolean", default: false },
+};
+const CODE_COLUMN_MAPPINGS = keyValue({ wire: "number", to: "number" }, { wire: "letter", to: "letter" }, { wire: "suffix", to: "suffix" }, { wire: "subseries", to: "subseries" }, { wire: "dual_m", to: "dual_m" });
+export class AstmIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, {
+        ...CODE_COLUMN_DEFS,
+        publisher: { type: "string", default: "ASTM" },
+        year: { type: "string" },
+        format_suffix: { type: "string" },
+        type: { type: "string" },
+    });
+    static mappings = keyValue(...CODE_COLUMN_MAPPINGS, { wire: "publisher", to: "publisher" }, { wire: "year", to: "year" }, { wire: "format_suffix", to: "format_suffix" }, { wire: "type", to: "type" });
+    code() {
+        if (this.number === undefined && this.letter === undefined)
+            return undefined;
+        return new AstmCode({
+            letter: this.letter,
+            number: this.number,
+            suffix: this.suffix,
+            subseries: this.subseries,
+            dual_m: this.dual_m,
+        });
+    }
+    toUrn() {
+        return new AstmUrnGenerator(this).generate();
+    }
+}
+function yearPortion(year) {
+    return year.length === 4 ? year.slice(-2) : year;
+}
+// --- Renderer -------------------------------------------------------------------
+function renderStandard(id) {
+    const parts = [];
+    parts.push(id.publisher);
+    const code = id.code();
+    if (code !== undefined) {
+        let codeStr = code.render();
+        if (code.dualM) {
+            const baseCode = `${code.letter ?? ""}${code.number ?? ""}`;
+            codeStr = `${baseCode}/${baseCode}M`;
+        }
+        parts.push(codeStr);
+    }
+    let result = parts.join(" ");
+    const self = id;
+    if (id.year !== undefined) {
+        result += `-${yearPortion(id.year)}`;
+        if (self["sub_year"] !== undefined)
+            result += self["sub_year"];
+    }
+    if (self["reapproval"] !== undefined)
+        result += `(${self["reapproval"]})`;
+    if (self["edition"] !== undefined)
+        result += `e${self["edition"]}`;
+    return result;
+}
+// --- URN generator ---------------------------------------------------------------
+class AstmUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const self = id;
+        // Ruby: ["urn", ns, type_segment?, code, ...] with the publisher
+        // replacing the namespace slot ("iso/astm" for ISO/ASTMTR).
+        const parts = ["urn", id.publisher.toLowerCase(), "std"];
+        const code = id.code();
+        if (code !== undefined)
+            parts.push(code.render());
+        if (id.year !== undefined)
+            parts.push(yearPortion(id.year));
+        if (self["sub_year"] !== undefined)
+            parts.push(String(self["sub_year"]));
+        if (self["reapproval"] !== undefined)
+            parts.push(`reapp.${self["reapproval"]}`);
+        if (self["edition"] !== undefined)
+            parts.push(`e${self["edition"]}`);
+        return parts.join(":");
+    }
+}
+function astmClass(spec) {
+    class AstmConcrete extends AstmIdentifier {
+        static polymorphicName = `pubid:astm:${spec.kind}`;
+        static urnGenerator = AstmUrnGenerator;
+        static get attributes() {
+            return spec.extraDefs === undefined
+                ? AstmIdentifier.attributes
+                : extendAttributes(AstmIdentifier, spec.extraDefs);
+        }
+        static get mappings() {
+            return spec.extraDefs === undefined
+                ? [...AstmIdentifier.mappings]
+                : [...AstmIdentifier.mappings,
+                    ...Object.keys(spec.extraDefs).map((name) => ({ wire: name, to: name }))];
+        }
+        render() {
+            return spec.render(this);
+        }
+        toUrn() {
+            return spec.urn !== undefined ? spec.urn(this) : super.toUrn();
+        }
+    }
+    registerType(AstmConcrete);
+    return AstmConcrete;
+}
+export const StandardClass = astmClass({
+    kind: "standard",
+    extraDefs: {
+        sub_year: { type: "string" },
+        reapproval: { type: "string" },
+        edition: { type: "string" },
+    },
+    render: renderStandard,
+});
+export const IsoDualPublishedClass = astmClass({
+    kind: "iso-dual-published",
+    extraDefs: {
+        sub_year: { type: "string" },
+        reapproval: { type: "string" },
+        edition: { type: "string" },
+    },
+    render: renderStandard,
+});
+export const ResearchReportClass = astmClass({
+    kind: "research-report",
+    extraDefs: { committee: { type: "string" } },
+    render: (id) => [id.publisher, `RR:${id["committee"]}-${id.code()?.number}`].join(" "),
+});
+export const DataSeriesClass = astmClass({
+    kind: "data-series",
+    extraDefs: { hol_suffix: { type: "boolean" } },
+    render: (id) => {
+        const self = id;
+        let result = `${id.publisher} DS`;
+        result += id.code()?.render() ?? "";
+        if (self["hol_suffix"] === true)
+            result += "HOL";
+        if (id.format_suffix !== undefined)
+            result += id.format_suffix;
+        return result;
+    },
+});
+export const TechnicalReportClass = astmClass({
+    kind: "technical-report",
+    render: (id) => {
+        let result;
+        const code = id.code();
+        if (id.publisher === "ISO/ASTM" && (code === undefined || code.letter === undefined)) {
+            result = "ISO/ASTMTR";
+        }
+        else {
+            result = "TR";
+            if (code?.letter !== undefined)
+                result += code.letter;
+        }
+        if (code?.number !== undefined)
+            result += code.number;
+        if (id.format_suffix !== undefined)
+            result += id.format_suffix;
+        return result;
+    },
+});
+export const MonographClass = astmClass({
+    kind: "monograph",
+    extraDefs: { edition: { type: "string" } },
+    render: (id) => {
+        const self = id;
+        let result = `${id.publisher} MONO`;
+        result += id.code()?.number ?? "";
+        if (self["edition"] !== undefined)
+            result += `-${self["edition"]}`;
+        if (id.format_suffix !== undefined)
+            result += id.format_suffix;
+        return result;
+    },
+});
+export const AdjunctClass = astmClass({
+    kind: "adjunct",
+    extraDefs: {
+        ea_suffix: { type: "boolean" },
+        dvd_suffix: { type: "boolean" },
+    },
+    render: (id) => {
+        const self = id;
+        const result = [];
+        if (self["ea_suffix"] !== true && self["dvd_suffix"] !== true) {
+            result.push(id.publisher);
+        }
+        result.push(`ADJ${id.number ?? ""}${self["ea_suffix"] === true ? "-EA" : ""}${self["dvd_suffix"] === true ? "DVD" : ""}`);
+        return result.join(" ");
+    },
+});
+export const WorkInProgressClass = astmClass({
+    kind: "work-in-progress",
+    render: (id) => `${id.publisher} WK${id.code()?.number ?? ""}`,
+});
+export const ManualClass = astmClass({
+    kind: "manual",
+    extraDefs: {
+        edition: { type: "string" },
+        supplement: { type: "boolean" },
+        tp_designation: { type: "string" },
+    },
+    render: (id) => {
+        const self = id;
+        let result = "MNL";
+        if (self["tp_designation"] !== undefined)
+            result += "TP";
+        result += id.code()?.number ?? "";
+        if (self["edition"] !== undefined)
+            result += `-${self["edition"]}`;
+        result = `${id.publisher} ${result}`;
+        if (self["supplement"] === true)
+            result += "-SUP";
+        if (id.format_suffix !== undefined)
+            result += id.format_suffix;
+        return result;
+    },
+});

package/dist/flavors/bipm/index.d.ts

@@ -0,0 +1,30 @@
+import { Grammar } from "../../grammar/engine.js";
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+import { BaseIdentifier } from "../../model/identifier.js";
+export declare const bipmGrammar: Grammar;
+export declare abstract class BipmIdentifier extends BaseIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: import("../../model/attribute.js").FieldMapping[];
+    readonly group: string | undefined;
+    readonly type_code: string | undefined;
+    readonly number: string | undefined;
+    readonly year: number | undefined;
+    readonly language: string | undefined;
+    readonly form: string | undefined;
+    readonly issue: string | undefined;
+    readonly article: string | undefined;
+    readonly edition: string | undefined;
+    readonly version: string | undefined;
+    readonly years: string | undefined;
+    readonly variant: string | undefined;
+    readonly mep_code: string | undefined;
+    readonly report_code: string | undefined;
+    readonly guide_kind: string | undefined;
+    readonly appendix: string | undefined;
+    readonly annex: string | undefined;
+    readonly part: string | undefined;
+    numberSegment(): string;
+    yearSegment(lang?: string): string;
+    fullContentWrap(body: string): string;
+}
+export declare function bipmGrammarImplementation(): FlavorImplementation;