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

package/lib/schema/registry.d.ts

@@ -0,0 +1,7 @@
+import { IfcSchema } from "./schema";
+export declare const SUPPORTED_SCHEMAS: readonly string[];
+export declare function describeSupportedSchemas(): string;
+export declare function isEditableSchema(name: string): boolean;
+export declare function isSupportedSchema(identifier: string): boolean;
+export declare function readingSchemaFor(identifier: string): IfcSchema | undefined;
+export declare function schemaNamed(identifier: string): IfcSchema;

package/lib/schema/registry.js

@@ -0,0 +1,37 @@
+import { IFC4_SCHEMA } from "./generated/ifc4";
+import { IFC4X3_ADD2_SCHEMA } from "./generated/ifc4x3";
+import { IfcSchema } from "./schema";
+const loaded = new Map();
+const TABLES = new Map([[IFC4_SCHEMA.name, IFC4_SCHEMA], [IFC4X3_ADD2_SCHEMA.name, IFC4X3_ADD2_SCHEMA]]);
+const READ_THROUGH = new Map([["IFC2X3", IFC4_SCHEMA.name], ["IFC4X3", IFC4X3_ADD2_SCHEMA.name]]);
+const EDITABLE = new Set([IFC4_SCHEMA.name]);
+export const SUPPORTED_SCHEMAS = [...TABLES.keys()];
+export function describeSupportedSchemas() {
+    const through = [...READ_THROUGH].map(([file, table]) => `${file} through ${table}`);
+    return `${SUPPORTED_SCHEMAS.join(" and ")}, with ${through.join(" and ")}`;
+}
+export function isEditableSchema(name) {
+    return EDITABLE.has(name.trim().toUpperCase());
+}
+export function isSupportedSchema(identifier) {
+    return TABLES.has(identifier.trim().toUpperCase());
+}
+export function readingSchemaFor(identifier) {
+    const name = identifier.trim().toUpperCase();
+    const through = READ_THROUGH.get(name);
+    return TABLES.has(name) ? schemaNamed(name) : through === undefined ? undefined : schemaNamed(through);
+}
+export function schemaNamed(identifier) {
+    const name = identifier.trim().toUpperCase();
+    const known = loaded.get(name);
+    if (known) {
+        return known;
+    }
+    const table = TABLES.get(name);
+    if (!table) {
+        throw new Error(`The IFC schema ${identifier} is not supported; supported: ${SUPPORTED_SCHEMAS.join(", ")}`);
+    }
+    const schema = new IfcSchema(table);
+    loaded.set(name, schema);
+    return schema;
+}

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

@@ -0,0 +1,45 @@
+export type IfcAggregateKind = "LIST" | "SET" | "ARRAY" | "BAG";
+export type IfcTypeSpec = string | IfcAggregateSpec;
+export type IfcAggregateSpec = readonly [IfcAggregateKind, number, number | null, IfcTypeSpec];
+export type CompactAttribute = readonly [string, IfcTypeSpec] | readonly [string, IfcTypeSpec, 1];
+export type CompactInverse = readonly [string, IfcTypeSpec, string];
+export interface CompactEntity {
+    readonly p: string | null;
+    readonly a: readonly CompactAttribute[];
+    readonly abs?: 1;
+    readonly d?: readonly string[];
+    readonly i?: readonly CompactInverse[];
+}
+export interface CompactDefinedType {
+    readonly t: IfcTypeSpec;
+}
+export interface CompactEnumerationType {
+    readonly e: readonly string[];
+}
+export interface CompactSelectType {
+    readonly s: readonly string[];
+}
+export type CompactType = CompactDefinedType | CompactEnumerationType | CompactSelectType;
+export interface CompactSchema {
+    readonly name: string;
+    readonly release: string;
+    readonly types: Readonly<Record<string, CompactType>>;
+    readonly entities: Readonly<Record<string, CompactEntity>>;
+}
+export interface IfcAttributeInfo {
+    readonly name: string;
+    readonly type: IfcTypeSpec;
+    readonly optional: boolean;
+    readonly derived: boolean;
+}
+export interface IfcEntityInfo {
+    readonly name: string;
+    readonly supertype: string | null;
+    readonly abstract: boolean;
+    readonly attributes: readonly IfcAttributeInfo[];
+    readonly positions: ReadonlyMap<string, number>;
+}
+export interface SelectContents {
+    readonly entities: readonly string[];
+    readonly valueTypes: ReadonlySet<string>;
+}

package/lib/schema/schema-types.js

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

package/lib/schema/schema.d.ts

@@ -0,0 +1,23 @@
+import type { CompactSchema, CompactType, IfcEntityInfo, IfcTypeSpec, SelectContents } from "./schema-types";
+export declare const SIMPLE_TYPES: ReadonlySet<string>;
+export declare class IfcSchema {
+    readonly name: string;
+    readonly release: string;
+    private readonly table;
+    private readonly entityNames;
+    private readonly typeNames;
+    private readonly infos;
+    private subtypeLists;
+    private readonly selects;
+    constructor(table: CompactSchema);
+    entityName(name: string): string | undefined;
+    typeName(name: string): string | undefined;
+    hasEntity(name: string): boolean;
+    type(name: string): CompactType | undefined;
+    entity(name: string): IfcEntityInfo;
+    isSubtypeOf(name: string, ancestor: string): boolean;
+    subtypesOf(name: string): readonly string[];
+    selectContents(select: string): SelectContents;
+    underlying(spec: IfcTypeSpec): IfcTypeSpec;
+    private build;
+}

package/lib/schema/schema.js

@@ -0,0 +1,136 @@
+export const SIMPLE_TYPES = new Set(["REAL", "INTEGER", "NUMBER", "STRING", "BOOLEAN", "LOGICAL", "BINARY"]);
+export class IfcSchema {
+    constructor(table) {
+        this.infos = new Map();
+        this.selects = new Map();
+        this.table = table;
+        this.name = table.name;
+        this.release = table.release;
+        this.entityNames = new Map(Object.keys(table.entities).flatMap((name) => [[name, name], [name.toUpperCase(), name]]));
+        this.typeNames = new Map(Object.keys(table.types).map((name) => [name.toUpperCase(), name]));
+    }
+    entityName(name) {
+        var _a;
+        return (_a = this.entityNames.get(name)) !== null && _a !== void 0 ? _a : this.entityNames.get(name.toUpperCase());
+    }
+    typeName(name) {
+        return this.typeNames.get(name.toUpperCase());
+    }
+    hasEntity(name) {
+        return this.entityNames.has(name.toUpperCase());
+    }
+    type(name) {
+        const canonical = this.typeName(name);
+        return canonical === undefined ? undefined : this.table.types[canonical];
+    }
+    entity(name) {
+        const canonical = this.entityName(name);
+        if (canonical === undefined) {
+            throw new Error(`${this.name} has no entity named ${name}`);
+        }
+        const known = this.infos.get(canonical);
+        if (known) {
+            return known;
+        }
+        const info = this.build(canonical);
+        this.infos.set(canonical, info);
+        return info;
+    }
+    isSubtypeOf(name, ancestor) {
+        var _a;
+        const target = this.entityName(ancestor);
+        for (let current = this.entityName(name); current; current = (_a = this.table.entities[current]) === null || _a === void 0 ? void 0 : _a.p) {
+            if (current === target) {
+                return true;
+            }
+        }
+        return false;
+    }
+    subtypesOf(name) {
+        var _a, _b, _c;
+        const canonical = this.entityName(name);
+        if (canonical === undefined) {
+            return [];
+        }
+        if (!this.subtypeLists) {
+            this.subtypeLists = new Map();
+            for (const entity of Object.keys(this.table.entities)) {
+                for (let current = entity; current; current = (_a = this.table.entities[current]) === null || _a === void 0 ? void 0 : _a.p) {
+                    const list = (_b = this.subtypeLists.get(current)) !== null && _b !== void 0 ? _b : [];
+                    list.push(entity);
+                    this.subtypeLists.set(current, list);
+                }
+            }
+        }
+        return (_c = this.subtypeLists.get(canonical)) !== null && _c !== void 0 ? _c : [];
+    }
+    selectContents(select) {
+        const known = this.selects.get(select);
+        if (known) {
+            return known;
+        }
+        const entities = [];
+        const valueTypes = new Set();
+        const seen = new Set();
+        const visit = (name) => {
+            if (seen.has(name)) {
+                return;
+            }
+            seen.add(name);
+            const entity = this.entityName(name);
+            if (entity !== undefined) {
+                entities.push(entity);
+                return;
+            }
+            const type = this.type(name);
+            if (type && "s" in type) {
+                type.s.forEach(visit);
+            }
+            else if (type) {
+                valueTypes.add(this.typeName(name));
+            }
+        };
+        visit(select);
+        const contents = { entities, valueTypes };
+        this.selects.set(select, contents);
+        return contents;
+    }
+    underlying(spec) {
+        let current = spec;
+        for (;;) {
+            if (typeof current !== "string") {
+                return current;
+            }
+            const type = this.type(current);
+            if (!type || !("t" in type)) {
+                return current;
+            }
+            current = type.t;
+        }
+    }
+    build(name) {
+        var _a, _b, _c;
+        const chain = [];
+        for (let current = name; current; current = (_a = this.table.entities[current]) === null || _a === void 0 ? void 0 : _a.p) {
+            chain.unshift(current);
+        }
+        const derived = new Set();
+        for (const link of chain) {
+            (_c = (_b = this.table.entities[link]) === null || _b === void 0 ? void 0 : _b.d) === null || _c === void 0 ? void 0 : _c.forEach((attribute) => derived.add(attribute));
+        }
+        const attributes = [];
+        for (const link of chain) {
+            for (const attribute of this.table.entities[link].a) {
+                attributes.push({ name: attribute[0], type: attribute[1], optional: attribute[2] === 1, derived: derived.has(attribute[0]) });
+            }
+        }
+        const entity = this.table.entities[name];
+        return {
+            name,
+            supertype: entity.p,
+            abstract: entity.abs === 1,
+            attributes,
+            positions: new Map(attributes.map((attribute, index) => [attribute.name, index])),
+        };
+    }
+}

package/lib/step/constants.d.ts

@@ -0,0 +1,48 @@
+export declare const PRINTABLE_FIRST = 32;
+export declare const PRINTABLE_LAST = 126;
+export declare const BMP_LIMIT = 65535;
+export declare const MAX_CODE_POINT = 1114111;
+export declare const HEX_RADIX = 16;
+export declare const DECIMAL_RADIX = 10;
+export declare const UCS2_DIGITS = 4;
+export declare const UCS4_DIGITS = 8;
+export declare const BYTE_DIGITS = 2;
+export declare const UPPER_HALF_OFFSET = 128;
+export declare const CHARACTERS_PER_CHUNK = 8192;
+export declare const LATIN1_PART = 1;
+export declare const MAX_NESTING = 64;
+export declare const INITIAL_ROWS = 1024;
+export declare const MAX_EXPRESS_ID = 2147483647;
+export declare const MAX_FILE_BYTES: number;
+export declare const MAX_TYPE_CODES = 65536;
+export declare const TYPE_HASH_PRIME = 16777619;
+export declare const UPPER_CASE_OFFSET = 32;
+export declare const BOM: readonly [239, 187, 191];
+export declare const CHAR_HASH = 35;
+export declare const CHAR_EQUALS = 61;
+export declare const CHAR_OPEN = 40;
+export declare const CHAR_CLOSE = 41;
+export declare const CHAR_COMMA = 44;
+export declare const CHAR_SEMICOLON = 59;
+export declare const CHAR_APOSTROPHE = 39;
+export declare const CHAR_QUOTE = 34;
+export declare const CHAR_DOT = 46;
+export declare const CHAR_DOLLAR = 36;
+export declare const CHAR_STAR = 42;
+export declare const CHAR_SLASH = 47;
+export declare const CHAR_MINUS = 45;
+export declare const CHAR_PLUS = 43;
+export declare const CHAR_ZERO = 48;
+export declare const CHAR_NINE = 57;
+export declare const CHAR_UPPER_A = 65;
+export declare const CHAR_UPPER_Z = 90;
+export declare const CHAR_LOWER_A = 97;
+export declare const CHAR_LOWER_Z = 122;
+export declare const CHAR_UNDERSCORE = 95;
+export declare const CHAR_UPPER_E = 69;
+export declare const CHAR_LOWER_E = 101;
+export declare const CHAR_SPACE = 32;
+export declare const CHAR_BACKSLASH = 92;
+export declare const CHAR_TILDE = 126;
+export declare const DEFAULT_IMPLEMENTATION_LEVEL = "2;1";
+export declare const HEADER_ENTITIES_READ: readonly ["FILE_DESCRIPTION", "FILE_NAME", "FILE_SCHEMA"];

package/lib/step/constants.js

@@ -0,0 +1,48 @@
+export const PRINTABLE_FIRST = 0x20;
+export const PRINTABLE_LAST = 0x7e;
+export const BMP_LIMIT = 0xffff;
+export const MAX_CODE_POINT = 0x10ffff;
+export const HEX_RADIX = 16;
+export const DECIMAL_RADIX = 10;
+export const UCS2_DIGITS = 4;
+export const UCS4_DIGITS = 8;
+export const BYTE_DIGITS = 2;
+export const UPPER_HALF_OFFSET = 0x80;
+export const CHARACTERS_PER_CHUNK = 8192;
+export const LATIN1_PART = 1;
+export const MAX_NESTING = 64;
+export const INITIAL_ROWS = 1024;
+export const MAX_EXPRESS_ID = 2147483647;
+export const MAX_FILE_BYTES = Math.pow(2, 32) - 1;
+export const MAX_TYPE_CODES = 0x10000;
+export const TYPE_HASH_PRIME = 16777619;
+export const UPPER_CASE_OFFSET = 0x20;
+export const BOM = [0xef, 0xbb, 0xbf];
+export const CHAR_HASH = 0x23;
+export const CHAR_EQUALS = 0x3d;
+export const CHAR_OPEN = 0x28;
+export const CHAR_CLOSE = 0x29;
+export const CHAR_COMMA = 0x2c;
+export const CHAR_SEMICOLON = 0x3b;
+export const CHAR_APOSTROPHE = 0x27;
+export const CHAR_QUOTE = 0x22;
+export const CHAR_DOT = 0x2e;
+export const CHAR_DOLLAR = 0x24;
+export const CHAR_STAR = 0x2a;
+export const CHAR_SLASH = 0x2f;
+export const CHAR_MINUS = 0x2d;
+export const CHAR_PLUS = 0x2b;
+export const CHAR_ZERO = 0x30;
+export const CHAR_NINE = 0x39;
+export const CHAR_UPPER_A = 0x41;
+export const CHAR_UPPER_Z = 0x5a;
+export const CHAR_LOWER_A = 0x61;
+export const CHAR_LOWER_Z = 0x7a;
+export const CHAR_UNDERSCORE = 0x5f;
+export const CHAR_UPPER_E = 0x45;
+export const CHAR_LOWER_E = 0x65;
+export const CHAR_SPACE = 0x20;
+export const CHAR_BACKSLASH = 0x5c;
+export const CHAR_TILDE = 0x7e;
+export const DEFAULT_IMPLEMENTATION_LEVEL = "2;1";
+export const HEADER_ENTITIES_READ = ["FILE_DESCRIPTION", "FILE_NAME", "FILE_SCHEMA"];

package/lib/step/encoder.d.ts

@@ -0,0 +1,21 @@
+import type { IfcSchema } from "../schema/schema";
+import type { IfcEntityInfo, IfcTypeSpec } from "../schema/schema-types";
+import type { IfcEntity, IfcValue } from "./step-types";
+export declare class IfcEncoder {
+    private readonly schema;
+    constructor(schema: IfcSchema);
+    normalizeArguments(type: string, args: readonly IfcValue[], path: string): IfcValue[];
+    normalizeAttribute(info: IfcEntityInfo, index: number, value: IfcValue, path: string): IfcValue;
+    encodeEntity(entity: IfcEntity): string;
+    encodeValue(spec: IfcTypeSpec, value: IfcValue, path: string): string;
+    private writable;
+    private located;
+    private enumMember;
+    private selected;
+    private definedValue;
+    private checkGlobalId;
+    private normalize;
+    private normalizeList;
+    private format;
+}
+export declare function encoderFor(schema: IfcSchema): IfcEncoder;