@bitbybit-dev/ifc 0.0.0-stage → 1.5.0-rc.0

package/lib/step/encoder.js

@@ -0,0 +1,321 @@
+import { GLOBAL_ID_PATTERN, GLOBAL_ID_TYPE } from "../schema/constants";
+import { SIMPLE_TYPES } from "../schema/schema";
+import { IfcValueError, ValueProblem } from "./errors";
+import { formatInteger, formatReal } from "./numbers";
+import { encodeString } from "./strings";
+import { DERIVED, isBinary, isDerived, isEnumeration, isList, isReference, isTyped } from "./values";
+const BINARY_DIGITS = /^[0-3][0-9A-Fa-f]*$/;
+function describe(value) {
+    if (value === null) {
+        return "nothing";
+    }
+    if (isDerived(value)) {
+        return "the derived marker";
+    }
+    if (isList(value)) {
+        return "a list";
+    }
+    if (isReference(value)) {
+        return `a reference to #${value.ref}`;
+    }
+    if (isEnumeration(value)) {
+        return `the enumeration value ${value.enum}`;
+    }
+    if (isTyped(value)) {
+        return `a typed ${value.type}`;
+    }
+    if (typeof value === "string") {
+        return "a text";
+    }
+    return typeof value === "number" || typeof value === "boolean" ? `${typeof value} ${value}` : "an unknown value";
+}
+function within(error, segment) {
+    return error instanceof ValueProblem ? error.within(segment) : error;
+}
+function checkSimple(spec, value) {
+    switch (spec) {
+        case "REAL":
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                throw new ValueProblem(`expected a finite real number, got ${describe(value)}`);
+            }
+            return;
+        case "INTEGER":
+            if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+                throw new ValueProblem(`expected a whole number, got ${describe(value)}`);
+            }
+            return;
+        case "NUMBER":
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                throw new ValueProblem(`expected a finite number, got ${describe(value)}`);
+            }
+            return;
+        case "STRING":
+            if (typeof value !== "string") {
+                throw new ValueProblem(`expected a text, got ${describe(value)}`);
+            }
+            return;
+        case "BOOLEAN":
+            if (typeof value !== "boolean") {
+                throw new ValueProblem(`expected true or false, got ${describe(value)}`);
+            }
+            return;
+        case "LOGICAL":
+            if (typeof value !== "boolean" && !(isEnumeration(value) && value.enum === "U")) {
+                throw new ValueProblem(`expected true, false or unknown, got ${describe(value)}`);
+            }
+            return;
+        default:
+            if (!isBinary(value)) {
+                throw new ValueProblem(`expected a binary value, got ${describe(value)}`);
+            }
+            if (!BINARY_DIGITS.test(value.binary)) {
+                throw new ValueProblem("a binary value is a digit from 0 to 3 followed by hexadecimal digits");
+            }
+    }
+}
+function formatSimple(spec, value) {
+    checkSimple(spec, value);
+    if (typeof value === "number") {
+        return spec === "REAL" || (spec === "NUMBER" && !Number.isSafeInteger(value)) ? formatReal(value) : formatInteger(value);
+    }
+    if (typeof value === "string") {
+        return encodeString(value);
+    }
+    if (typeof value === "boolean") {
+        return value ? ".T." : ".F.";
+    }
+    return isBinary(value) ? `"${value.binary.toUpperCase()}"` : ".U.";
+}
+function checkBounds(spec, value) {
+    const [kind, lower, upper] = spec;
+    if (kind === "ARRAY" && upper !== null) {
+        if (value.length !== upper - lower + 1) {
+            throw new ValueProblem(`an ARRAY [${lower}:${upper}] holds exactly ${upper - lower + 1} values, got ${value.length}`);
+        }
+    }
+    else if (value.length < lower || (upper !== null && value.length > upper)) {
+        throw new ValueProblem(`a ${kind} of ${lower} to ${upper !== null && upper !== void 0 ? upper : "any number of"} values, got ${value.length}`);
+    }
+}
+export class IfcEncoder {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    normalizeArguments(type, args, path) {
+        const info = this.writable(type, args.length, path);
+        return info.attributes.map((_, index) => this.normalizeAttribute(info, index, args[index], path));
+    }
+    normalizeAttribute(info, index, value, path) {
+        const attribute = info.attributes[index];
+        try {
+            if (attribute.derived) {
+                if (value !== null && !isDerived(value)) {
+                    throw new ValueProblem("the attribute is derived and takes no value");
+                }
+                return DERIVED;
+            }
+            if (value === null) {
+                if (!attribute.optional) {
+                    throw new ValueProblem("the attribute is required");
+                }
+                return null;
+            }
+            return this.normalize(attribute.type, value);
+        }
+        catch (error) {
+            throw this.located(error, path, info, index);
+        }
+    }
+    encodeEntity(entity) {
+        const path = `#${entity.id}`;
+        const info = this.writable(entity.type, entity.args.length, path);
+        const parts = info.attributes.map((attribute, index) => {
+            const value = entity.args[index];
+            try {
+                if (attribute.derived) {
+                    if (value !== null && !isDerived(value)) {
+                        throw new ValueProblem("the attribute is derived and takes no value");
+                    }
+                    return "*";
+                }
+                if (value === null) {
+                    if (!attribute.optional) {
+                        throw new ValueProblem("the attribute is required");
+                    }
+                    return "$";
+                }
+                return this.format(attribute.type, value);
+            }
+            catch (error) {
+                throw this.located(error, path, info, index);
+            }
+        });
+        return `#${entity.id}=${info.name.toUpperCase()}(${parts.join(",")});`;
+    }
+    encodeValue(spec, value, path) {
+        try {
+            return this.format(spec, value);
+        }
+        catch (error) {
+            if (error instanceof ValueProblem) {
+                throw new IfcValueError(`${path}${error.segments.join("")}`, error.message);
+            }
+            throw error;
+        }
+    }
+    writable(type, count, path) {
+        const info = this.schema.entity(type);
+        if (info.abstract) {
+            throw new IfcValueError(path, `${info.name} is abstract and cannot be written`);
+        }
+        if (count !== info.attributes.length) {
+            throw new IfcValueError(path, `${info.name} has ${info.attributes.length} attributes, got ${count} values`);
+        }
+        return info;
+    }
+    located(error, path, info, index) {
+        if (!(error instanceof ValueProblem)) {
+            return error;
+        }
+        return new IfcValueError(`${path} ${info.name}.${info.attributes[index].name}${error.segments.join("")}`, error.message);
+    }
+    enumMember(spec, members, value) {
+        const member = typeof value === "string" ? value.toUpperCase() : isEnumeration(value) ? value.enum : undefined;
+        if (member === undefined || !members.includes(member)) {
+            throw new ValueProblem(`expected one of ${members.join(", ")} for ${spec}, got ${describe(value)}`);
+        }
+        return member;
+    }
+    selected(select, value) {
+        const contents = this.schema.selectContents(select);
+        if (isReference(value)) {
+            if (!contents.entities.length) {
+                throw new ValueProblem(`${select} takes typed values, not references`);
+            }
+            return undefined;
+        }
+        if (!isTyped(value)) {
+            throw new ValueProblem(`${select} needs a typed value or a reference, got ${describe(value)}`);
+        }
+        const typeName = this.schema.typeName(value.type);
+        if (typeName === undefined || !contents.valueTypes.has(typeName)) {
+            throw new ValueProblem(`${value.type} is not one of the types ${select} accepts`);
+        }
+        return { type: typeName, value: value.value };
+    }
+    definedValue(spec, value) {
+        if (!isTyped(value)) {
+            return value;
+        }
+        if (this.schema.typeName(value.type) !== this.schema.typeName(spec)) {
+            throw new ValueProblem(`expected ${spec}, got a typed ${value.type}`);
+        }
+        return value.value;
+    }
+    checkGlobalId(spec, value) {
+        if (spec === GLOBAL_ID_TYPE && (typeof value !== "string" || !GLOBAL_ID_PATTERN.test(value))) {
+            throw new ValueProblem("a GlobalId is 22 characters of 0-9, A-Z, a-z, _ and $, the first from 0 to 3");
+        }
+    }
+    normalize(spec, value) {
+        if (value === null || isDerived(value)) {
+            throw new ValueProblem(`expected a value, got ${describe(value)}`);
+        }
+        if (typeof spec !== "string") {
+            return this.normalizeList(spec, value);
+        }
+        if (SIMPLE_TYPES.has(spec)) {
+            checkSimple(spec, value);
+            return value;
+        }
+        if (this.schema.hasEntity(spec)) {
+            if (!isReference(value)) {
+                throw new ValueProblem(`expected a reference to an ${spec}, got ${describe(value)}`);
+            }
+            return value;
+        }
+        const type = this.schema.type(spec);
+        if ("e" in type) {
+            return { enum: this.enumMember(spec, type.e, value) };
+        }
+        if ("s" in type) {
+            const chosen = this.selected(spec, value);
+            return chosen === undefined ? value : { type: chosen.type, value: this.normalize(chosen.type, chosen.value) };
+        }
+        const inner = this.definedValue(spec, value);
+        this.checkGlobalId(this.schema.typeName(spec), inner);
+        return this.normalize(type.t, inner);
+    }
+    normalizeList(spec, value) {
+        if (!isList(value)) {
+            throw new ValueProblem(`expected a list, got ${describe(value)}`);
+        }
+        checkBounds(spec, value);
+        const member = spec[3];
+        const items = value.map((item, index) => {
+            try {
+                return this.normalize(member, item);
+            }
+            catch (error) {
+                throw within(error, `[${index}]`);
+            }
+        });
+        if (spec[0] === "SET") {
+            this.format(spec, items);
+        }
+        return items;
+    }
+    format(spec, value) {
+        if (value === null || isDerived(value)) {
+            throw new ValueProblem(`expected a value, got ${describe(value)}`);
+        }
+        if (typeof spec !== "string") {
+            if (!isList(value)) {
+                throw new ValueProblem(`expected a list, got ${describe(value)}`);
+            }
+            checkBounds(spec, value);
+            const parts = value.map((item, index) => {
+                try {
+                    return this.format(spec[3], item);
+                }
+                catch (error) {
+                    throw within(error, `[${index}]`);
+                }
+            });
+            if (spec[0] === "SET" && new Set(parts).size !== parts.length) {
+                throw new ValueProblem("a SET holds each value once, and this one repeats a value");
+            }
+            return `(${parts.join(",")})`;
+        }
+        if (SIMPLE_TYPES.has(spec)) {
+            return formatSimple(spec, value);
+        }
+        if (this.schema.hasEntity(spec)) {
+            if (!isReference(value)) {
+                throw new ValueProblem(`expected a reference to an ${spec}, got ${describe(value)}`);
+            }
+            return `#${value.ref}`;
+        }
+        const type = this.schema.type(spec);
+        if (!type) {
+            throw new ValueProblem(`the schema has no type ${spec}`);
+        }
+        if ("e" in type) {
+            return `.${this.enumMember(spec, type.e, value)}.`;
+        }
+        if ("s" in type) {
+            const chosen = this.selected(spec, value);
+            return chosen === undefined ? this.format(this.schema.selectContents(spec).entities[0], value) : `${chosen.type.toUpperCase()}(${this.format(chosen.type, chosen.value)})`;
+        }
+        return this.format(type.t, this.definedValue(spec, value));
+    }
+}
+const encoders = new WeakMap();
+export function encoderFor(schema) {
+    let encoder = encoders.get(schema);
+    if (!encoder) {
+        encoder = new IfcEncoder(schema);
+        encoders.set(schema, encoder);
+    }
+    return encoder;
+}

package/lib/step/errors.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A file that does not follow the ISO 10303-21 encoding, holds an entity id twice, names a schema
+ * this library does not read or an entity type its schema does not define, with the byte where the
+ * problem is. A row is decoded when it is first asked for, so a broken row raises it then.
+ * @beta
+ */
+export declare class StepSyntaxError extends Error {
+    /**
+     * The offset of the byte at which the problem was found.
+     */
+    readonly offset: number;
+    /**
+     * Makes the error.
+     * @param message - What is wrong
+     * @param offset - The offset of the byte at which the problem was found
+     */
+    constructor(message: string, offset: number);
+}
+/**
+ * An attribute value that its schema type does not accept, with the entity and attribute it was
+ * given for.
+ * @beta
+ */
+export declare class IfcValueError extends Error {
+    /**
+     * Where the value was given, such as `#12 IfcWall.Name` or `#12 IfcPolyline.Points[3]`.
+     */
+    readonly path: string;
+    /**
+     * Makes the error.
+     * @param path - Where the value was given
+     * @param message - What is wrong with it
+     */
+    constructor(path: string, message: string);
+}
+export declare class ValueProblem extends Error {
+    readonly segments: string[];
+    within(segment: string): ValueProblem;
+}

package/lib/step/errors.js

@@ -0,0 +1,45 @@
+/**
+ * A file that does not follow the ISO 10303-21 encoding, holds an entity id twice, names a schema
+ * this library does not read or an entity type its schema does not define, with the byte where the
+ * problem is. A row is decoded when it is first asked for, so a broken row raises it then.
+ * @beta
+ */
+export class StepSyntaxError extends Error {
+    /**
+     * Makes the error.
+     * @param message - What is wrong
+     * @param offset - The offset of the byte at which the problem was found
+     */
+    constructor(message, offset) {
+        super(`${message} at byte ${offset}`);
+        this.name = "StepSyntaxError";
+        this.offset = offset;
+    }
+}
+/**
+ * An attribute value that its schema type does not accept, with the entity and attribute it was
+ * given for.
+ * @beta
+ */
+export class IfcValueError extends Error {
+    /**
+     * Makes the error.
+     * @param path - Where the value was given
+     * @param message - What is wrong with it
+     */
+    constructor(path, message) {
+        super(`${path}: ${message}`);
+        this.name = "IfcValueError";
+        this.path = path;
+    }
+}
+export class ValueProblem extends Error {
+    constructor() {
+        super(...arguments);
+        this.segments = [];
+    }
+    within(segment) {
+        this.segments.unshift(segment);
+        return this;
+    }
+}

package/lib/step/file-index.d.ts

@@ -0,0 +1,2 @@
+import type { StepIndex } from "./step-types";
+export declare function indexStep(bytes: Uint8Array): StepIndex;

package/lib/step/file-index.js

@@ -0,0 +1,221 @@
+import { BOM, CHAR_EQUALS, CHAR_HASH, CHAR_LOWER_A, CHAR_LOWER_Z, CHAR_MINUS, CHAR_OPEN, CHAR_SEMICOLON, CHAR_ZERO, DECIMAL_RADIX, INITIAL_ROWS, MAX_EXPRESS_ID, MAX_FILE_BYTES, MAX_TYPE_CODES, TYPE_HASH_PRIME, UPPER_CASE_OFFSET, } from "./constants";
+import { StepSyntaxError } from "./errors";
+import { decodeArguments } from "./reader";
+import { closingParenthesis, isDigit, isNameCharacter, skipSpace, textOf } from "./scanner";
+function grown(array, make) {
+    const next = make(array.length * 2);
+    next.set(array);
+    return next;
+}
+function upperCased(code) {
+    return code >= CHAR_LOWER_A && code <= CHAR_LOWER_Z ? code - UPPER_CASE_OFFSET : code;
+}
+function spells(name, bytes, start, end) {
+    if (name.length !== end - start) {
+        return false;
+    }
+    for (let at = start; at < end; at++) {
+        if (name.charCodeAt(at - start) !== upperCased(bytes[at])) {
+            return false;
+        }
+    }
+    return true;
+}
+function typeCodeOf(rows, bytes, start, end) {
+    let hash = end - start;
+    for (let at = start; at < end; at++) {
+        hash = Math.imul(hash ^ upperCased(bytes[at]), TYPE_HASH_PRIME);
+    }
+    const candidates = rows.codesOfHash.get(hash);
+    for (const code of candidates !== null && candidates !== void 0 ? candidates : []) {
+        if (spells(rows.typeTable[code], bytes, start, end)) {
+            return code;
+        }
+    }
+    if (rows.typeTable.length === MAX_TYPE_CODES) {
+        throw new StepSyntaxError(`The file names more than ${MAX_TYPE_CODES} entity types`, start);
+    }
+    let name = "";
+    for (let at = start; at < end; at++) {
+        name += String.fromCharCode(upperCased(bytes[at]));
+    }
+    const code = rows.typeTable.push(name) - 1;
+    if (candidates) {
+        candidates.push(code);
+    }
+    else {
+        rows.codesOfHash.set(hash, [code]);
+    }
+    return code;
+}
+function addRow(rows, id, typeCode, spans) {
+    if (rows.count === rows.ids.length) {
+        rows.ids = grown(rows.ids, (n) => new Int32Array(n));
+        rows.typeCodes = grown(rows.typeCodes, (n) => new Uint16Array(n));
+        rows.argStart = grown(rows.argStart, (n) => new Uint32Array(n));
+        rows.argEnd = grown(rows.argEnd, (n) => new Uint32Array(n));
+        rows.rowStart = grown(rows.rowStart, (n) => new Uint32Array(n));
+        rows.rowEnd = grown(rows.rowEnd, (n) => new Uint32Array(n));
+    }
+    rows.ids[rows.count] = id;
+    rows.typeCodes[rows.count] = typeCode;
+    rows.rowStart[rows.count] = spans.rowStart;
+    rows.argStart[rows.count] = spans.argStart;
+    rows.argEnd[rows.count] = spans.argEnd;
+    rows.rowEnd[rows.count] = spans.rowEnd;
+    rows.count++;
+}
+function readKeyword(bytes, at) {
+    let end = at;
+    while (end < bytes.length && (isNameCharacter(bytes[end]) || bytes[end] === CHAR_MINUS)) {
+        end++;
+    }
+    return [textOf(bytes, at, end).toUpperCase(), end];
+}
+function expectSemicolon(bytes, at, after) {
+    const position = skipSpace(bytes, at, bytes.length);
+    if (bytes[position] !== CHAR_SEMICOLON) {
+        throw new StepSyntaxError(`Expected ';' after ${after}`, position);
+    }
+    return position + 1;
+}
+function expectKeyword(bytes, at, keyword) {
+    const position = skipSpace(bytes, at, bytes.length);
+    const [found, end] = readKeyword(bytes, position);
+    if (found !== keyword) {
+        throw new StepSyntaxError(`Expected ${keyword}`, position);
+    }
+    return end;
+}
+function readHeader(bytes, from) {
+    const header = [];
+    let at = expectSemicolon(bytes, expectKeyword(bytes, from, "HEADER"), "HEADER");
+    for (;;) {
+        at = skipSpace(bytes, at, bytes.length);
+        const [name, nameEnd] = readKeyword(bytes, at);
+        if (name === "ENDSEC") {
+            return [header, expectSemicolon(bytes, nameEnd, "ENDSEC"), at];
+        }
+        if (!name) {
+            throw new StepSyntaxError("Expected a header entity or ENDSEC", at);
+        }
+        const open = skipSpace(bytes, nameEnd, bytes.length);
+        if (bytes[open] !== CHAR_OPEN) {
+            throw new StepSyntaxError(`The header entity ${name} has no attribute list`, open);
+        }
+        const close = closingParenthesis(bytes, open, bytes.length);
+        const end = expectSemicolon(bytes, close + 1, name);
+        header.push({ type: name, args: decodeArguments(bytes, open + 1, close), text: textOf(bytes, at, end), offset: at });
+        at = end;
+    }
+}
+function readRow(bytes, at, rows) {
+    let idEnd = at + 1;
+    let id = 0;
+    while (idEnd < bytes.length && isDigit(bytes[idEnd])) {
+        id = id * DECIMAL_RADIX + bytes[idEnd] - CHAR_ZERO;
+        idEnd++;
+    }
+    if (idEnd === at + 1) {
+        throw new StepSyntaxError("An entity without an id", at);
+    }
+    if (id > MAX_EXPRESS_ID) {
+        throw new StepSyntaxError(`Entity #${textOf(bytes, at + 1, idEnd)} has an id above ${MAX_EXPRESS_ID}, which this library does not read`, at);
+    }
+    const equals = skipSpace(bytes, idEnd, bytes.length);
+    if (bytes[equals] !== CHAR_EQUALS) {
+        throw new StepSyntaxError(`Entity #${id} has no '='`, equals);
+    }
+    const nameStart = skipSpace(bytes, equals + 1, bytes.length);
+    let nameEnd = nameStart;
+    while (nameEnd < bytes.length && isNameCharacter(bytes[nameEnd])) {
+        nameEnd++;
+    }
+    const open = skipSpace(bytes, nameEnd, bytes.length);
+    if (bytes[open] !== CHAR_OPEN) {
+        throw new StepSyntaxError(`Entity #${id} has no attribute list`, open);
+    }
+    const close = closingParenthesis(bytes, open, bytes.length);
+    const semicolon = skipSpace(bytes, close + 1, bytes.length);
+    if (bytes[semicolon] !== CHAR_SEMICOLON) {
+        throw new StepSyntaxError(`Entity #${id} does not end with ';'`, semicolon);
+    }
+    const rowEnd = semicolon + 1;
+    addRow(rows, id, typeCodeOf(rows, bytes, nameStart, nameEnd), { rowStart: at, argStart: open + 1, argEnd: close, rowEnd });
+    return rowEnd;
+}
+function readDataSection(bytes, from, rows) {
+    let at = skipSpace(bytes, from, bytes.length);
+    if (bytes[at] === CHAR_OPEN) {
+        at = closingParenthesis(bytes, at, bytes.length) + 1;
+    }
+    at = expectSemicolon(bytes, at, "DATA");
+    for (;;) {
+        at = skipSpace(bytes, at, bytes.length);
+        if (at >= bytes.length) {
+            throw new StepSyntaxError("The DATA section never ends", at);
+        }
+        if (bytes[at] !== CHAR_HASH) {
+            const [keyword, keywordEnd] = readKeyword(bytes, at);
+            if (keyword !== "ENDSEC") {
+                throw new StepSyntaxError("Expected an entity or ENDSEC", at);
+            }
+            return expectSemicolon(bytes, keywordEnd, "ENDSEC");
+        }
+        at = readRow(bytes, at, rows);
+    }
+}
+function startOf(bytes) {
+    return BOM.every((byte, index) => bytes[index] === byte) ? BOM.length : 0;
+}
+export function indexStep(bytes) {
+    if (bytes.length > MAX_FILE_BYTES) {
+        throw new StepSyntaxError(`The file holds ${bytes.length} bytes; files of 4 GiB or more are not read`, 0);
+    }
+    const [header, afterHeader, headerEnd] = readHeader(bytes, expectSemicolon(bytes, expectKeyword(bytes, startOf(bytes), "ISO-10303-21"), "ISO-10303-21"));
+    const rows = {
+        count: 0,
+        ids: new Int32Array(INITIAL_ROWS),
+        typeCodes: new Uint16Array(INITIAL_ROWS),
+        typeTable: [],
+        codesOfHash: new Map(),
+        argStart: new Uint32Array(INITIAL_ROWS),
+        argEnd: new Uint32Array(INITIAL_ROWS),
+        rowStart: new Uint32Array(INITIAL_ROWS),
+        rowEnd: new Uint32Array(INITIAL_ROWS),
+    };
+    const sectionStarts = [];
+    let at = readDataSection(bytes, expectKeyword(bytes, afterHeader, "DATA"), rows);
+    for (;;) {
+        at = skipSpace(bytes, at, bytes.length);
+        const [keyword, keywordEnd] = readKeyword(bytes, at);
+        if (keyword === "DATA") {
+            sectionStarts.push(rows.count);
+            at = readDataSection(bytes, keywordEnd, rows);
+            continue;
+        }
+        if (keyword !== "END-ISO-10303-21") {
+            throw new StepSyntaxError("Expected DATA or END-ISO-10303-21", at);
+        }
+        const end = skipSpace(bytes, expectSemicolon(bytes, keywordEnd, "END-ISO-10303-21"), bytes.length);
+        if (end < bytes.length) {
+            throw new StepSyntaxError("The file goes on after END-ISO-10303-21;", end);
+        }
+        break;
+    }
+    return {
+        bytes,
+        count: rows.count,
+        ids: rows.ids.subarray(0, rows.count),
+        typeCodes: rows.typeCodes.subarray(0, rows.count),
+        typeTable: rows.typeTable,
+        argStart: rows.argStart.subarray(0, rows.count),
+        argEnd: rows.argEnd.subarray(0, rows.count),
+        rowStart: rows.rowStart.subarray(0, rows.count),
+        rowEnd: rows.rowEnd.subarray(0, rows.count),
+        header,
+        headerEnd,
+        afterHeader,
+        sectionStarts,
+    };
+}

package/lib/step/header.d.ts

@@ -0,0 +1,4 @@
+import type { IfcFileHeader, StepHeaderEntity } from "./step-types";
+export declare function headerFromEntities(entities: readonly StepHeaderEntity[]): IfcFileHeader;
+export declare function otherHeaderEntities(entities: readonly StepHeaderEntity[]): string[];
+export declare function encodeHeader(header: IfcFileHeader, others?: readonly string[]): string;

package/lib/step/header.js

@@ -0,0 +1,52 @@
+import { DEFAULT_IMPLEMENTATION_LEVEL, HEADER_ENTITIES_READ } from "./constants";
+import { encodeString } from "./strings";
+const READ = new Set(HEADER_ENTITIES_READ);
+function texts(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+export function headerFromEntities(entities) {
+    const find = (type) => { var _a, _b; return (_b = (_a = entities.find((entity) => entity.type === type)) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : []; };
+    const description = find("FILE_DESCRIPTION");
+    const name = find("FILE_NAME");
+    const schema = find("FILE_SCHEMA");
+    return {
+        description: texts(description[0]),
+        implementationLevel: text(description[1]) || DEFAULT_IMPLEMENTATION_LEVEL,
+        name: text(name[0]),
+        timeStamp: text(name[1]),
+        author: texts(name[2]),
+        organization: texts(name[3]),
+        preprocessorVersion: text(name[4]),
+        originatingSystem: text(name[5]),
+        authorization: text(name[6]),
+        schemaIdentifiers: texts(schema[0]),
+    };
+}
+export function otherHeaderEntities(entities) {
+    return entities.filter((entity) => !READ.has(entity.type)).map((entity) => entity.text);
+}
+function list(values) {
+    return `(${(values.length ? values : [""]).map(encodeString).join(",")})`;
+}
+export function encodeHeader(header, others = []) {
+    return [
+        "ISO-10303-21;",
+        "HEADER;",
+        `FILE_DESCRIPTION(${list(header.description)},${encodeString(header.implementationLevel)});`,
+        `FILE_NAME(${[
+            encodeString(header.name),
+            encodeString(header.timeStamp),
+            list(header.author),
+            list(header.organization),
+            encodeString(header.preprocessorVersion),
+            encodeString(header.originatingSystem),
+            encodeString(header.authorization),
+        ].join(",")});`,
+        `FILE_SCHEMA(${list(header.schemaIdentifiers)});`,
+        ...others,
+        "ENDSEC;",
+    ].join("\n");
+}

package/lib/step/numbers.d.ts

@@ -0,0 +1,3 @@
+export declare function formatReal(value: number): string;
+export declare function formatInteger(value: number): string;
+export declare function exactDecimal(bytes: Uint8Array, start: number, end: number): number | undefined;