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

package/lib/step/numbers.js

@@ -0,0 +1,73 @@
+import { CHAR_DOT, CHAR_LOWER_E, CHAR_MINUS, CHAR_PLUS, CHAR_UPPER_E, CHAR_ZERO, DECIMAL_RADIX } from "./constants";
+import { isDigit } from "./scanner";
+const MAX_EXACT_DIGITS = 15;
+const MAX_EXACT_POWER = 22;
+const MAX_EXPONENT_DIGITS = 4;
+const EXACT_POWERS = Array.from({ length: MAX_EXACT_POWER + 1 }, (_, power) => Number(`1e${power}`));
+export function formatReal(value) {
+    if (!Number.isFinite(value)) {
+        throw new RangeError(`An IFC real must be finite, not ${value}`);
+    }
+    const text = Object.is(value, -0) ? "0" : String(value);
+    const exponentAt = text.indexOf("e");
+    const mantissa = exponentAt < 0 ? text : text.slice(0, exponentAt);
+    const exponent = exponentAt < 0 ? "" : `E${text.slice(exponentAt + 1).replace("+", "")}`;
+    return `${mantissa.includes(".") ? mantissa : `${mantissa}.`}${exponent}`;
+}
+export function formatInteger(value) {
+    if (!Number.isSafeInteger(value)) {
+        throw new RangeError(`An IFC integer must be a whole number within the safe range, not ${value}`);
+    }
+    return String(value);
+}
+export function exactDecimal(bytes, start, end) {
+    let at = start;
+    const negative = bytes[at] === CHAR_MINUS;
+    if (negative || bytes[at] === CHAR_PLUS) {
+        at++;
+    }
+    let mantissa = 0;
+    let digits = 0;
+    let significant = 0;
+    let scale = 0;
+    let fraction = false;
+    for (; at < end; at++) {
+        const code = bytes[at];
+        if (code === CHAR_DOT && !fraction) {
+            fraction = true;
+            continue;
+        }
+        if (!isDigit(code)) {
+            break;
+        }
+        mantissa = mantissa * DECIMAL_RADIX + (code - CHAR_ZERO);
+        digits++;
+        significant += mantissa === 0 ? 0 : 1;
+        scale += fraction ? 1 : 0;
+    }
+    if (digits === 0 || significant > MAX_EXACT_DIGITS) {
+        return undefined;
+    }
+    let exponent = 0;
+    if (at < end && (bytes[at] === CHAR_UPPER_E || bytes[at] === CHAR_LOWER_E)) {
+        at++;
+        const negativeExponent = bytes[at] === CHAR_MINUS;
+        if (negativeExponent || bytes[at] === CHAR_PLUS) {
+            at++;
+        }
+        const first = at;
+        for (; at < end && at - first < MAX_EXPONENT_DIGITS && isDigit(bytes[at]); at++) {
+            exponent = exponent * DECIMAL_RADIX + (bytes[at] - CHAR_ZERO);
+        }
+        if (at === first) {
+            return undefined;
+        }
+        exponent = negativeExponent ? -exponent : exponent;
+    }
+    const power = exponent - scale;
+    if (at !== end || power < -MAX_EXACT_POWER || power > MAX_EXACT_POWER) {
+        return undefined;
+    }
+    const value = power < 0 ? mantissa / EXACT_POWERS[-power] : mantissa * EXACT_POWERS[power];
+    return negative ? -value : value;
+}

package/lib/step/reader.d.ts

@@ -0,0 +1,2 @@
+import type { IfcValue, TypeSpelling } from "./step-types";
+export declare function decodeArguments(bytes: Uint8Array, start: number, end: number, spell?: TypeSpelling): IfcValue[];

package/lib/step/reader.js

@@ -0,0 +1,160 @@
+import { CHAR_APOSTROPHE, CHAR_CLOSE, CHAR_COMMA, CHAR_DOLLAR, CHAR_DOT, CHAR_HASH, CHAR_LOWER_E, CHAR_MINUS, CHAR_OPEN, CHAR_PLUS, CHAR_QUOTE, CHAR_STAR, CHAR_UPPER_E, CHAR_ZERO, DECIMAL_RADIX, MAX_NESTING, } from "./constants";
+import { StepSyntaxError } from "./errors";
+import { exactDecimal } from "./numbers";
+import { asciiText, endOfBinary, endOfString, isDigit, isNameCharacter, skipSpace, textOf } from "./scanner";
+import { decodeString } from "./strings";
+import { DERIVED } from "./values";
+function readNumber(bytes, at, end) {
+    var _a;
+    let position = at;
+    if (bytes[position] === CHAR_MINUS || bytes[position] === CHAR_PLUS) {
+        position++;
+    }
+    while (position < end) {
+        const code = bytes[position];
+        const signOfExponent = (code === CHAR_MINUS || code === CHAR_PLUS) && (bytes[position - 1] === CHAR_UPPER_E || bytes[position - 1] === CHAR_LOWER_E);
+        if (!isDigit(code) && code !== CHAR_DOT && code !== CHAR_UPPER_E && code !== CHAR_LOWER_E && !signOfExponent) {
+            break;
+        }
+        position++;
+    }
+    const value = (_a = exactDecimal(bytes, at, position)) !== null && _a !== void 0 ? _a : Number(asciiText(bytes, at, position));
+    if (Number.isNaN(value)) {
+        throw new StepSyntaxError("A malformed number", at);
+    }
+    if (!Number.isFinite(value)) {
+        throw new StepSyntaxError("A number too large to be finite", at);
+    }
+    return [value, position];
+}
+function readName(bytes, at, end) {
+    let position = at;
+    while (position < end && isNameCharacter(bytes[position])) {
+        position++;
+    }
+    return position;
+}
+function readReference(bytes, at, end) {
+    var _a;
+    let close = at + 1;
+    let id = 0;
+    while (close < end && isDigit(bytes[close])) {
+        id = id * DECIMAL_RADIX + (bytes[close] - CHAR_ZERO);
+        close++;
+    }
+    if (close === at + 1 || !Number.isSafeInteger(id) || isNameCharacter((_a = bytes[close]) !== null && _a !== void 0 ? _a : 0)) {
+        throw new StepSyntaxError("A reference that is not '#' followed by digits", at);
+    }
+    return [{ ref: id }, close];
+}
+function readEnumeration(bytes, at, end) {
+    const close = readName(bytes, at + 1, end);
+    if (bytes[close] !== CHAR_DOT) {
+        throw new StepSyntaxError("An enumeration value is never closed", at);
+    }
+    const name = asciiText(bytes, at + 1, close).toUpperCase();
+    const value = name === "T" ? true : name === "F" ? false : { enum: name };
+    return [value, close + 1];
+}
+function readScalar(bytes, at, end) {
+    const code = bytes[at];
+    if (code === CHAR_DOLLAR) {
+        return [null, at + 1];
+    }
+    if (code === CHAR_STAR) {
+        return [DERIVED, at + 1];
+    }
+    if (code === CHAR_HASH) {
+        return readReference(bytes, at, end);
+    }
+    if (code === CHAR_APOSTROPHE) {
+        const close = endOfString(bytes, at, end);
+        return [decodeString(textOf(bytes, at + 1, close), at), close + 1];
+    }
+    if (code === CHAR_QUOTE) {
+        const close = endOfBinary(bytes, at, end);
+        return [{ binary: textOf(bytes, at + 1, close) }, close + 1];
+    }
+    if (code === CHAR_DOT) {
+        return readEnumeration(bytes, at, end);
+    }
+    if (isDigit(code) || code === CHAR_MINUS || code === CHAR_PLUS) {
+        return readNumber(bytes, at, end);
+    }
+    throw new StepSyntaxError(`An unexpected character '${String.fromCharCode(code)}'`, at);
+}
+function closeFrame(stack, at, spell) {
+    const frame = stack.pop();
+    if (frame.typeName === undefined) {
+        return frame.items;
+    }
+    if (frame.items.length !== 1) {
+        throw new StepSyntaxError(`The typed value ${frame.typeName} holds ${frame.items.length} values instead of one`, at);
+    }
+    return { type: spell ? spell(frame.typeName) : frame.typeName, value: frame.items[0] };
+}
+function openFrame(bytes, at, end, stack) {
+    let typeName;
+    let open = at;
+    if (bytes[at] !== CHAR_OPEN) {
+        const nameEnd = readName(bytes, at, end);
+        typeName = asciiText(bytes, at, nameEnd);
+        open = skipSpace(bytes, nameEnd, end);
+        if (bytes[open] !== CHAR_OPEN) {
+            throw new StepSyntaxError(`The typed value ${typeName} has no parentheses`, at);
+        }
+    }
+    if (stack.length > MAX_NESTING) {
+        throw new StepSyntaxError(`Values nested more than ${MAX_NESTING} deep`, at);
+    }
+    stack.push({ items: [], typeName });
+    return skipSpace(bytes, open + 1, end);
+}
+export function decodeArguments(bytes, start, end, spell) {
+    const root = { items: [], typeName: undefined };
+    const stack = [root];
+    let at = skipSpace(bytes, start, end);
+    let expectValue = true;
+    while (at < end) {
+        const code = bytes[at];
+        if (code === CHAR_COMMA) {
+            if (expectValue) {
+                throw new StepSyntaxError("A value is missing before a comma", at);
+            }
+            expectValue = true;
+            at = skipSpace(bytes, at + 1, end);
+            continue;
+        }
+        if (code === CHAR_CLOSE) {
+            if (stack.length === 1) {
+                throw new StepSyntaxError("A closing parenthesis without an opening one", at);
+            }
+            if (expectValue && stack[stack.length - 1].items.length > 0) {
+                throw new StepSyntaxError("A value is missing before a closing parenthesis", at);
+            }
+            const value = closeFrame(stack, at, spell);
+            stack[stack.length - 1].items.push(value);
+            expectValue = false;
+            at = skipSpace(bytes, at + 1, end);
+            continue;
+        }
+        if (!expectValue) {
+            throw new StepSyntaxError("Two values without a comma between them", at);
+        }
+        if (code === CHAR_OPEN || (isNameCharacter(code) && !isDigit(code))) {
+            at = openFrame(bytes, at, end, stack);
+            continue;
+        }
+        const [value, next] = readScalar(bytes, at, end);
+        stack[stack.length - 1].items.push(value);
+        expectValue = false;
+        at = skipSpace(bytes, next, end);
+    }
+    if (stack.length !== 1) {
+        throw new StepSyntaxError("A parenthesis is never closed", end);
+    }
+    if (expectValue && root.items.length > 0) {
+        throw new StepSyntaxError("A value is missing at the end", end);
+    }
+    return root.items;
+}

package/lib/step/scanner.d.ts

@@ -0,0 +1,13 @@
+export declare function isDigit(code: number): boolean;
+export declare function isNameCharacter(code: number): boolean;
+export declare function plainText(bytes: Uint8Array, start: number, end: number): string | undefined;
+export declare function asciiText(bytes: Uint8Array, start: number, end: number): string;
+export declare function textOf(bytes: Uint8Array, start: number, end: number): string;
+export declare function endOfString(bytes: Uint8Array, open: number, end: number): number;
+export declare function endOfBinary(bytes: Uint8Array, open: number, end: number): number;
+export declare function skipSpace(bytes: Uint8Array, at: number, end: number): number;
+export declare function closingParenthesis(bytes: Uint8Array, open: number, end: number): number;
+export declare function referenceCapacity(bytes: Uint8Array, start: number, end: number): number;
+export declare function referencesInto(bytes: Uint8Array, start: number, end: number, into: Int32Array): number;
+export declare function referenceList(bytes: Uint8Array, start: number, end: number): number[] | undefined;
+export declare function firstStringIn(bytes: Uint8Array, start: number, end: number): [number, number] | undefined;

package/lib/step/scanner.js

@@ -0,0 +1,203 @@
+import { CHARACTERS_PER_CHUNK, DECIMAL_RADIX, CHAR_APOSTROPHE, CHAR_CLOSE, CHAR_COMMA, CHAR_HASH, CHAR_LOWER_A, CHAR_LOWER_Z, CHAR_NINE, CHAR_OPEN, CHAR_QUOTE, CHAR_SLASH, CHAR_BACKSLASH, CHAR_SPACE, CHAR_STAR, CHAR_TILDE, CHAR_UNDERSCORE, CHAR_UPPER_A, CHAR_UPPER_Z, CHAR_ZERO, MAX_EXPRESS_ID, } from "./constants";
+import { StepSyntaxError } from "./errors";
+const strictUtf8 = new TextDecoder("utf-8", { fatal: true });
+export function isDigit(code) {
+    return code >= CHAR_ZERO && code <= CHAR_NINE;
+}
+export function isNameCharacter(code) {
+    return (code >= CHAR_UPPER_A && code <= CHAR_UPPER_Z) || (code >= CHAR_LOWER_A && code <= CHAR_LOWER_Z) || isDigit(code) || code === CHAR_UNDERSCORE;
+}
+function latin1(bytes) {
+    let out = "";
+    for (let at = 0; at < bytes.length; at += CHARACTERS_PER_CHUNK) {
+        out += String.fromCharCode(...bytes.subarray(at, at + CHARACTERS_PER_CHUNK));
+    }
+    return out;
+}
+export function plainText(bytes, start, end) {
+    if (end - start > CHARACTERS_PER_CHUNK) {
+        return undefined;
+    }
+    for (let at = start; at < end; at++) {
+        const code = bytes[at];
+        if (code < CHAR_SPACE || code > CHAR_TILDE || code === CHAR_BACKSLASH || code === CHAR_APOSTROPHE) {
+            return undefined;
+        }
+    }
+    return String.fromCharCode(...bytes.subarray(start, end));
+}
+export function asciiText(bytes, start, end) {
+    return Reflect.apply(String.fromCharCode, null, bytes.subarray(start, end));
+}
+export function textOf(bytes, start, end) {
+    const slice = bytes.subarray(start, end);
+    try {
+        return strictUtf8.decode(slice);
+    }
+    catch (_a) {
+        return latin1(slice);
+    }
+}
+function endOfComment(bytes, open, end) {
+    for (let at = open + 2; at + 1 < end; at++) {
+        if (bytes[at] === CHAR_STAR && bytes[at + 1] === CHAR_SLASH) {
+            return at + 2;
+        }
+    }
+    throw new StepSyntaxError("A comment is never closed", open);
+}
+export function endOfString(bytes, open, end) {
+    let at = open + 1;
+    while (at < end) {
+        if (bytes[at] === CHAR_APOSTROPHE) {
+            if (bytes[at + 1] === CHAR_APOSTROPHE) {
+                at += 2;
+                continue;
+            }
+            return at;
+        }
+        at++;
+    }
+    throw new StepSyntaxError("A string is never closed", open);
+}
+export function endOfBinary(bytes, open, end) {
+    const close = bytes.indexOf(CHAR_QUOTE, open + 1);
+    if (close < 0 || close >= end) {
+        throw new StepSyntaxError("A binary value is never closed", open);
+    }
+    return close;
+}
+export function skipSpace(bytes, at, end) {
+    let position = at;
+    while (position < end) {
+        const code = bytes[position];
+        if (code <= CHAR_SPACE) {
+            position++;
+        }
+        else if (code === CHAR_SLASH && bytes[position + 1] === CHAR_STAR) {
+            position = endOfComment(bytes, position, end);
+        }
+        else {
+            break;
+        }
+    }
+    return position;
+}
+function afterQuoted(bytes, at, end) {
+    const code = bytes[at];
+    if (code === CHAR_APOSTROPHE) {
+        return endOfString(bytes, at, end) + 1;
+    }
+    if (code === CHAR_QUOTE) {
+        return endOfBinary(bytes, at, end) + 1;
+    }
+    if (code === CHAR_SLASH && bytes[at + 1] === CHAR_STAR) {
+        return endOfComment(bytes, at, end);
+    }
+    return at;
+}
+function isQuoteOrSlash(code) {
+    return code === CHAR_APOSTROPHE || code === CHAR_QUOTE || code === CHAR_SLASH;
+}
+export function closingParenthesis(bytes, open, end) {
+    let depth = 0;
+    let at = open;
+    while (at < end) {
+        const code = bytes[at];
+        if (code === CHAR_OPEN) {
+            depth++;
+        }
+        else if (code === CHAR_CLOSE) {
+            depth--;
+            if (depth === 0) {
+                return at;
+            }
+        }
+        else if (isQuoteOrSlash(code)) {
+            const skipped = afterQuoted(bytes, at, end);
+            if (skipped !== at) {
+                at = skipped;
+                continue;
+            }
+        }
+        at++;
+    }
+    throw new StepSyntaxError("A parenthesis is never closed", open);
+}
+export function referenceCapacity(bytes, start, end) {
+    let count = 0;
+    for (let at = bytes.indexOf(CHAR_HASH, start); at >= 0 && at < end; at = bytes.indexOf(CHAR_HASH, at + 1)) {
+        count++;
+    }
+    return count;
+}
+export function referencesInto(bytes, start, end, into) {
+    let count = 0;
+    let at = start;
+    while (at < end) {
+        const code = bytes[at];
+        if (code === CHAR_HASH) {
+            let digits = at + 1;
+            let id = 0;
+            while (digits < end && isDigit(bytes[digits])) {
+                id = id * DECIMAL_RADIX + bytes[digits] - CHAR_ZERO;
+                digits++;
+            }
+            if (digits > at + 1 && id <= MAX_EXPRESS_ID) {
+                into[count++] = id;
+            }
+            at = digits;
+            continue;
+        }
+        if (isQuoteOrSlash(code)) {
+            const skipped = afterQuoted(bytes, at, end);
+            if (skipped !== at) {
+                at = skipped;
+                continue;
+            }
+        }
+        at++;
+    }
+    return count;
+}
+export function referenceList(bytes, start, end) {
+    let at = skipSpace(bytes, start, end);
+    if (bytes[at] !== CHAR_OPEN) {
+        return undefined;
+    }
+    at = skipSpace(bytes, at + 1, end);
+    const references = [];
+    while (at < end && bytes[at] !== CHAR_CLOSE) {
+        if (bytes[at] !== CHAR_HASH) {
+            return undefined;
+        }
+        let digits = at + 1;
+        let id = 0;
+        while (digits < end && isDigit(bytes[digits])) {
+            id = id * DECIMAL_RADIX + bytes[digits] - CHAR_ZERO;
+            digits++;
+        }
+        if (digits === at + 1 || id > MAX_EXPRESS_ID) {
+            return undefined;
+        }
+        references.push(id);
+        at = skipSpace(bytes, digits, end);
+        if (bytes[at] === CHAR_COMMA) {
+            at = skipSpace(bytes, at + 1, end);
+            if (bytes[at] === CHAR_CLOSE) {
+                return undefined;
+            }
+        }
+        else if (bytes[at] !== CHAR_CLOSE) {
+            return undefined;
+        }
+    }
+    return at < end && skipSpace(bytes, at + 1, end) === end ? references : undefined;
+}
+export function firstStringIn(bytes, start, end) {
+    const open = skipSpace(bytes, start, end);
+    if (bytes[open] !== CHAR_APOSTROPHE) {
+        return undefined;
+    }
+    return [open + 1, endOfString(bytes, open, end)];
+}

package/lib/step/step-types.d.ts

@@ -0,0 +1,170 @@
+/**
+ * A reference to another entity of the same file, by its express id: `#12` in the file.
+ * @beta
+ */
+export interface IfcReference {
+    /**
+     * The express id of the entity referred to.
+     */
+    readonly ref: number;
+}
+/**
+ * An enumeration value, written between dots: `.ELEMENT.` in the file.
+ * @beta
+ */
+export interface IfcEnumerationValue {
+    /**
+     * The value, in upper case.
+     */
+    readonly enum: string;
+}
+/**
+ * A value carried with its defined type, as a select needs it: `IFCLABEL('Wall')` in the file.
+ * @beta
+ */
+export interface IfcTypedValue {
+    /**
+     * The defined type, in the schema's spelling, such as `IfcLabel`.
+     */
+    readonly type: string;
+    /**
+     * The value itself.
+     */
+    readonly value: IfcValue;
+}
+/**
+ * A binary value: its bits as hexadecimal digits, after a first digit that counts the unused
+ * leading bits.
+ * @beta
+ */
+export interface IfcBinaryValue {
+    /**
+     * The digits as the file writes them.
+     */
+    readonly binary: string;
+}
+/**
+ * An attribute a subtype derives from its other attributes, written `*` in the file.
+ * @beta
+ */
+export interface IfcDerivedValue {
+    /**
+     * Always true.
+     */
+    readonly derived: true;
+}
+/**
+ * One attribute value of an IFC entity. `null` is an unset optional attribute (`$` in the file), a
+ * number is a real or an integer as the schema says, and a list is an aggregate.
+ * @beta
+ */
+export type IfcValue = null | boolean | number | string | IfcReference | IfcEnumerationValue | IfcTypedValue | IfcBinaryValue | IfcDerivedValue | readonly IfcValue[];
+/**
+ * One entity instance: its express id, its type in the schema's spelling, and its attribute values
+ * in the order the schema lists them.
+ * @beta
+ */
+export interface IfcEntity {
+    /**
+     * The express id, unique within the file.
+     */
+    readonly id: number;
+    /**
+     * The entity type, in the schema's spelling, such as `IfcWall`.
+     */
+    readonly type: string;
+    /**
+     * The attribute values, inherited attributes first, in the order a file writes them.
+     */
+    readonly args: readonly IfcValue[];
+}
+/**
+ * The HEADER section of an IFC file: what the file declares about itself.
+ * @beta
+ */
+export interface IfcFileHeader {
+    /**
+     * Free texts describing the file; IFC uses the first to declare the model view, such as
+     * `ViewDefinition [ReferenceView_V1.2]`.
+     */
+    readonly description: readonly string[];
+    /**
+     * The conformance level of the file's encoding, `2;1` for files written by this library.
+     */
+    readonly implementationLevel: string;
+    /**
+     * The name of the file.
+     */
+    readonly name: string;
+    /**
+     * When the file was written, as ISO 8601 date and time.
+     */
+    readonly timeStamp: string;
+    /**
+     * The people who wrote the file.
+     */
+    readonly author: readonly string[];
+    /**
+     * The organizations of those people.
+     */
+    readonly organization: readonly string[];
+    /**
+     * The software that encoded the file.
+     */
+    readonly preprocessorVersion: string;
+    /**
+     * The software the data comes from.
+     */
+    readonly originatingSystem: string;
+    /**
+     * Who approved the file.
+     */
+    readonly authorization: string;
+    /**
+     * The schemas the data follows, such as `IFC4`.
+     */
+    readonly schemaIdentifiers: readonly string[];
+}
+export interface StepHeaderEntity {
+    readonly type: string;
+    readonly args: readonly IfcValue[];
+    readonly text: string;
+    readonly offset: number;
+}
+export interface StepIndex {
+    readonly bytes: Uint8Array;
+    readonly count: number;
+    readonly ids: Int32Array;
+    readonly typeCodes: Uint16Array;
+    readonly typeTable: readonly string[];
+    readonly argStart: Uint32Array;
+    readonly argEnd: Uint32Array;
+    readonly rowStart: Uint32Array;
+    readonly rowEnd: Uint32Array;
+    readonly header: readonly StepHeaderEntity[];
+    readonly headerEnd: number;
+    readonly afterHeader: number;
+    readonly sectionStarts: readonly number[];
+}
+export interface StepRows {
+    count: number;
+    ids: Int32Array;
+    typeCodes: Uint16Array;
+    readonly typeTable: string[];
+    readonly codesOfHash: Map<number, number[]>;
+    argStart: Uint32Array;
+    argEnd: Uint32Array;
+    rowStart: Uint32Array;
+    rowEnd: Uint32Array;
+}
+export interface RowSpans {
+    readonly rowStart: number;
+    readonly argStart: number;
+    readonly argEnd: number;
+    readonly rowEnd: number;
+}
+export interface ParseFrame {
+    readonly items: IfcValue[];
+    readonly typeName: string | undefined;
+}
+export type TypeSpelling = (typeName: string) => string;

package/lib/step/step-types.js

@@ -0,0 +1 @@
+export {};

package/lib/step/strings.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeString(text: string): string;
+export declare function decodeString(raw: string, offset?: number): string;