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

package/lib/step/strings.js

@@ -0,0 +1,150 @@
+import { BMP_LIMIT, BYTE_DIGITS, CHARACTERS_PER_CHUNK, HEX_RADIX, LATIN1_PART, MAX_CODE_POINT, PRINTABLE_FIRST, PRINTABLE_LAST, UCS2_DIGITS, UCS4_DIGITS, UPPER_HALF_OFFSET } from "./constants";
+import { StepSyntaxError } from "./errors";
+const APOSTROPHE = "'";
+const BACKSLASH = "\\";
+const END_OF_RUN = "\\X0\\";
+const HEX_DIGITS = /^[0-9A-Fa-f]+$/;
+const ALPHABET_DIRECTIVE = /^\\P([A-I])\\/;
+const ALPHABET_LETTERS = "ABCDEFGHI";
+const DIRECTIVE_LENGTH = "\\PA\\".length;
+const partDecoders = new Map();
+function isPrintable(code) {
+    return code >= PRINTABLE_FIRST && code <= PRINTABLE_LAST;
+}
+function hexOf(value, digits) {
+    return value.toString(HEX_RADIX).toUpperCase().padStart(digits, "0");
+}
+function escapeRun(run) {
+    const codePoints = Array.from(run, (character) => character.codePointAt(0));
+    if (codePoints.some((point) => point > BMP_LIMIT)) {
+        return `\\X4\\${codePoints.map((point) => hexOf(point, UCS4_DIGITS)).join("")}${END_OF_RUN}`;
+    }
+    let units = "";
+    for (let index = 0; index < run.length; index++) {
+        units += hexOf(run.charCodeAt(index), UCS2_DIGITS);
+    }
+    return `\\X2\\${units}${END_OF_RUN}`;
+}
+export function encodeString(text) {
+    let out = APOSTROPHE;
+    let run = "";
+    for (const character of text) {
+        if (isPrintable(character.codePointAt(0))) {
+            if (run) {
+                out += escapeRun(run);
+                run = "";
+            }
+            out += character === APOSTROPHE ? "''" : character === BACKSLASH ? "\\\\" : character;
+        }
+        else {
+            run += character;
+        }
+    }
+    if (run) {
+        out += escapeRun(run);
+    }
+    return `${out}${APOSTROPHE}`;
+}
+function charactersOf(units) {
+    let out = "";
+    for (let at = 0; at < units.length; at += CHARACTERS_PER_CHUNK) {
+        out += String.fromCharCode(...units.slice(at, at + CHARACTERS_PER_CHUNK));
+    }
+    return out;
+}
+function codePointsOf(points, offset) {
+    let out = "";
+    for (const point of points) {
+        if (point > MAX_CODE_POINT) {
+            throw new StepSyntaxError(`The code point ${hexOf(point, UCS4_DIGITS)} lies beyond Unicode`, offset);
+        }
+        out += String.fromCodePoint(point);
+    }
+    return out;
+}
+function hexRun(raw, from, digits, offset) {
+    const end = raw.indexOf(END_OF_RUN, from);
+    if (end < 0) {
+        throw new StepSyntaxError("A \\X2\\ or \\X4\\ run is never closed with \\X0\\", offset);
+    }
+    const hex = raw.slice(from, end);
+    if (hex.length % digits !== 0 || (hex.length > 0 && !HEX_DIGITS.test(hex))) {
+        throw new StepSyntaxError(`A run of hexadecimal characters holds something other than groups of ${digits} digits`, offset);
+    }
+    const values = [];
+    for (let at = 0; at < hex.length; at += digits) {
+        values.push(Number.parseInt(hex.slice(at, at + digits), HEX_RADIX));
+    }
+    return [values, end + END_OF_RUN.length];
+}
+function isByteEscape(raw, at) {
+    const start = at + "\\X\\".length;
+    return raw.startsWith("\\X\\", at) && start + BYTE_DIGITS <= raw.length && HEX_DIGITS.test(raw.slice(start, start + BYTE_DIGITS));
+}
+function upperHalf(code, part) {
+    const byte = code + UPPER_HALF_OFFSET;
+    if (part === LATIN1_PART) {
+        return String.fromCharCode(byte);
+    }
+    let decoder = partDecoders.get(part);
+    if (!decoder) {
+        decoder = new TextDecoder(`iso-8859-${part}`);
+        partDecoders.set(part, decoder);
+    }
+    return decoder.decode(Uint8Array.of(byte));
+}
+export function decodeString(raw, offset = 0) {
+    let out = "";
+    let at = 0;
+    let part = LATIN1_PART;
+    while (at < raw.length) {
+        const character = raw[at];
+        if (character === APOSTROPHE && raw[at + 1] === APOSTROPHE) {
+            out += APOSTROPHE;
+            at += 2;
+            continue;
+        }
+        if (character !== BACKSLASH) {
+            out += character;
+            at++;
+            continue;
+        }
+        if (raw.startsWith("\\\\", at)) {
+            out += BACKSLASH;
+            at += 2;
+        }
+        else if (raw.startsWith("\\X2\\", at)) {
+            const [units, next] = hexRun(raw, at + "\\X2\\".length, UCS2_DIGITS, offset);
+            out += charactersOf(units);
+            at = next;
+        }
+        else if (raw.startsWith("\\X4\\", at)) {
+            const [points, next] = hexRun(raw, at + "\\X4\\".length, UCS4_DIGITS, offset);
+            out += codePointsOf(points, offset);
+            at = next;
+        }
+        else if (isByteEscape(raw, at)) {
+            const start = at + "\\X\\".length;
+            out += String.fromCharCode(Number.parseInt(raw.slice(start, start + BYTE_DIGITS), HEX_RADIX));
+            at = start + BYTE_DIGITS;
+        }
+        else if (raw.startsWith("\\S\\", at) && at + "\\S\\".length < raw.length) {
+            const next = at + "\\S\\".length;
+            const escapedApostrophe = raw[next] === APOSTROPHE && raw[next + 1] === APOSTROPHE;
+            out += upperHalf(raw.charCodeAt(next), part);
+            at = next + (escapedApostrophe ? 2 : 1);
+        }
+        else {
+            const directive = ALPHABET_DIRECTIVE.exec(raw.slice(at, at + DIRECTIVE_LENGTH));
+            if (directive) {
+                part = ALPHABET_LETTERS.indexOf(directive[1]) + 1;
+                at += DIRECTIVE_LENGTH;
+            }
+            else {
+                out += character;
+                at++;
+            }
+        }
+    }
+    return out;
+}

package/lib/step/values.d.ts

@@ -0,0 +1,13 @@
+import type { IfcBinaryValue, IfcDerivedValue, IfcEnumerationValue, IfcReference, IfcTypedValue, IfcValue } from "./step-types";
+export declare const DERIVED: IfcDerivedValue;
+export declare function ref(id: number): IfcReference;
+export declare function enumValue(value: string): IfcEnumerationValue;
+export declare function typed(type: string, value: IfcValue): IfcTypedValue;
+export declare function isReference(value: IfcValue | undefined): value is IfcReference;
+export declare function isEnumeration(value: IfcValue | undefined): value is IfcEnumerationValue;
+export declare function isTyped(value: IfcValue | undefined): value is IfcTypedValue;
+export declare function isBinary(value: IfcValue | undefined): value is IfcBinaryValue;
+export declare function isDerived(value: IfcValue | undefined): value is IfcDerivedValue;
+export declare function isList(value: IfcValue | undefined): value is readonly IfcValue[];
+export declare function textValue(value: IfcValue | undefined): string | undefined;
+export declare function referencesIn(value: IfcValue, into?: number[]): number[];

package/lib/step/values.js

@@ -0,0 +1,51 @@
+export const DERIVED = Object.freeze({ derived: true });
+export function ref(id) {
+    return { ref: id };
+}
+export function enumValue(value) {
+    return { enum: value.toUpperCase() };
+}
+export function typed(type, value) {
+    return { type, value };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isReference(value) {
+    return isRecord(value) && "ref" in value;
+}
+export function isEnumeration(value) {
+    return isRecord(value) && "enum" in value;
+}
+export function isTyped(value) {
+    return isRecord(value) && "type" in value && "value" in value;
+}
+export function isBinary(value) {
+    return isRecord(value) && "binary" in value;
+}
+export function isDerived(value) {
+    return isRecord(value) && "derived" in value;
+}
+export function isList(value) {
+    return Array.isArray(value);
+}
+export function textValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return isTyped(value) && typeof value.value === "string" ? value.value : undefined;
+}
+export function referencesIn(value, into = []) {
+    if (isReference(value)) {
+        into.push(value.ref);
+    }
+    else if (isList(value)) {
+        for (const item of value) {
+            referencesIn(item, into);
+        }
+    }
+    else if (isTyped(value)) {
+        referencesIn(value.value, into);
+    }
+    return into;
+}

package/package.json

@@ -1,6 +1,52 @@
 {
-  "name": "@bitbybit-dev/ifc",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@bitbybit-dev/ifc",
+    "version": "1.5.0-rc.0",
+    "description": "Bit By Bit Developers IFC library to write, read and author BIM models in TypeScript",
+    "homepage": "https://docs.bitbybit.dev/classes/Bit.IFC",
+    "main": "index.js",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/bitbybit-dev/bitbybit.git",
+        "directory": "packages/dev/ifc"
+    },
+    "keywords": [
+        "Bit By Bit Developers",
+        "bitbybit",
+        "bitbybit.dev",
+        "IFC",
+        "BIM",
+        "Industry Foundation Classes",
+        "buildingSMART",
+        "IFC4",
+        "STEP",
+        "ISO 10303-21",
+        "AEC",
+        "Architecture",
+        "Construction",
+        "Building",
+        "Walls",
+        "Slabs",
+        "Doors",
+        "Windows",
+        "Geometry",
+        "CAD",
+        "3D",
+        "Parametric",
+        "Modeling",
+        "Browser CAD"
+    ],
+    "directories": {
+        "lib": "lib"
+    },
+    "author": "Bit by bit developers",
+    "license": "MIT",
+    "funding": {
+        "type": "corporate",
+        "url": "https://bitbybit.dev/auth/pick-plan"
+    },
+    "types": "./index.d.ts",
+    "type": "module",
+    "dependencies": {
+        "@bitbybit-dev/base": "1.5.0-rc.0"
+    }
+}