@pubid/pubid 0.1.3 → 0.1.5

package/dist/flavors/ashrae/index.js

@@ -0,0 +1,306 @@
+import { parseGrammar } from "../../grammar/engine.js";
+import { ashraeGrammar } from "./grammar.js";
+import { preprocessAshrae } from "./preprocessor.js";
+import { PubidDate } from "../../model/component.js";
+import { AddendaPackage, Addendum, CombinedAddenda, Errata, Guideline, Interpretation, Standard, } from "./model.js";
+/**
+ * Port of lib/pubid/ashrae/builder.rb — attribute extraction, class
+ * selection, and the five supplement build paths.
+ */
+const MONTH_NAMES = [
+    "January", "February", "March", "April", "May", "June", "July",
+    "August", "September", "October", "November", "December",
+];
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function flatten(data) {
+    return Array.isArray(data) ? Object.assign({}, ...data) : data;
+}
+function value(v) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (Array.isArray(v)) {
+        if (v.length === 0)
+            return undefined;
+        const joined = v.join("");
+        return joined.length > 0 ? joined : undefined;
+    }
+    const s = String(v).trim();
+    return s.length > 0 ? s : undefined;
+}
+function leafClass(type) {
+    return type === "Guideline" ? Guideline : Standard;
+}
+function buildLeaf(attrs) {
+    return new (leafClass(attrs["type"]))(attrs);
+}
+function extractAttributes(parsed) {
+    const attributes = {};
+    const publisher = value(parsed["publisher"]);
+    if (publisher !== undefined)
+        attributes["publisher"] = publisher;
+    attributes["type"] = value(parsed["type"]) ?? "Standard";
+    const codeWithYear = parsed["code_with_year"];
+    if (isObj(codeWithYear)) {
+        const code = value(codeWithYear["code"]);
+        if (code !== undefined)
+            attributes["number"] = code;
+        const year = value(codeWithYear["year"]);
+        if (year !== undefined)
+            attributes["year"] = year;
+    }
+    else if (codeWithYear === undefined) {
+        const code = value(parsed["code"]);
+        if (code !== undefined)
+            attributes["number"] = code;
+    }
+    if (attributes["year"] === undefined) {
+        const year = value(parsed["year"]);
+        if (year !== undefined)
+            attributes["year"] = year;
+    }
+    const suffix = value(parsed["suffix"]);
+    if (suffix !== undefined)
+        attributes["suffix"] = suffix;
+    const reaffirmed = value(parsed["reaffirmed"]);
+    if (reaffirmed !== undefined)
+        attributes["reaffirmed"] = reaffirmed;
+    const copublisher = value(parsed["copublisher"]);
+    if (copublisher !== undefined)
+        attributes["copublisher"] = copublisher;
+    return attributes;
+}
+function extractBaseAttributes(parsed) {
+    // Unwrap the :base subtree the supplement grammars nest the base
+    // document under.
+    const data = isObj(parsed["base"]) ? parsed["base"] : parsed;
+    const attributes = {};
+    const publisher = value(data["publisher"]);
+    if (publisher !== undefined)
+        attributes["publisher"] = publisher;
+    const copublisher = value(data["copublisher"]);
+    if (copublisher !== undefined)
+        attributes["copublisher"] = copublisher;
+    attributes["type"] = value(data["type"]) ?? "Standard";
+    const codeWithYear = data["code_with_year"];
+    if (isObj(codeWithYear)) {
+        const code = value(codeWithYear["code"]);
+        if (code !== undefined)
+            attributes["number"] = code;
+        const year = value(codeWithYear["year"]);
+        if (year !== undefined)
+            attributes["year"] = year;
+    }
+    else {
+        const code = value(data["code"]);
+        if (code !== undefined)
+            attributes["number"] = code;
+        const year = value(data["year"]);
+        if (year !== undefined)
+            attributes["year"] = year;
+    }
+    const suffix = value(data["suffix"]);
+    if (suffix !== undefined)
+        attributes["suffix"] = suffix;
+    const reaffirmed = value(data["reaffirmed"]);
+    if (reaffirmed !== undefined)
+        attributes["reaffirmed"] = reaffirmed;
+    return attributes;
+}
+function pad2(v) {
+    return String(Number(v)).padStart(2, "0");
+}
+function errataDateOf(errataDate) {
+    if (!isObj(errataDate))
+        return undefined;
+    const numeric = value(errataDate["numeric_date"]);
+    if (numeric !== undefined) {
+        const [month, day, year] = numeric.replaceAll(" ", "").split("-");
+        return new PubidDate({ year, month: pad2(month), day: pad2(day) });
+    }
+    const monthName = value(errataDate["month"]);
+    const month = monthName === undefined ? undefined : MONTH_NAMES.indexOf(monthName) + 1;
+    const day = value(errataDate["day"]);
+    if (month === undefined || month === 0 || day === undefined)
+        return undefined;
+    return new PubidDate({
+        year: value(errataDate["errata_year"]),
+        month: pad2(String(month)),
+        day: pad2(day),
+    });
+}
+function buildErrata(parsed) {
+    const base = buildLeaf(extractBaseAttributes(parsed));
+    return new Errata({ base, date: errataDateOf(parsed["errata_date"]) });
+}
+function buildAddendum(parsed) {
+    const base = buildLeaf(extractBaseAttributes(parsed));
+    return new Addendum({
+        base,
+        addendum_code: value(parsed["addendum_code"]),
+    });
+}
+function buildPublisherAddendum(parsed) {
+    // The copublisher rides BOTH the addendum and its base (the gem
+    // records it at both levels).
+    const copublisher = value(parsed["copublisher"]);
+    const base = buildLeaf({
+        type: value(parsed["type"]),
+        number: value(parsed["code"]),
+        year: value(parsed["year"]),
+        ...(copublisher !== undefined ? { copublisher } : {}),
+    });
+    return new Addendum({
+        base,
+        addendum_code: value(parsed["addendum_code"]),
+        ...(copublisher !== undefined ? { copublisher } : {}),
+    });
+}
+function codeWithYearBaseAttrs(parsed) {
+    const baseAttrs = { type: "Standard" };
+    const copublisher = value(parsed["copublisher"]);
+    if (copublisher !== undefined)
+        baseAttrs["copublisher"] = copublisher;
+    const codeWithYear = parsed["code_with_year"];
+    if (isObj(codeWithYear)) {
+        const code = value(codeWithYear["code"]);
+        if (code !== undefined)
+            baseAttrs["number"] = code;
+        const year = value(codeWithYear["year"]);
+        if (year !== undefined)
+            baseAttrs["year"] = year;
+    }
+    return baseAttrs;
+}
+function buildCombinedAddenda(parsed) {
+    const baseAttrs = {};
+    if (isObj(parsed["code_with_year"])) {
+        const code = value(parsed["code_with_year"]["code"]);
+        if (code !== undefined)
+            baseAttrs["number"] = code;
+        const year = value(parsed["code_with_year"]["year"]);
+        if (year !== undefined)
+            baseAttrs["year"] = year;
+    }
+    else {
+        baseAttrs["type"] = value(parsed["type"]) ?? "Standard";
+        const code = value(parsed["code"]);
+        if (code !== undefined)
+            baseAttrs["number"] = code;
+        const year = value(parsed["year"]);
+        if (year !== undefined)
+            baseAttrs["year"] = year;
+    }
+    const copublisher = value(parsed["copublisher"]);
+    if (copublisher !== undefined)
+        baseAttrs["copublisher"] = copublisher;
+    const publisher = value(parsed["publisher"]);
+    if (publisher !== undefined)
+        baseAttrs["publisher"] = publisher;
+    const base = buildLeaf(baseAttrs);
+    const firstCode = value(parsed["addendum_code"]);
+    // The "a through z" range form yields a single object, not an array.
+    const additionalRaw = parsed["additional_codes"];
+    const additionalCodes = Array.isArray(additionalRaw)
+        ? additionalRaw
+        : additionalRaw !== undefined && additionalRaw !== null
+            ? [additionalRaw]
+            : undefined;
+    let addendumCodes;
+    if (firstCode !== undefined || additionalCodes !== undefined) {
+        const codeList = [];
+        if (Array.isArray(additionalCodes)) {
+            // The repetition subtrees nest (iteration arrays around the
+            // captured objects); flatten before extracting each code.
+            for (const code of additionalCodes.flat(Infinity)) {
+                const codeStr = isObj(code)
+                    ? value(code["addendum_code"])
+                    : value(code);
+                if (codeStr !== undefined && codeStr !== "and")
+                    codeList.push(codeStr);
+            }
+        }
+        addendumCodes = firstCode ?? "";
+        if (codeList.length > 0) {
+            addendumCodes += `, ${codeList.join(", ")}`;
+        }
+    }
+    return new CombinedAddenda({ base, addendum_codes: addendumCodes });
+}
+function buildAddendaPackage(parsed) {
+    const base = buildLeaf(extractBaseAttributes(parsed));
+    return new AddendaPackage({
+        base,
+        package_description: value(parsed["package_description"]),
+    });
+}
+export function buildAshraeIdentifier(tree) {
+    let parsed = flatten(tree);
+    if (parsed["errata_keyword"] !== undefined) {
+        return buildErrata(parsed);
+    }
+    if (parsed["interpretation_identifier"] !== undefined) {
+        const data = flatten(parsed["interpretation_identifier"]);
+        const baseAttrs = extractBaseAttributes(flatten(data["base"]));
+        const base = buildLeaf(baseAttrs);
+        return new Interpretation({ base });
+    }
+    if (parsed["combined_addenda"] !== undefined) {
+        return buildCombinedAddenda(flatten(parsed["combined_addenda"]));
+    }
+    if (parsed["addenda_package"] !== undefined) {
+        return buildAddendaPackage(flatten(parsed["addenda_package"]));
+    }
+    if (parsed["addendum_identifier"] !== undefined) {
+        return buildAddendum(flatten(parsed["addendum_identifier"]));
+    }
+    if (parsed["publisher_addendum"] !== undefined) {
+        return buildPublisherAddendum(flatten(parsed["publisher_addendum"]));
+    }
+    if (parsed["publisher_addendum_copublisher"] !== undefined) {
+        const data = flatten(parsed["publisher_addendum_copublisher"]);
+        return buildPublisherAddendum({
+            copublisher: data["copublisher"],
+            type: value(data["type"]) ?? "Standard",
+            code: data["code"],
+            year: data["year"],
+            addendum_code: data["addendum_code"],
+        });
+    }
+    if (parsed["publisher_addendum_copublisher_no_type"] !== undefined) {
+        return buildAddendumFromCodeWithYear(flatten(parsed["publisher_addendum_copublisher_no_type"]));
+    }
+    if (parsed["addendum_no_type"] !== undefined) {
+        const data = flatten(parsed["addendum_no_type"]);
+        return buildAddendumFromCodeWithYear(data);
+    }
+    if (parsed["standard_addendum"] !== undefined) {
+        return buildAddendum(flatten(parsed["standard_addendum"]));
+    }
+    if (parsed["addendum"] !== undefined) {
+        return buildAddendum(flatten(parsed["addendum"]));
+    }
+    if (parsed["publisher_base_addendum"] !== undefined) {
+        return buildAddendum(flatten(parsed["publisher_base_addendum"]));
+    }
+    if (isObj(parsed["base"])) {
+        parsed = parsed["base"];
+    }
+    const attributes = extractAttributes(parsed);
+    return buildLeaf(attributes);
+}
+function buildAddendumFromCodeWithYear(data) {
+    const base = buildLeaf(codeWithYearBaseAttrs(data));
+    return new Addendum({
+        base,
+        addendum_code: value(data["addendum_code"]),
+    });
+}
+export function ashraeGrammarImplementation() {
+    return {
+        parse(input) {
+            const cleaned = preprocessAshrae(input);
+            const tree = parseGrammar(ashraeGrammar, cleaned);
+            return buildAshraeIdentifier(tree);
+        },
+    };
+}

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

@@ -0,0 +1,87 @@
+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";
+declare class AshraeUrnGenerator extends BaseUrnGenerator<AshraeIdentifier> {
+    generate(): string;
+}
+export declare abstract class AshraeIdentifier extends BaseIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly publisher: string | undefined;
+    readonly copublisher: string | undefined;
+    readonly type: string | undefined;
+    readonly suffix: string | undefined;
+    readonly amendment: string | undefined;
+    readonly reaffirmed: string | undefined;
+    readonly year: string | undefined;
+    root(): AshraeIdentifier;
+}
+export declare class Standard extends AshraeIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof AshraeUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly number: string | undefined;
+    constructor(attrs?: Record<string, unknown>);
+    render(): string;
+}
+export declare class Guideline extends AshraeIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof AshraeUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly number: string | undefined;
+    constructor(attrs?: Record<string, unknown>);
+    render(): string;
+}
+export declare abstract class SupplementIdentifier extends AshraeIdentifier {
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly base: AshraeIdentifier | undefined;
+    root(): AshraeIdentifier;
+}
+declare function delegatedCopublisher(model: BaseIdentifier, hash: Record<string, unknown>): void;
+export declare class Addendum extends SupplementIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof AshraeUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static compactHash: typeof delegatedCopublisher;
+    readonly addendum_code: string | undefined;
+    readonly addendum_date: string | undefined;
+    render(): string;
+}
+export declare class CombinedAddenda extends SupplementIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof AshraeUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static compactHash: typeof delegatedCopublisher;
+    readonly addendum_codes: string | undefined;
+    readonly connector: string | undefined;
+    render(): string;
+}
+export declare class AddendaPackage extends SupplementIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof AshraeUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    static compactHash: typeof delegatedCopublisher;
+    readonly package_description: string | undefined;
+    render(): string;
+}
+export declare class Errata extends SupplementIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof AshraeUrnGenerator;
+    static attributes: import("../../model/attribute.js").AttributeTable;
+    static mappings: FieldMapping[];
+    readonly date: PubidDate | undefined;
+    render(): string;
+}
+export declare class Interpretation extends SupplementIdentifier {
+    static polymorphicName: string;
+    static urnGenerator: typeof AshraeUrnGenerator;
+    render(): string;
+}
+export {};