@pubid/pubid 0.1.3 → 0.1.5

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

@@ -0,0 +1,2 @@
+import type { FlavorImplementation } from "../../conformance/implementation.js";
+export declare function ituGrammarImplementation(): FlavorImplementation;

package/dist/flavors/itu/index.js

@@ -0,0 +1,224 @@
+import { ParseFailed, parseGrammar } from "../../grammar/engine.js";
+import { PubidDate } from "../../model/component.js";
+import { ituGrammar, normalizeWhitespaceItu } from "./grammar.js";
+import { ITU_CLASSES, ITU_LANGUAGES, ItuCode, ItuDesignation, } from "./model.js";
+/**
+ * Port of lib/pubid/itu/builder.rb — the exact dispatch order:
+ * annex_to → annex_number → appendix_number → OB/_op_bull →
+ * supplement_type → handbook_marker → study_group → contribution →
+ * combined → report/recommendation.
+ */
+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;
+}
+function extractParts(raw) {
+    if (Array.isArray(raw)) {
+        return raw.map((p) => (isObj(p) ? String(p["part"]) : String(p)));
+    }
+    if (isObj(raw) && raw["part"] !== undefined)
+        return [String(raw["part"])];
+    return [];
+}
+const normLanguage = (v) => {
+    const raw = s(v);
+    if (raw === undefined)
+        return undefined;
+    return ITU_LANGUAGES[raw] ?? raw;
+};
+class ItuBuilder {
+    build(data) {
+        const tree = flatten(data);
+        // The common-text twin ("| ISO/IEC …") is stored as the stripped
+        // string (Ruby parses it cross-flavor; no ISO parser exists in the
+        // TS mirror yet, and no corpus row carries one).
+        const twinRaw = s(tree["common_text_twin"])?.replace(/^\s*\|\s*/, "");
+        const twin = twinRaw === "" ? undefined : twinRaw;
+        if (tree["annex_to"] !== undefined)
+            return this.buildAnnexTo(tree["annex_to"]);
+        if (tree["annex_number"] !== undefined) {
+            return this.withTwin(this.buildAnnexOfRecommendation(tree), twin);
+        }
+        if (tree["appendix_number"] !== undefined) {
+            return this.withTwin(this.buildAppendixOfRecommendation(tree), twin);
+        }
+        if ((s(tree["series"]) === "OB" && tree["series_dash"] === undefined) || tree["_op_bull"] !== undefined) {
+            return this.withTwin(this.buildSpecialPublication(tree), twin);
+        }
+        if (tree["supplement_type"] !== undefined) {
+            return this.withTwin(this.buildSupplement(tree), twin);
+        }
+        if (tree["handbook_marker"] !== undefined)
+            return this.buildHandbook(tree);
+        if (tree["study_group"] !== undefined)
+            return this.buildQuestion(tree);
+        if (tree["contribution_marker"] !== undefined)
+            return this.buildContribution(tree);
+        const code = tree["number"] !== undefined ? this.buildCode(tree) : undefined;
+        const date = tree["year"] !== undefined ? this.buildDate(tree) : undefined;
+        const common = {
+            sector: s(tree["sector"]),
+            series: s(tree["series"]),
+            code,
+            date,
+            version: s(tree["version"]),
+            series_word: tree["series_word"] !== undefined,
+            series_dash: tree["series_dash"] !== undefined,
+            attachment: tree["attachment"] !== undefined,
+            range_end: s(tree["range_end"]),
+            language: normLanguage(tree["language"]),
+            common_text_twin: twin,
+        };
+        if (tree["combined"] !== undefined) {
+            return new ITU_CLASSES["combined"]({
+                ...common,
+                combined: this.buildDesignations(tree["combined"]),
+            });
+        }
+        const klass = tree["report_marker"] !== undefined ? ITU_CLASSES["report"] : ITU_CLASSES["recommendation"];
+        return new klass({ ...common });
+    }
+    withTwin(identifier, twin) {
+        if (twin !== undefined) {
+            identifier["common_text_twin"] = twin;
+        }
+        return identifier;
+    }
+    buildCode(tree) {
+        return new ItuCode({
+            imp_marker: s(tree["imp_marker"]),
+            number: s(tree["number"]),
+            series_suffix: s(tree["series_suffix"]),
+            series_suffix_spaced: tree["series_suffix_spaced"] !== undefined,
+            subseries: s(tree["subseries"]),
+            parts: extractParts(tree["parts"]),
+            qualifier: s(tree["qualifier"]),
+            qualifier_glued: tree["qualifier"] !== undefined && tree["qualifier_spaced"] === undefined,
+        });
+    }
+    buildDate(tree) {
+        return new PubidDate({ year: s(tree["year"]), month: s(tree["month"]) });
+    }
+    /** OB is cross-bureau — the sector of legacy strings is dropped. */
+    buildSpecialPublication(tree) {
+        return new ITU_CLASSES["special_publication"]({
+            series: "OB",
+            code: tree["number"] !== undefined ? this.buildCode(tree) : undefined,
+            date: tree["year"] !== undefined ? this.buildDate(tree) : undefined,
+            language: normLanguage(tree["language"]),
+        });
+    }
+    buildAnnexTo(inner) {
+        const data = flatten(inner);
+        const base = this.buildSpecialPublication(data);
+        return new ITU_CLASSES["annex_to"]({
+            base,
+            language: normLanguage(data["language"]),
+        });
+    }
+    /** sector/series/code are deliberately NOT copied from the base. */
+    buildAnnexOfRecommendation(tree) {
+        return new ITU_CLASSES["annex_of"]({
+            base: this.build(tree["base"]),
+            number: s(tree["annex_number"]),
+            date: tree["year"] !== undefined ? this.buildDate(tree) : undefined,
+            language: normLanguage(tree["language"]),
+        });
+    }
+    buildAppendixOfRecommendation(tree) {
+        return new ITU_CLASSES["appendix_of"]({
+            base: this.build(tree["base"]),
+            number: s(tree["appendix_number"]),
+            material: s(tree["appendix_material"]),
+            date: tree["year"] !== undefined ? this.buildDate(tree) : undefined,
+            language: normLanguage(tree["language"]),
+        });
+    }
+    buildHandbook(tree) {
+        return new ITU_CLASSES["handbook"]({
+            sector: s(tree["sector"]),
+            code: this.buildCode(tree),
+            date: tree["year"] !== undefined ? this.buildDate(tree) : undefined,
+        });
+    }
+    buildQuestion(tree) {
+        return new ITU_CLASSES["question"]({
+            sector: s(tree["sector"]),
+            series: s(tree["series"]),
+            code: this.buildCode(tree),
+            study_group: s(tree["study_group"]),
+            has_bl: tree["has_bl"] !== undefined,
+            bracketed: tree["bracketed"] !== undefined,
+            has_colon: tree["question_colon"] !== undefined,
+        });
+    }
+    buildContribution(tree) {
+        return new ITU_CLASSES["contribution"]({
+            sector: s(tree["sector"]),
+            series: s(tree["series"]),
+            code: this.buildCode(tree),
+            language: normLanguage(tree["language"]),
+        });
+    }
+    buildDesignations(combined) {
+        const list = Array.isArray(combined) ? combined : [combined];
+        return list.map((element) => {
+            const d = isObj(element) && element["designation"] !== undefined ? flatten(element["designation"]) : isObj(element) ? element : {};
+            return new ItuDesignation({
+                series: s(d["series"]),
+                code: new ItuCode({
+                    number: s(d["number"]),
+                    series_suffix: s(d["series_suffix"]),
+                    series_suffix_spaced: d["series_suffix_spaced"] !== undefined,
+                    subseries: s(d["subseries"]),
+                    parts: extractParts(d["parts"]),
+                    qualifier: s(d["qualifier"]),
+                    qualifier_glued: d["qualifier"] !== undefined && d["qualifier_spaced"] === undefined,
+                }),
+            });
+        });
+    }
+    buildSupplement(tree) {
+        const base = tree["base"] !== undefined ? this.build(tree["base"]) : undefined;
+        const token = (s(tree["supplement_type"]) ?? "").replace(".", "");
+        const kind = { Amd: "amendment", Add: "addendum", Cor: "corrigendum", Err: "errata", Suppl: "supplement" }[token];
+        if (kind === undefined)
+            throw new ParseFailed(`ITU: unknown supplement type ${token}`, 0);
+        const date = tree["supplement_year"] !== undefined
+            ? new PubidDate({ year: s(tree["supplement_year"]), month: s(tree["supplement_month"]) })
+            : undefined;
+        // An annex base keeps sector/series/code on ITS base — reach
+        // through it via root, or a supplement of an annex carries none.
+        const baseAsIdu = base;
+        const baseIdentity = baseAsIdu !== undefined ? (baseAsIdu.sector !== undefined ? baseAsIdu : baseAsIdu.root()) : undefined;
+        const attrs = {
+            sector: baseIdentity?.sector ?? s(tree["sector"]),
+            series: baseIdentity?.series ?? s(tree["series"]),
+            code: baseIdentity?.code,
+            base,
+            number: s(tree["supplement_number"]),
+            // The captured space marks the SPACED ordinal; absence = glued.
+            number_glued: tree["supplement_space"] === undefined,
+            slash_joined: tree["supplement_slash"] !== undefined,
+            date,
+            language: normLanguage(tree["language"]),
+            series_word: base !== undefined ? baseIdentity?.series_word === true : tree["series_word"] !== undefined,
+        };
+        if (tree["technical"] !== undefined && kind === "corrigendum")
+            attrs["technical"] = true;
+        return new ITU_CLASSES[kind](attrs);
+    }
+}
+export function ituGrammarImplementation() {
+    const builder = new ItuBuilder();
+    return {
+        parse(input) {
+            const tree = parseGrammar(ituGrammar, normalizeWhitespaceItu(input));
+            if (typeof tree !== "object" || tree === null) {
+                throw new ParseFailed("ITU: unexpected parse tree", 0);
+            }
+            return builder.build(tree);
+        },
+    };
+}

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

@@ -0,0 +1,184 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import { type FieldMapping } from "../../model/attribute.js";
+import { PubidDate } from "../../model/component.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+import { Component } from "../../model/component.js";
+/**
+ * Port of lib/pubid/itu/identifiers/* + components/{code,designation}.rb.
+ * The wire hash is FLAT (StandardSerialization / the Supplement block):
+ * sector/series/number/parts/… are bare top-level scalars read through
+ * the ItuCode component; publisher ("ITU") is never serialized
+ * (reconstructed on render).
+ */
+/** Long-form ↔ single-letter language map (Identifiers::Base::LANGUAGES). */
+export declare const ITU_LANGUAGES: Record<string, string>;
+/** The ITU Code component (Components::Code): [Imp]NUMBER[suffix][.subseries][-parts][qualifier]. */
+export declare class ItuCode extends Component {
+    readonly imp_marker?: string | undefined;
+    readonly number?: string | undefined;
+    readonly series_suffix?: string | undefined;
+    readonly series_suffix_spaced: boolean;
+    readonly subseries?: string | undefined;
+    readonly parts: string[];
+    readonly qualifier?: string | undefined;
+    readonly qualifier_glued: boolean;
+    constructor(attrs: Record<string, unknown>);
+    render(): string;
+    /** Space-free form for URN/MR — keeps "D.200" and "D.200 R" distinct. */
+    compactS(): string;
+    toWire(): Record<string, unknown>;
+}
+/** One "/SERIES.CODE" joint designation (Components::Designation). */
+export declare class ItuDesignation extends Component {
+    readonly series?: string | undefined;
+    readonly code: ItuCode;
+    constructor(attrs: Record<string, unknown>);
+    render(): string;
+    toWire(): Record<string, unknown>;
+}
+export declare abstract class ItuIdentifier extends BaseIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly sector: string | undefined;
+    readonly series: string | undefined;
+    readonly code: ItuCode | undefined;
+    readonly date: PubidDate | undefined;
+    readonly language: string | undefined;
+    readonly version: string | undefined;
+    readonly series_word: boolean | undefined;
+    readonly series_dash: boolean | undefined;
+    readonly attachment: boolean | undefined;
+    readonly range_end: string | undefined;
+    readonly common_text_twin: string | undefined;
+    /** Walks `base` to the origin document (Pubid::Identifier#root). */
+    root(): ItuIdentifier;
+    /** " (M/YYYY)" / " (YYYY)" / "" — shared by every dated ITU type. */
+    dateSuffix(): string;
+    languageSuffix(): string;
+    twinSuffix(): string;
+    renderBase(): string;
+    render(): string;
+}
+export declare class ItuUrnGenerator extends BaseUrnGenerator<ItuIdentifier> {
+    generate(): string;
+    generateBaseUrn(id: ItuIdentifier): string;
+    generateSupplementUrn(id: ItuSupplement): string;
+}
+export declare class ItuRecommendation extends ItuIdentifier {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+}
+export declare class ItuReport extends ItuIdentifier {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    renderBase(): string;
+}
+export declare class ItuHandbook extends ItuIdentifier {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    renderBase(): string;
+}
+export declare class ItuSpecialPublication extends ItuIdentifier {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    renderBase(): string;
+}
+export declare class ItuContribution extends ItuIdentifier {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    renderBase(): string;
+}
+export declare class ItuQuestion extends ItuIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly study_group: string | undefined;
+    readonly has_bl: boolean | undefined;
+    readonly bracketed: boolean | undefined;
+    readonly has_colon: boolean | undefined;
+    renderBase(): string;
+}
+export declare class ItuCombinedIdentifier extends ItuIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly combined: ItuDesignation[];
+    renderBase(): string;
+}
+export declare abstract class ItuSupplement extends ItuIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    readonly base: ItuIdentifier | undefined;
+    readonly number: string | undefined;
+    readonly number_glued: boolean | undefined;
+    readonly slash_joined: boolean | undefined;
+    renderSupplement(label: string): string;
+}
+export declare class ItuSupplementSuppl extends ItuSupplement {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    render(): string;
+}
+export declare class ItuAmendment extends ItuSupplement {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    render(): string;
+}
+export declare class ItuAddendum extends ItuSupplement {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    render(): string;
+}
+export declare class ItuErrata extends ItuSupplement {
+    static polymorphicName: string;
+    static mappings: FieldMapping[];
+    render(): string;
+}
+export declare class ItuCorrigendum extends ItuSupplement {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly technical: boolean | undefined;
+    render(): string;
+}
+export declare class ItuAnnexOfRecommendation extends ItuIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly base: ItuIdentifier | undefined;
+    readonly number: string | undefined;
+    renderBase(): string;
+}
+export declare class ItuAppendixOfRecommendation extends ItuIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly base: ItuIdentifier | undefined;
+    readonly number: string | undefined;
+    readonly material: string | undefined;
+    renderBase(): string;
+}
+export declare class ItuAnnex extends ItuIdentifier {
+    static polymorphicName: string;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly base: ItuIdentifier | undefined;
+    renderBase(): string;
+}
+/** The builder's class table (kind token → class). */
+export declare const ITU_CLASSES: {
+    readonly recommendation: typeof ItuRecommendation;
+    readonly report: typeof ItuReport;
+    readonly handbook: typeof ItuHandbook;
+    readonly special_publication: typeof ItuSpecialPublication;
+    readonly contribution: typeof ItuContribution;
+    readonly question: typeof ItuQuestion;
+    readonly combined: typeof ItuCombinedIdentifier;
+    readonly supplement: typeof ItuSupplementSuppl;
+    readonly amendment: typeof ItuAmendment;
+    readonly addendum: typeof ItuAddendum;
+    readonly errata: typeof ItuErrata;
+    readonly corrigendum: typeof ItuCorrigendum;
+    readonly annex_of: typeof ItuAnnexOfRecommendation;
+    readonly appendix_of: typeof ItuAppendixOfRecommendation;
+    readonly annex_to: typeof ItuAnnex;
+};
+export type ItuKind = keyof typeof ITU_CLASSES;