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

package/lib/model/source.js

@@ -0,0 +1,172 @@
+import { ROOT_ENTITY } from "../schema/constants";
+import { StepSyntaxError } from "../step/errors";
+import { decodeArguments } from "../step/reader";
+import { firstStringIn, plainText, referenceCapacity, referenceList, referencesInto, textOf } from "../step/scanner";
+import { decodeString } from "../step/strings";
+import { RowsById } from "./rows-by-id";
+const NO_IDS = [];
+const UNSEEN = -1;
+export class IfcSource {
+    constructor(index, schema) {
+        this.decoded = new Map();
+        this.index = index;
+        this.schema = schema;
+        this.rows = new RowsById(index);
+        this.maxId = this.rows.maxId;
+        this.typeOfCode = index.typeTable.map((name) => schema.entityName(name));
+        this.spell = (typeName) => { var _a; return (_a = schema.typeName(typeName)) !== null && _a !== void 0 ? _a : typeName; };
+    }
+    has(id) {
+        return this.rows.rowOf(id) >= 0;
+    }
+    typeOf(id) {
+        const row = this.rows.rowOf(id);
+        return row < 0 ? undefined : this.typeOfRow(row);
+    }
+    rawTypeOf(id) {
+        const row = this.rows.rowOf(id);
+        return row < 0 ? undefined : this.index.typeTable[this.index.typeCodes[row]] || "complex instance";
+    }
+    get(id) {
+        const known = this.decoded.get(id);
+        if (known) {
+            return known;
+        }
+        const entity = this.decode(id);
+        if (entity) {
+            this.decoded.set(id, entity);
+        }
+        return entity;
+    }
+    peek(id) {
+        var _a;
+        return (_a = this.decoded.get(id)) !== null && _a !== void 0 ? _a : this.decode(id);
+    }
+    referenceList(id) {
+        const row = this.rows.rowOf(id);
+        return row < 0 ? undefined : referenceList(this.index.bytes, this.index.argStart[row], this.index.argEnd[row]);
+    }
+    rawArguments(id) {
+        const row = this.rows.rowOf(id);
+        return row < 0 ? undefined : decodeArguments(this.index.bytes, this.index.argStart[row], this.index.argEnd[row], this.spell);
+    }
+    decode(id) {
+        const row = this.rows.rowOf(id);
+        if (row < 0) {
+            return undefined;
+        }
+        const type = this.typeOfRow(row);
+        if (type === undefined) {
+            throw new StepSyntaxError(`Entity #${id} is a ${this.rawTypeOf(id)}, which ${this.schema.name} does not define`, this.index.rowStart[row]);
+        }
+        return { id, type, args: decodeArguments(this.index.bytes, this.index.argStart[row], this.index.argEnd[row], this.spell) };
+    }
+    idsOfType(type) {
+        var _a;
+        if (!this.typeIds) {
+            const lists = this.typeOfCode.map(() => []);
+            for (let row = 0; row < this.index.count; row++) {
+                lists[this.index.typeCodes[row]].push(this.index.ids[row]);
+            }
+            const index = new Map();
+            this.typeOfCode.forEach((name, code) => {
+                var _a;
+                if (name !== undefined && lists[code].length) {
+                    index.set(name, [...((_a = index.get(name)) !== null && _a !== void 0 ? _a : []), ...lists[code]]);
+                }
+            });
+            this.typeIds = index;
+        }
+        return (_a = this.typeIds.get(type)) !== null && _a !== void 0 ? _a : NO_IDS;
+    }
+    ownersOfGlobalId(globalId) {
+        var _a, _b;
+        (_a = this.globalIdOwners) !== null && _a !== void 0 ? _a : (this.globalIdOwners = this.indexGlobalIds());
+        const first = this.globalIdOwners.first.get(globalId);
+        return first === undefined ? NO_IDS : [first, ...((_b = this.globalIdOwners.more.get(globalId)) !== null && _b !== void 0 ? _b : NO_IDS)];
+    }
+    usersOf(id) {
+        const row = this.rows.rowOf(id);
+        if (row < 0) {
+            return NO_IDS;
+        }
+        if (!this.users) {
+            this.users = this.indexUsers();
+        }
+        return Array.from(this.users.users.subarray(this.users.offsets[row], this.users.offsets[row + 1]));
+    }
+    indexGlobalIds() {
+        var _a;
+        const first = new Map();
+        const more = new Map();
+        const { bytes, argStart, argEnd, ids, count, typeCodes } = this.index;
+        const rooted = this.typeOfCode.map((type) => type !== undefined && this.schema.isSubtypeOf(type, ROOT_ENTITY));
+        for (let row = 0; row < count; row++) {
+            const span = rooted[typeCodes[row]] ? firstStringIn(bytes, argStart[row], argEnd[row]) : undefined;
+            if (!span) {
+                continue;
+            }
+            const globalId = (_a = plainText(bytes, span[0], span[1])) !== null && _a !== void 0 ? _a : decodeString(textOf(bytes, span[0], span[1]), span[0]);
+            if (!first.has(globalId)) {
+                first.set(globalId, ids[row]);
+                continue;
+            }
+            const list = more.get(globalId);
+            if (list) {
+                list.push(ids[row]);
+            }
+            else {
+                more.set(globalId, [ids[row]]);
+            }
+        }
+        return { first, more };
+    }
+    typeOfRow(row) {
+        return this.typeOfCode[this.index.typeCodes[row]];
+    }
+    indexUsers() {
+        const { ids, count } = this.index;
+        const offsets = new Int32Array(count + 1);
+        const seen = new Int32Array(count).fill(UNSEEN);
+        let scratch = new Int32Array(0);
+        const targetRows = (row, stamp) => {
+            const start = this.index.argStart[row];
+            const end = this.index.argEnd[row];
+            const capacity = referenceCapacity(this.index.bytes, start, end);
+            if (capacity === 0) {
+                return 0;
+            }
+            if (scratch.length < capacity) {
+                scratch = new Int32Array(Math.max(capacity, 2 * scratch.length));
+            }
+            const found = referencesInto(this.index.bytes, start, end, scratch);
+            let kept = 0;
+            for (let at = 0; at < found; at++) {
+                const target = this.rows.rowOf(scratch[at]);
+                if (target >= 0 && seen[target] !== stamp) {
+                    seen[target] = stamp;
+                    scratch[kept++] = target;
+                }
+            }
+            return kept;
+        };
+        for (let row = 0; row < count; row++) {
+            const kept = targetRows(row, row);
+            for (let at = 0; at < kept; at++) {
+                offsets[scratch[at] + 1]++;
+            }
+        }
+        for (let row = 0; row < count; row++) {
+            offsets[row + 1] = offsets[row + 1] + offsets[row];
+        }
+        const users = new Int32Array(offsets[count]);
+        const filled = offsets.slice(0, count);
+        for (let row = 0; row < count; row++) {
+            const kept = targetRows(row, row + count);
+            for (let at = 0; at < kept; at++) {
+                users[filled[scratch[at]]++] = ids[row];
+            }
+        }
+        return { offsets, users };
+    }
+}

package/lib/model/transaction.d.ts

@@ -0,0 +1,39 @@
+import type { IfcEntity, IfcValue } from "../step/step-types";
+import type { IfcSchema } from "../schema/schema";
+import { EntityLookup } from "./entity-lookup";
+import type { IfcAttributes } from "./model-types";
+import { ModelSnapshot } from "./snapshot";
+export declare class IfcTransaction extends EntityLookup {
+    readonly base: ModelSnapshot;
+    private readonly changes;
+    private readonly changedUsers;
+    private readonly keySeed;
+    private readonly usedGlobalIds;
+    private readonly dropCandidates;
+    private nextId;
+    private issued;
+    private committed;
+    constructor(base: ModelSnapshot, keySeed?: string);
+    get schema(): IfcSchema;
+    get(id: number): IfcEntity | undefined;
+    typeOf(id: number): string | undefined;
+    byType(type: string): IfcEntity[];
+    referencesTo(id: number): readonly number[];
+    argsFrom(type: string, attributes: IfcAttributes): IfcValue[];
+    create(type: string, attributes?: IfcAttributes): number;
+    update(id: number, attributes: IfcAttributes): void;
+    delete(id: number): void;
+    globalId(key: string | undefined): string;
+    givenGlobalId(globalId: string): string;
+    structureGlobalId(name: string): string;
+    dropIfUnused(ids: readonly number[]): void;
+    commit(): ModelSnapshot;
+    private record;
+    private automaticGlobalId;
+    private claim;
+    private assertOpen;
+    private checkGlobalIds;
+    private pruneUnused;
+    private onlyPresents;
+    private letGo;
+}

package/lib/model/transaction.js

@@ -0,0 +1,250 @@
+import { MAX_EXPRESS_ID } from "../step/constants";
+import { encoderFor } from "../step/encoder";
+import { DERIVED, isDerived, isList, isReference, referencesIn } from "../step/values";
+import { PRUNABLE_TYPES } from "./constants";
+import { EntityLookup } from "./entity-lookup";
+import { automaticGlobalId, keyGlobalId, randomGlobalId, structureGlobalId } from "./guid";
+import { checkReferences } from "./references";
+import { ModelSnapshot } from "./snapshot";
+const ascending = (a, b) => a - b;
+const STYLED_ITEM = "IfcStyledItem";
+const LAYER_ASSIGNMENT = "IfcPresentationLayerAssignment";
+export class IfcTransaction extends EntityLookup {
+    constructor(base, keySeed = base.keySeed) {
+        super();
+        this.changes = new Map();
+        this.changedUsers = new Map();
+        this.usedGlobalIds = new Set();
+        this.dropCandidates = new Set();
+        this.issued = 0;
+        this.committed = false;
+        if (!base.editable) {
+            throw new Error(base.schemaName === base.schema.name
+                ? `This ${base.schemaName} model can be shown and queried but not changed; changes are made to IFC4 models`
+                : `This ${base.schemaName} file is read through the ${base.schema.name} schema, so it can be shown and queried but not changed`);
+        }
+        this.base = base;
+        this.nextId = base.nextId;
+        this.keySeed = keySeed;
+    }
+    get schema() {
+        return this.base.schema;
+    }
+    get(id) {
+        var _a;
+        if (this.changes.has(id)) {
+            return (_a = this.changes.get(id)) !== null && _a !== void 0 ? _a : undefined;
+        }
+        return this.base.get(id);
+    }
+    typeOf(id) {
+        var _a;
+        if (this.changes.has(id)) {
+            return (_a = this.changes.get(id)) === null || _a === void 0 ? void 0 : _a.type;
+        }
+        return this.base.typeOf(id);
+    }
+    byType(type) {
+        const found = [];
+        for (const entity of this.base.byType(type)) {
+            if (!this.changes.has(entity.id)) {
+                found.push(entity);
+            }
+        }
+        for (const entity of this.changes.values()) {
+            if (entity && this.schema.isSubtypeOf(entity.type, type)) {
+                found.push(entity);
+            }
+        }
+        return found.sort((a, b) => a.id - b.id);
+    }
+    referencesTo(id) {
+        var _a;
+        const users = this.base.referencesTo(id).filter((user) => !this.changes.has(user));
+        users.push(...((_a = this.changedUsers.get(id)) !== null && _a !== void 0 ? _a : []));
+        return users.sort(ascending);
+    }
+    argsFrom(type, attributes) {
+        const info = this.schema.entity(type);
+        const unknown = Object.keys(attributes).filter((name) => !info.positions.has(name));
+        if (unknown.length) {
+            throw new Error(`${info.name} has no attribute ${unknown.join(", ")}`);
+        }
+        const misplaced = info.attributes.find((attribute) => attribute.derived && attributes[attribute.name] !== undefined && !isDerived(attributes[attribute.name]));
+        if (misplaced) {
+            throw new Error(`${info.name}.${misplaced.name} is derived and takes no value`);
+        }
+        return info.attributes.map((attribute) => { var _a; return (attribute.derived ? DERIVED : (_a = attributes[attribute.name]) !== null && _a !== void 0 ? _a : null); });
+    }
+    create(type, attributes = {}) {
+        this.assertOpen();
+        const info = this.schema.entity(type);
+        const id = this.nextId;
+        if (id > MAX_EXPRESS_ID) {
+            throw new Error(`The model has no express id left below ${MAX_EXPRESS_ID}`);
+        }
+        const args = encoderFor(this.schema).normalizeArguments(info.name, this.argsFrom(info.name, attributes), `#${id}`);
+        this.nextId++;
+        this.record(id, { id, type: info.name, args });
+        return id;
+    }
+    update(id, attributes) {
+        this.assertOpen();
+        const entity = this.entity(id);
+        const info = this.schema.entity(entity.type);
+        const encoder = encoderFor(this.schema);
+        const args = [...entity.args];
+        for (const [name, value] of Object.entries(attributes)) {
+            const position = info.positions.get(name);
+            if (position === undefined) {
+                throw new Error(`${info.name} has no attribute ${name}`);
+            }
+            if (info.attributes[position].derived) {
+                throw new Error(`${info.name}.${name} is derived and takes no value`);
+            }
+            args[position] = encoder.normalizeAttribute(info, position, value !== null && value !== void 0 ? value : null, `#${id}`);
+        }
+        this.record(id, { id, type: info.name, args });
+    }
+    delete(id) {
+        this.assertOpen();
+        this.entity(id);
+        this.record(id, null);
+    }
+    globalId(key) {
+        const globalId = key === undefined ? this.automaticGlobalId() : keyGlobalId(this.keySeed, key);
+        this.claim(globalId, key === undefined ? `the GlobalId ${globalId}` : `the id '${key}'`);
+        return globalId;
+    }
+    givenGlobalId(globalId) {
+        this.claim(globalId, `the GlobalId ${globalId}`);
+        return globalId;
+    }
+    structureGlobalId(name) {
+        const globalId = structureGlobalId(this.keySeed, name);
+        this.claim(globalId, `the GlobalId ${globalId}`);
+        return globalId;
+    }
+    dropIfUnused(ids) {
+        ids.forEach((id) => this.dropCandidates.add(id));
+    }
+    commit() {
+        this.assertOpen();
+        this.committed = true;
+        this.pruneUnused();
+        const overlay = this.base.overlay.withChanges([...this.changes].map(([id, entity]) => { var _a; return [id, entity === null && !((_a = this.base.source) === null || _a === void 0 ? void 0 : _a.has(id)) ? undefined : entity]; }));
+        const next = new ModelSnapshot(Object.assign(Object.assign({}, this.base.parts), { overlay, nextId: this.nextId }));
+        const inherited = this.base.releaseIndexes();
+        if (inherited) {
+            for (const [id, entity] of this.changes) {
+                const before = this.base.overlay.get(id);
+                if (before) {
+                    inherited.remove(before);
+                }
+                if (entity) {
+                    inherited.add(entity);
+                }
+            }
+            next.adoptIndexes(inherited);
+        }
+        const changed = [...this.changes.keys()].filter((id) => this.changes.get(id) !== null);
+        const deleted = [...this.changes.keys()].filter((id) => this.changes.get(id) === null);
+        checkReferences(next, changed, deleted);
+        this.checkGlobalIds(next, changed);
+        return next;
+    }
+    record(id, entity) {
+        var _a;
+        const before = this.changes.get(id);
+        for (const target of new Set(before ? before.args.flatMap((arg) => referencesIn(arg)) : [])) {
+            (_a = this.changedUsers.get(target)) === null || _a === void 0 ? void 0 : _a.delete(id);
+        }
+        for (const target of new Set(entity ? entity.args.flatMap((arg) => referencesIn(arg)) : [])) {
+            let users = this.changedUsers.get(target);
+            if (!users) {
+                users = new Set();
+                this.changedUsers.set(target, users);
+            }
+            users.add(id);
+        }
+        this.changes.set(id, entity);
+    }
+    automaticGlobalId() {
+        return this.base.seededIds ? automaticGlobalId(this.keySeed, `${this.base.nextId}.${this.issued++}`) : randomGlobalId();
+    }
+    claim(globalId, what) {
+        if (this.usedGlobalIds.has(globalId) || this.base.byGlobalId(globalId) !== undefined) {
+            throw new Error(`The model already holds an object with ${what}`);
+        }
+        this.usedGlobalIds.add(globalId);
+    }
+    assertOpen() {
+        if (this.committed) {
+            throw new Error("The transaction has been committed; start a new one from the model it made");
+        }
+    }
+    checkGlobalIds(next, changed) {
+        const indexes = next.overlayIndexes();
+        for (const id of changed) {
+            const globalId = indexes.globalIdOf(next.entity(id));
+            const before = this.base.get(id);
+            if (globalId === undefined || (before && indexes.globalIdOf(before) === globalId)) {
+                continue;
+            }
+            const owners = next.globalIdOwners(globalId);
+            if (owners.length > 1) {
+                throw new Error(`#${owners[0]} and #${owners[1]} have the same GlobalId ${globalId}`);
+            }
+        }
+    }
+    pruneUnused() {
+        if (!this.dropCandidates.size) {
+            return;
+        }
+        const removed = new Set();
+        const work = [...this.dropCandidates];
+        while (work.length) {
+            const id = work.pop();
+            const entity = this.get(id);
+            if (!entity || removed.has(id) || !PRUNABLE_TYPES.some((type) => this.schema.isSubtypeOf(entity.type, type))) {
+                continue;
+            }
+            const users = this.referencesTo(id).filter((user) => !removed.has(user));
+            if (!users.every((user) => this.onlyPresents(user, id, removed))) {
+                continue;
+            }
+            users.forEach((user) => this.letGo(user, id, removed));
+            removed.add(id);
+            this.record(id, null);
+            work.push(...entity.args.flatMap((arg) => referencesIn(arg)));
+        }
+    }
+    onlyPresents(user, id, removed) {
+        const entity = this.get(user);
+        if (!entity) {
+            return false;
+        }
+        if (this.schema.isSubtypeOf(entity.type, STYLED_ITEM)) {
+            const item = this.attribute(user, "Item");
+            return isReference(item) && item.ref === id && this.referencesTo(user).every((other) => removed.has(other));
+        }
+        return this.schema.isSubtypeOf(entity.type, LAYER_ASSIGNMENT);
+    }
+    letGo(user, id, removed) {
+        const entity = this.get(user);
+        if (this.schema.isSubtypeOf(entity.type, STYLED_ITEM)) {
+            removed.add(user);
+            this.record(user, null);
+            return;
+        }
+        const position = this.schema.entity(entity.type).positions.get("AssignedItems");
+        const assigned = entity.args[position];
+        const kept = (isList(assigned) ? assigned : []).filter((item) => !(isReference(item) && item.ref === id));
+        if (!kept.length) {
+            removed.add(user);
+            this.record(user, null);
+            return;
+        }
+        this.record(user, Object.assign(Object.assign({}, entity), { args: entity.args.map((arg, index) => (index === position ? kept : arg)) }));
+    }
+}

package/lib/model/upgrade.d.ts

@@ -0,0 +1,2 @@
+import { ModelSnapshot } from "./snapshot";
+export declare function upgradeToIfc4(model: ModelSnapshot): ModelSnapshot;

package/lib/model/upgrade.js

@@ -0,0 +1,78 @@
+import { encoderFor } from "../step/encoder";
+import { DERIVED, enumValue, isDerived, isList, isReference } from "../step/values";
+import { ModelSnapshot } from "./snapshot";
+const IFC4 = "IFC4";
+const NOT_DEFINED = "NOTDEFINED";
+const SET = "SET";
+const SUCCESSORS = new Map([["IFCRELOCCUPIESSPACES", "IfcRelAssignsToActor"]]);
+function notDefinedFor(schema, attribute) {
+    const type = typeof attribute.type === "string" ? schema.type(attribute.type) : undefined;
+    return type && "e" in type && type.e.includes(NOT_DEFINED) ? enumValue(NOT_DEFINED) : undefined;
+}
+function keyOf(value) {
+    return isReference(value) ? `#${value.ref}` : JSON.stringify(value);
+}
+function withoutRepeats(values) {
+    const seen = new Set();
+    const kept = values.filter((value) => {
+        const key = keyOf(value);
+        const fresh = !seen.has(key);
+        seen.add(key);
+        return fresh;
+    });
+    return kept.length === values.length ? values : kept;
+}
+function upgradedValue(schema, info, entity, index, value) {
+    const attribute = info.attributes[index];
+    if (attribute.derived) {
+        return isDerived(value) ? value : DERIVED;
+    }
+    if (value === null || isDerived(value)) {
+        if (attribute.optional) {
+            return value === null ? value : null;
+        }
+        const fallback = notDefinedFor(schema, attribute);
+        if (fallback === undefined) {
+            throw new Error(`#${entity.id} ${info.name}.${attribute.name} is required by IFC4 and the file leaves it out, so the file cannot be upgraded`);
+        }
+        return fallback;
+    }
+    return Array.isArray(attribute.type) && attribute.type[0] === SET && isList(value) ? withoutRepeats(value) : value;
+}
+function upgradedEntity(model, id) {
+    var _a, _b;
+    const known = model.typeOf(id);
+    if (known !== undefined) {
+        return model.peek(id);
+    }
+    const raw = (_b = (_a = model.source) === null || _a === void 0 ? void 0 : _a.rawTypeOf(id)) !== null && _b !== void 0 ? _b : "";
+    const successor = SUCCESSORS.get(raw.toUpperCase());
+    if (successor === undefined) {
+        throw new Error(`#${id} is an ${raw}, which IFC4 has no counterpart for, so the file cannot be upgraded`);
+    }
+    return { id, type: successor, args: model.source.rawArguments(id) };
+}
+export function upgradeToIfc4(model) {
+    if (model.editable && model.schemaName === IFC4) {
+        return model;
+    }
+    if (model.schema.name !== IFC4) {
+        throw new Error(`Only an IFC2X3 model is upgraded to IFC4, and this one is ${model.schemaName}`);
+    }
+    const encoder = encoderFor(model.schema);
+    const changes = [];
+    for (const id of model.ids()) {
+        const entity = upgradedEntity(model, id);
+        const info = model.schema.entity(entity.type);
+        if (entity.args.length > info.attributes.length) {
+            throw new Error(`#${id} gives ${entity.args.length} values where IFC4's ${info.name} takes ${info.attributes.length}, so the file cannot be upgraded`);
+        }
+        const args = info.attributes.map((_, index) => { var _a; return upgradedValue(model.schema, info, entity, index, (_a = entity.args[index]) !== null && _a !== void 0 ? _a : null); });
+        const normalized = encoder.normalizeArguments(info.name, args, `#${id}`);
+        const changed = entity.type !== model.typeOf(id) || entity.args.length !== args.length || args.some((value, index) => value !== entity.args[index]);
+        if (changed) {
+            changes.push([id, { id, type: info.name, args: normalized }]);
+        }
+    }
+    return new ModelSnapshot(Object.assign(Object.assign({}, model.parts), { header: Object.assign(Object.assign({}, model.header), { schemaIdentifiers: [IFC4] }), overlay: model.overlay.withChanges(changes) }));
+}

package/lib/schema/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const GLOBAL_ID_TYPE = "IfcGloballyUniqueId";
+export declare const GLOBAL_ID_PATTERN: RegExp;
+export declare const ROOT_ENTITY = "IfcRoot";

package/lib/schema/constants.js

@@ -0,0 +1,3 @@
+export const GLOBAL_ID_TYPE = "IfcGloballyUniqueId";
+export const GLOBAL_ID_PATTERN = /^[0-3][0-9A-Za-z_$]{21}$/;
+export const ROOT_ENTITY = "IfcRoot";

package/lib/schema/generated/ifc4.d.ts

@@ -0,0 +1,2 @@
+import type { CompactSchema } from "../schema-types";
+export declare const IFC4_SCHEMA: CompactSchema;