@pubid/pubid 0.1.3 → 0.1.4

package/dist/flavors/api/index.js

@@ -0,0 +1,71 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { apiGrammar, preprocessApi } from "./grammar.js";
+import { TypelessStandardClass, TYPE_CLASS_MAP } from "./model.js";
+/**
+ * Port of lib/pubid/api/builder.rb — type dispatch plus the shared
+ * base-builder assignment loop (chapter routes into `number`; :type is
+ * dispatch-only and dropped).
+ */
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const strv = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    if (Array.isArray(v)) {
+        if (v.length === 0)
+            return undefined;
+        const joined = v.flat(10).map(String).join("");
+        return joined.length > 0 ? joined : undefined;
+    }
+    const s = String(v).trim();
+    return s.length > 0 ? s : undefined;
+};
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+function castValue(key, value) {
+    if (key === "reaffirmation") {
+        return isObj(value) ? strv(value["year"]) : strv(value);
+    }
+    return strv(value);
+}
+function assignAttributes(identifier, data) {
+    const self = identifier;
+    const known = new Set([
+        "publisher", "number", "part", "subpart", "year", "reaffirmation",
+        "section", "subsection",
+    ]);
+    for (const [key, value] of Object.entries(data)) {
+        if (key === "type")
+            continue;
+        if (key === "chapter") {
+            const chapter = strv(value);
+            if (chapter !== undefined)
+                self["number"] = chapter;
+            continue;
+        }
+        // :part_number is a parse-tree key the gem's base builder silently
+        // drops (not an attribute) — matched 1:1.
+        if (!known.has(key))
+            continue;
+        const realized = castValue(key, value);
+        if (realized !== undefined)
+            self[key] = realized;
+    }
+}
+export function buildApiIdentifier(tree) {
+    const data = flatten(tree);
+    const typeStr = strv(data["type"]);
+    const klass = (typeStr !== undefined ? TYPE_CLASS_MAP[typeStr] : undefined)
+        ?? TypelessStandardClass;
+    const identifier = new klass();
+    assignAttributes(identifier, data);
+    return identifier;
+}
+export function apiGrammarImplementation() {
+    return {
+        parse(input) {
+            const tree = parseGrammar(apiGrammar, preprocessApi(input));
+            return buildApiIdentifier(tree);
+        },
+    };
+}

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

@@ -0,0 +1,27 @@
+import { BaseIdentifier } from "../../model/identifier.js";
+import type { IdentifierStatic } from "../../model/identifier.js";
+import { type AttributeTable, type FieldMapping } from "../../model/attribute.js";
+export declare abstract class ApiIdentifier extends BaseIdentifier {
+    static attributes: AttributeTable;
+    static mappings: FieldMapping[];
+    readonly publisher: string | undefined;
+    readonly number: string | undefined;
+    readonly part: string | undefined;
+    readonly subpart: string | undefined;
+    readonly year: string | undefined;
+    readonly reaffirmation: string | undefined;
+    constructor(attrs?: Record<string, unknown>);
+    /** The printed type token (plain method on the Ruby leaf, never a wire attribute). */
+    typeString(): string | undefined;
+    render(): string;
+}
+export declare const BulletinClass: IdentifierStatic;
+export declare const RecommendedPracticeClass: IdentifierStatic;
+export declare const SpecificationClass: IdentifierStatic;
+export declare const StandardClass: IdentifierStatic;
+export declare const TechnicalReportClass: IdentifierStatic;
+export declare const ContinuousOperationsStandardClass: IdentifierStatic;
+export declare const PublicationClass: IdentifierStatic;
+export declare const TypelessStandardClass: IdentifierStatic;
+export declare const MpmsClass: IdentifierStatic;
+export declare const TYPE_CLASS_MAP: Record<string, IdentifierStatic>;

package/dist/flavors/api/model.js

@@ -0,0 +1,114 @@
+import { BaseIdentifier, registerType } from "../../model/identifier.js";
+import { keyValue, extendAttributes } from "../../model/attribute.js";
+import { BaseUrnGenerator } from "../../model/urn-generator.js";
+/**
+ * Port of lib/pubid/api: the shared base, the eight typed leaf
+ * classes plus TypelessStandard, the renderer and the URN generator.
+ */
+const BASE_ATTRS = {
+    publisher: { type: "string", default: "API" },
+    number: { type: "string" },
+    part: { type: "string" },
+    subpart: { type: "string" },
+    year: { type: "string" },
+    reaffirmation: { type: "string" },
+};
+const BASE_MAPPINGS = keyValue({ wire: "publisher", to: "publisher" }, { wire: "number", to: "number" }, { wire: "part", to: "part" }, { wire: "subpart", to: "subpart" }, { wire: "year", to: "year" }, { wire: "reaffirmation", to: "reaffirmation" });
+export class ApiIdentifier extends BaseIdentifier {
+    static attributes = extendAttributes(BaseIdentifier, BASE_ATTRS);
+    static mappings = BASE_MAPPINGS;
+    constructor(attrs = {}) {
+        super(attrs);
+        const self = this;
+        if (self["publisher"] === undefined)
+            self["publisher"] = "API";
+    }
+    /** The printed type token (plain method on the Ruby leaf, never a wire attribute). */
+    typeString() {
+        return undefined;
+    }
+    render() {
+        const parts = ["API"];
+        if (this.typeString() !== undefined)
+            parts.push(this.typeString());
+        const code = codePortion(this);
+        if (code !== undefined)
+            parts.push(code);
+        let result = parts.join(" ");
+        if (this.year !== undefined)
+            result += `-${this.year}`;
+        if (this.reaffirmation !== undefined)
+            result += ` (R${this.reaffirmation})`;
+        return result;
+    }
+}
+function codePortion(id) {
+    if (id.number === undefined)
+        return undefined;
+    return id.part !== undefined ? `${id.number}-${id.part}` : id.number;
+}
+class ApiUrnGenerator extends BaseUrnGenerator {
+    generate() {
+        const id = this.identifier;
+        const parts = ["urn", "api", "std"];
+        if (id.number !== undefined)
+            parts.push(id.number);
+        if (id.part !== undefined)
+            parts.push(`-${id.part}`);
+        if (id.year !== undefined)
+            parts.push(id.year);
+        parts[1] = id.publisher !== undefined ? id.publisher.toLowerCase() : "api";
+        return parts.join(":");
+    }
+}
+function apiClass(spec, extraAttrs = {}, render) {
+    class ApiConcrete extends ApiIdentifier {
+        static polymorphicName = `pubid:api:${spec.kind}`;
+        static urnGenerator = ApiUrnGenerator;
+        static attributes = extendAttributes(ApiIdentifier, extraAttrs);
+        static mappings = [
+            ...BASE_MAPPINGS,
+            ...Object.keys(extraAttrs).map((k) => ({ wire: k, to: k })),
+        ];
+        typeString() {
+            return spec.typeString;
+        }
+        render() {
+            return render !== undefined ? render(this) : super.render();
+        }
+    }
+    registerType(ApiConcrete);
+    return ApiConcrete;
+}
+export const BulletinClass = apiClass({ kind: "bulletin", typeString: "BULL" });
+export const RecommendedPracticeClass = apiClass({ kind: "recommended-practice", typeString: "RP" });
+export const SpecificationClass = apiClass({ kind: "specification", typeString: "SPEC" });
+export const StandardClass = apiClass({ kind: "standard", typeString: "STD" });
+export const TechnicalReportClass = apiClass({ kind: "technical-report", typeString: "TR" });
+export const ContinuousOperationsStandardClass = apiClass({ kind: "continuous-operations-standard", typeString: "COS" });
+export const PublicationClass = apiClass({ kind: "publication", typeString: "PUBL" });
+export const TypelessStandardClass = apiClass({ kind: "typeless-standard" });
+export const MpmsClass = apiClass({ kind: "mpms", typeString: "MPMS" }, { section: { type: "string" }, subsection: { type: "string" } }, (id) => {
+    const self = id;
+    const parts = ["API", "MPMS"];
+    if (id.number !== undefined)
+        parts.push(`CH ${id.number}`);
+    if (self.section !== undefined) {
+        parts.push(`.${self.section}`);
+        if (self.subsection !== undefined)
+            parts.push(`.${self.subsection}`);
+    }
+    if (id.year !== undefined)
+        parts.push(`-${id.year}`);
+    return parts.join(" ").replaceAll(" .", ".");
+});
+export const TYPE_CLASS_MAP = {
+    BULL: BulletinClass,
+    MPMS: MpmsClass,
+    RP: RecommendedPracticeClass,
+    SPEC: SpecificationClass,
+    STD: StandardClass,
+    TR: TechnicalReportClass,
+    COS: ContinuousOperationsStandardClass,
+    PUBL: PublicationClass,
+};

package/dist/flavors/ashrae/grammar.d.ts

@@ -0,0 +1,2 @@
+import { Grammar } from "../../grammar/engine.js";
+export declare const ashraeGrammar: Grammar;