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

package/lib/model/io.js

@@ -0,0 +1,136 @@
+import { isZip, zipEntries, zipEntryData } from "@bitbybit-dev/base/lib/api/services/helpers/zip";
+import { describeSupportedSchemas, readingSchemaFor, schemaNamed } from "../schema/registry";
+import { StepSyntaxError } from "../step/errors";
+import { encoderFor } from "../step/encoder";
+import { indexStep } from "../step/file-index";
+import { encodeHeader, headerFromEntities, otherHeaderEntities } from "../step/header";
+import { textOf } from "../step/scanner";
+import { ARCHIVE_RESOURCE_FOLDER, CARRIAGE_RETURN, IFC_EXTENSION, LINE_BREAK, LINE_FEED, LONGEST_STRING, TEXT_PER_CHUNK, WINDOWS_LINE_BREAK } from "./constants";
+import { IdMap } from "./id-map";
+import { ModelSnapshot } from "./snapshot";
+import { IfcSource } from "./source";
+const encoder = new TextEncoder();
+const FILE_SCHEMA = "FILE_SCHEMA";
+function ifcInArchive(archive) {
+    const files = zipEntries(archive).filter((entry) => !entry.name.endsWith("/") && !entry.name.startsWith(ARCHIVE_RESOURCE_FOLDER));
+    const models = files.filter((entry) => entry.name.toLowerCase().endsWith(IFC_EXTENSION));
+    if (models.length !== 1) {
+        const held = (models.length ? models : files).map((entry) => entry.name).join(", ");
+        throw new StepSyntaxError(models.length ? `The .ifczip archive holds ${models.length} .ifc files (${held}), not one` : `The .ifczip archive holds no .ifc file${held ? `, only ${held}` : ""}`, 0);
+    }
+    return zipEntryData(archive, models[0]);
+}
+function bytesOf(input) {
+    if (typeof input === "string") {
+        return encoder.encode(input);
+    }
+    const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+    return isZip(bytes) ? ifcInArchive(bytes) : bytes;
+}
+export function readModel(input) {
+    var _a, _b;
+    const index = indexStep(bytesOf(input));
+    const header = headerFromEntities(index.header);
+    const schemaName = header.schemaIdentifiers[0];
+    const named = (_b = (_a = index.header.find((entity) => entity.type === FILE_SCHEMA)) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : index.headerEnd;
+    if (schemaName === undefined) {
+        throw new StepSyntaxError("The file names no schema in FILE_SCHEMA", named);
+    }
+    const schema = readingSchemaFor(schemaName);
+    if (schema === undefined) {
+        throw new StepSyntaxError(`The file's schema ${schemaName} is not supported; supported: ${describeSupportedSchemas()}`, named);
+    }
+    const source = new IfcSource(index, schema);
+    return new ModelSnapshot({ schema, header, headerExtras: otherHeaderEntities(index.header), source, overlay: IdMap.empty(), nextId: source.maxId + 1, seededIds: false });
+}
+export function emptyModel(schemaName, header) {
+    return new ModelSnapshot({ schema: schemaNamed(schemaName), header, headerExtras: [], source: undefined, overlay: IdMap.empty(), nextId: 1, seededIds: true });
+}
+function lineBreakOf(bytes) {
+    const feed = bytes.indexOf(LINE_FEED);
+    return feed > 0 && bytes[feed - 1] === CARRIAGE_RETURN ? WINDOWS_LINE_BREAK : LINE_BREAK;
+}
+function rowsOf(model) {
+    const rows = [];
+    const encode = encoderFor(model.schema);
+    const source = model.source;
+    if (source) {
+        const { bytes, ids, rowStart, rowEnd, count, sectionStarts } = source.index;
+        const breaks = new Set(sectionStarts);
+        let runStart = -1;
+        const flush = (endRow) => {
+            if (runStart >= 0) {
+                rows.push(bytes.subarray(rowStart[runStart], rowEnd[endRow - 1]));
+                runStart = -1;
+            }
+        };
+        for (let row = 0; row < count; row++) {
+            const changed = model.overlay.get(ids[row]);
+            if (breaks.has(row)) {
+                flush(row);
+            }
+            if (changed === undefined) {
+                runStart = runStart < 0 ? row : runStart;
+                continue;
+            }
+            flush(row);
+            if (changed !== null) {
+                rows.push(encode.encodeEntity(changed));
+            }
+        }
+        flush(count);
+    }
+    model.overlay.forEach((entity, id) => {
+        if (entity && !(source === null || source === void 0 ? void 0 : source.has(id))) {
+            rows.push(encode.encodeEntity(entity));
+        }
+    });
+    return rows;
+}
+function partsOf(model, header) {
+    const source = model.source;
+    const index = source && source.index.count > 0 ? source.index : undefined;
+    const lineBreak = source ? lineBreakOf(source.index.bytes) : LINE_BREAK;
+    const rows = rowsOf(model);
+    const sameHeader = source !== undefined && JSON.stringify(header) === JSON.stringify(headerFromEntities(source.index.header));
+    const encodedHeader = () => encodeHeader(header, model.headerExtras).split(LINE_BREAK).join(lineBreak);
+    const head = !index
+        ? [`${encodedHeader()}${lineBreak}DATA;${lineBreak}`]
+        : sameHeader
+            ? [index.bytes.subarray(0, index.rowStart[0])]
+            : [encodedHeader(), index.bytes.subarray(index.afterHeader, index.rowStart[0])];
+    const tail = index ? index.bytes.subarray(index.rowEnd[index.count - 1]) : `${rows.length ? lineBreak : ""}ENDSEC;${lineBreak}END-ISO-10303-21;${lineBreak}`;
+    return [...head, ...rows.flatMap((row, at) => (at === 0 ? [row] : [lineBreak, row])), tail];
+}
+export function writeModel(model, header = model.header, longest = LONGEST_STRING) {
+    const parts = partsOf(model, header);
+    const length = parts.reduce((sum, part) => sum + part.length, 0);
+    if (length > longest) {
+        throw new Error(`The file is about ${length} bytes, more than one JavaScript string holds; write it with model.writeBytes`);
+    }
+    return parts.map((part) => (typeof part === "string" ? part : textOf(part, 0, part.length))).join("");
+}
+export function writeModelBytes(model, header = model.header, textPerChunk = TEXT_PER_CHUNK) {
+    const chunks = [];
+    let text = "";
+    for (const part of partsOf(model, header)) {
+        if (typeof part === "string") {
+            text += part;
+        }
+        if (typeof part !== "string" || text.length > textPerChunk) {
+            chunks.push(encoder.encode(text));
+            text = "";
+        }
+        if (typeof part !== "string") {
+            chunks.push(part);
+        }
+    }
+    chunks.push(encoder.encode(text));
+    const bytes = new Uint8Array(chunks.reduce((sum, chunk) => sum + chunk.length, 0));
+    let at = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, at);
+        at += chunk.length;
+    }
+    return bytes;
+}

package/lib/model/is-model.d.ts

@@ -0,0 +1,9 @@
+import type { IfcModel } from "./model-types";
+/**
+ * Whether a value is a model this library made, as `model.create`, `model.read` and every method
+ * that changes a model return one.
+ * @param value - The value to test
+ * @returns True for a model
+ * @beta
+ */
+export declare function isIfcModel(value: unknown): value is IfcModel;

package/lib/model/is-model.js

@@ -0,0 +1,11 @@
+import { ModelSnapshot } from "./snapshot";
+/**
+ * Whether a value is a model this library made, as `model.create`, `model.read` and every method
+ * that changes a model return one.
+ * @param value - The value to test
+ * @returns True for a model
+ * @beta
+ */
+export function isIfcModel(value) {
+    return value instanceof ModelSnapshot;
+}

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

@@ -0,0 +1,111 @@
+import type { IfcSchema } from "../schema/schema";
+import type { IfcEntity, IfcFileHeader, IfcValue } from "../step/step-types";
+import type { IdMap } from "./id-map";
+import type { IfcSource } from "./source";
+/**
+ * An IFC model at one moment: a schema, a file header and its entities. A model never changes:
+ * every method that edits one returns a new model, which shares with the old one everything the
+ * edit did not touch, so the old model can still be read, written or edited another way.
+ * @beta
+ */
+export interface IfcModel {
+    /**
+     * The schema the model's file names, such as `IFC4`.
+     */
+    readonly schemaName: string;
+    /**
+     * Whether the model can be changed: false for a file whose schema is read through another's,
+     * such as an `IFC2X3` file read through `IFC4`, which can be shown and queried but not edited.
+     */
+    readonly editable: boolean;
+    /**
+     * The file header the model was read or created with.
+     */
+    readonly header: IfcFileHeader;
+    /**
+     * How many entities the model holds.
+     */
+    readonly size: number;
+    /**
+     * Whether the model holds an entity with this express id.
+     * @param id - The express id
+     * @returns True when the entity is there
+     */
+    has(id: number): boolean;
+    /**
+     * The entity with this express id.
+     * @param id - The express id
+     * @returns The entity, or undefined when the model holds none with this id
+     */
+    get(id: number): IfcEntity | undefined;
+    /**
+     * The entity with this express id, which must be there.
+     * @param id - The express id
+     * @returns The entity
+     */
+    entity(id: number): IfcEntity;
+    /**
+     * The type of the entity with this express id, in the schema's spelling.
+     * @param id - The express id
+     * @returns The type, or undefined when there is no such entity or its type is one the schema
+     * does not define
+     */
+    typeOf(id: number): string | undefined;
+    /**
+     * One attribute of an entity, by the attribute's name in the schema.
+     * @param id - The express id of the entity
+     * @param name - The attribute name, such as `Name`
+     * @returns The value, or null when the attribute is unset
+     */
+    attribute(id: number, name: string): IfcValue;
+    /**
+     * The express ids of every entity: those of the file the model was read from in file order,
+     * then those created since, in ascending order.
+     * @returns The ids
+     */
+    ids(): readonly number[];
+    /**
+     * Every entity of a type, in ascending order of express id.
+     * @param type - The entity type, such as `IfcWall`, in any case
+     * @param includeSubtypes - Whether entities of its subtypes count too; true when left out
+     * @returns The entities
+     */
+    byType(type: string, includeSubtypes?: boolean): IfcEntity[];
+    /**
+     * The object with this GlobalId.
+     * @param globalId - The GlobalId
+     * @returns The express id of the object, or undefined when the model holds none with it
+     */
+    byGlobalId(globalId: string): number | undefined;
+    /**
+     * The entities that refer to an entity.
+     * @param id - The express id of the entity referred to
+     * @returns The express ids of the entities that refer to it, in ascending order
+     */
+    referencesTo(id: number): readonly number[];
+}
+export type IfcOverlay = IdMap<IfcEntity | null>;
+export type IfcAttributes = Readonly<Record<string, IfcValue | undefined>>;
+export interface SnapshotParts {
+    readonly schema: IfcSchema;
+    readonly header: IfcFileHeader;
+    readonly headerExtras: readonly string[];
+    readonly source: IfcSource | undefined;
+    readonly overlay: IfcOverlay;
+    readonly nextId: number;
+    readonly seededIds: boolean;
+}
+export interface TrieNode<V> {
+    owner: object | undefined;
+    readonly children: (TrieNode<V> | undefined)[];
+    readonly values: (V | undefined)[];
+}
+export type FilePart = string | Uint8Array;
+export interface GlobalIdOwners {
+    readonly first: Map<string, number>;
+    readonly more: Map<string, number[]>;
+}
+export interface SourceUsers {
+    readonly offsets: Int32Array;
+    readonly users: Int32Array;
+}

package/lib/model/model-types.js

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

package/lib/model/overlay-indexes.d.ts

@@ -0,0 +1,17 @@
+import type { IfcSchema } from "../schema/schema";
+import type { IfcEntity } from "../step/step-types";
+import type { IfcOverlay } from "./model-types";
+export declare class OverlayIndexes {
+    private readonly schema;
+    private readonly types;
+    private readonly globalIds;
+    private readonly users;
+    private readonly rooted;
+    constructor(schema: IfcSchema, overlay: IfcOverlay);
+    globalIdOf(entity: IfcEntity): string | undefined;
+    add(entity: IfcEntity): void;
+    remove(entity: IfcEntity): void;
+    idsOfType(type: string): ReadonlySet<number> | undefined;
+    ownersOfGlobalId(globalId: string): ReadonlySet<number> | undefined;
+    usersOf(id: number): ReadonlySet<number> | undefined;
+}

package/lib/model/overlay-indexes.js

@@ -0,0 +1,69 @@
+import { ROOT_ENTITY } from "../schema/constants";
+import { referencesIn } from "../step/values";
+function addTo(map, key, id) {
+    const set = map.get(key);
+    if (set) {
+        set.add(id);
+    }
+    else {
+        map.set(key, new Set([id]));
+    }
+}
+function removeFrom(map, key, id) {
+    const set = map.get(key);
+    if ((set === null || set === void 0 ? void 0 : set.delete(id)) && set.size === 0) {
+        map.delete(key);
+    }
+}
+export class OverlayIndexes {
+    constructor(schema, overlay) {
+        this.types = new Map();
+        this.globalIds = new Map();
+        this.users = new Map();
+        this.rooted = new Map();
+        this.schema = schema;
+        overlay.forEach((entity) => {
+            if (entity) {
+                this.add(entity);
+            }
+        });
+    }
+    globalIdOf(entity) {
+        let isRoot = this.rooted.get(entity.type);
+        if (isRoot === undefined) {
+            isRoot = this.schema.isSubtypeOf(entity.type, ROOT_ENTITY);
+            this.rooted.set(entity.type, isRoot);
+        }
+        const globalId = entity.args[0];
+        return isRoot && typeof globalId === "string" ? globalId : undefined;
+    }
+    add(entity) {
+        addTo(this.types, entity.type, entity.id);
+        const globalId = this.globalIdOf(entity);
+        if (globalId !== undefined) {
+            addTo(this.globalIds, globalId, entity.id);
+        }
+        for (const target of new Set(entity.args.flatMap((arg) => referencesIn(arg)))) {
+            addTo(this.users, target, entity.id);
+        }
+    }
+    remove(entity) {
+        removeFrom(this.types, entity.type, entity.id);
+        const globalId = this.globalIdOf(entity);
+        if (globalId !== undefined) {
+            removeFrom(this.globalIds, globalId, entity.id);
+        }
+        for (const target of new Set(entity.args.flatMap((arg) => referencesIn(arg)))) {
+            removeFrom(this.users, target, entity.id);
+        }
+    }
+    idsOfType(type) {
+        return this.types.get(type);
+    }
+    ownersOfGlobalId(globalId) {
+        return this.globalIds.get(globalId);
+    }
+    usersOf(id) {
+        return this.users.get(id);
+    }
+}

package/lib/model/references.d.ts

@@ -0,0 +1,2 @@
+import type { ModelSnapshot } from "./snapshot";
+export declare function checkReferences(model: ModelSnapshot, changed: readonly number[], deleted: readonly number[]): void;

package/lib/model/references.js

@@ -0,0 +1,51 @@
+import { isList, isReference, isTyped } from "../step/values";
+function checkReference(model, spec, id, path) {
+    var _a, _b;
+    const target = model.typeOf(id);
+    if (target === undefined) {
+        const what = model.has(id) ? `a ${(_b = (_a = model.source) === null || _a === void 0 ? void 0 : _a.rawTypeOf(id)) !== null && _b !== void 0 ? _b : "type"}, which ${model.schema.name} does not define` : "which the model does not hold";
+        throw new Error(`${path} refers to #${id}, ${what}`);
+    }
+    const accepted = model.schema.hasEntity(spec) ? [spec] : model.schema.selectContents(spec).entities;
+    if (!accepted.some((name) => model.schema.isSubtypeOf(target, name))) {
+        throw new Error(`${path} refers to #${id}, an ${target}, where ${spec} is expected`);
+    }
+}
+function checkValue(model, spec, value, path) {
+    if (typeof spec !== "string") {
+        if (isList(value)) {
+            value.forEach((item, index) => checkValue(model, spec[3], item, `${path}[${index}]`));
+        }
+        return;
+    }
+    if (isReference(value)) {
+        checkReference(model, spec, value.ref, path);
+        return;
+    }
+    const type = model.schema.type(spec);
+    if (!type) {
+        return;
+    }
+    if ("t" in type) {
+        checkValue(model, type.t, value, path);
+    }
+    else if ("s" in type && isTyped(value)) {
+        checkValue(model, value.type, value.value, path);
+    }
+}
+export function checkReferences(model, changed, deleted) {
+    for (const id of changed) {
+        const entity = model.entity(id);
+        const info = model.schema.entity(entity.type);
+        info.attributes.forEach((attribute, index) => {
+            var _a;
+            checkValue(model, attribute.type, (_a = entity.args[index]) !== null && _a !== void 0 ? _a : null, `#${id} ${info.name}.${attribute.name}`);
+        });
+    }
+    for (const id of deleted) {
+        const users = model.referencesTo(id);
+        if (users.length) {
+            throw new Error(`#${id} cannot be deleted while ${users.map((user) => `#${user}`).join(", ")} still refer to it`);
+        }
+    }
+}

package/lib/model/rows-by-id.d.ts

@@ -0,0 +1,8 @@
+import type { StepIndex } from "../step/step-types";
+export declare class RowsById {
+    readonly maxId: number;
+    private readonly dense;
+    private readonly sparse;
+    constructor(index: StepIndex);
+    rowOf(id: number): number;
+}

package/lib/model/rows-by-id.js

@@ -0,0 +1,39 @@
+import { StepSyntaxError } from "../step/errors";
+const ABSENT = -1;
+const DENSE_IDS_PER_ROW = 4;
+const DENSE_SLACK = 1024;
+export class RowsById {
+    constructor(index) {
+        let maxId = 0;
+        for (let row = 0; row < index.count; row++) {
+            maxId = Math.max(maxId, index.ids[row]);
+        }
+        this.maxId = maxId;
+        if (maxId <= DENSE_IDS_PER_ROW * index.count + DENSE_SLACK) {
+            const dense = new Int32Array(maxId + 1).fill(ABSENT);
+            for (let row = 0; row < index.count; row++) {
+                const id = index.ids[row];
+                if (dense[id] !== ABSENT) {
+                    throw new StepSyntaxError(`The file holds entity #${id} twice`, index.rowStart[row]);
+                }
+                dense[id] = row;
+            }
+            this.dense = dense;
+        }
+        else {
+            const sparse = new Map();
+            for (let row = 0; row < index.count; row++) {
+                const id = index.ids[row];
+                if (sparse.has(id)) {
+                    throw new StepSyntaxError(`The file holds entity #${id} twice`, index.rowStart[row]);
+                }
+                sparse.set(id, row);
+            }
+            this.sparse = sparse;
+        }
+    }
+    rowOf(id) {
+        var _a, _b;
+        return (_b = (this.dense ? this.dense[id] : (_a = this.sparse) === null || _a === void 0 ? void 0 : _a.get(id))) !== null && _b !== void 0 ? _b : ABSENT;
+    }
+}

package/lib/model/snapshot.d.ts

@@ -0,0 +1,36 @@
+import type { IfcSchema } from "../schema/schema";
+import type { IfcEntity, IfcFileHeader } from "../step/step-types";
+import { EntityLookup } from "./entity-lookup";
+import type { IfcModel, IfcOverlay, SnapshotParts } from "./model-types";
+import { OverlayIndexes } from "./overlay-indexes";
+import type { IfcSource } from "./source";
+export declare class ModelSnapshot extends EntityLookup implements IfcModel {
+    readonly schema: IfcSchema;
+    readonly header: IfcFileHeader;
+    readonly headerExtras: readonly string[];
+    readonly source: IfcSource | undefined;
+    readonly overlay: IfcOverlay;
+    readonly nextId: number;
+    readonly seededIds: boolean;
+    private indexes;
+    private projectGlobalId;
+    constructor(parts: SnapshotParts);
+    get parts(): SnapshotParts;
+    get schemaName(): string;
+    get editable(): boolean;
+    get size(): number;
+    get keySeed(): string;
+    has(id: number): boolean;
+    get(id: number): IfcEntity | undefined;
+    peek(id: number): IfcEntity;
+    referenceList(id: number): readonly number[] | undefined;
+    typeOf(id: number): string | undefined;
+    ids(): readonly number[];
+    byType(type: string, includeSubtypes?: boolean): IfcEntity[];
+    globalIdOwners(globalId: string): number[];
+    byGlobalId(globalId: string): number | undefined;
+    referencesTo(id: number): readonly number[];
+    overlayIndexes(): OverlayIndexes;
+    releaseIndexes(): OverlayIndexes | undefined;
+    adoptIndexes(indexes: OverlayIndexes): void;
+}

package/lib/model/snapshot.js

@@ -0,0 +1,144 @@
+import { isEditableSchema } from "../schema/registry";
+import { EntityLookup } from "./entity-lookup";
+import { OverlayIndexes } from "./overlay-indexes";
+const NO_IDS = [];
+const ascending = (a, b) => a - b;
+export class ModelSnapshot extends EntityLookup {
+    constructor(parts) {
+        super();
+        this.schema = parts.schema;
+        this.header = parts.header;
+        this.headerExtras = parts.headerExtras;
+        this.source = parts.source;
+        this.overlay = parts.overlay;
+        this.nextId = parts.nextId;
+        this.seededIds = parts.seededIds;
+    }
+    get parts() {
+        return { schema: this.schema, header: this.header, headerExtras: this.headerExtras, source: this.source, overlay: this.overlay, nextId: this.nextId, seededIds: this.seededIds };
+    }
+    get schemaName() {
+        var _a;
+        return ((_a = this.header.schemaIdentifiers[0]) === null || _a === void 0 ? void 0 : _a.trim().toUpperCase()) || this.schema.name;
+    }
+    get editable() {
+        return this.schemaName === this.schema.name && isEditableSchema(this.schema.name);
+    }
+    get size() {
+        return this.ids().length;
+    }
+    get keySeed() {
+        var _a;
+        if (this.projectGlobalId === undefined) {
+            const globalId = (_a = this.byType("IfcProject")[0]) === null || _a === void 0 ? void 0 : _a.args[0];
+            this.projectGlobalId = typeof globalId === "string" ? globalId : "";
+        }
+        return this.projectGlobalId;
+    }
+    has(id) {
+        var _a, _b;
+        const changed = this.overlay.get(id);
+        if (changed !== undefined) {
+            return changed !== null;
+        }
+        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.has(id)) !== null && _b !== void 0 ? _b : false;
+    }
+    get(id) {
+        var _a;
+        const changed = this.overlay.get(id);
+        if (changed !== undefined) {
+            return changed !== null && changed !== void 0 ? changed : undefined;
+        }
+        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.get(id);
+    }
+    peek(id) {
+        var _a;
+        const changed = this.overlay.get(id);
+        const entity = changed === undefined ? (_a = this.source) === null || _a === void 0 ? void 0 : _a.peek(id) : changed;
+        if (!entity) {
+            throw new Error(`The model has no entity #${id}`);
+        }
+        return entity;
+    }
+    referenceList(id) {
+        var _a;
+        return this.overlay.get(id) === undefined ? (_a = this.source) === null || _a === void 0 ? void 0 : _a.referenceList(id) : undefined;
+    }
+    typeOf(id) {
+        var _a;
+        const changed = this.overlay.get(id);
+        if (changed !== undefined) {
+            return changed === null || changed === void 0 ? void 0 : changed.type;
+        }
+        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.typeOf(id);
+    }
+    ids() {
+        const ids = [];
+        const source = this.source;
+        if (source) {
+            for (const id of source.index.ids) {
+                if (this.overlay.get(id) !== null) {
+                    ids.push(id);
+                }
+            }
+        }
+        this.overlay.forEach((entity, id) => {
+            if (entity && !(source === null || source === void 0 ? void 0 : source.has(id))) {
+                ids.push(id);
+            }
+        });
+        return ids;
+    }
+    byType(type, includeSubtypes = true) {
+        var _a, _b, _c;
+        const names = includeSubtypes ? this.schema.subtypesOf(type) : [this.schema.entityName(type)].filter((name) => name !== undefined);
+        const indexes = this.overlayIndexes();
+        const ids = [];
+        for (const name of names) {
+            for (const id of (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.idsOfType(name)) !== null && _b !== void 0 ? _b : NO_IDS) {
+                if (!this.overlay.has(id)) {
+                    ids.push(id);
+                }
+            }
+            (_c = indexes.idsOfType(name)) === null || _c === void 0 ? void 0 : _c.forEach((id) => ids.push(id));
+        }
+        return ids.sort(ascending).map((id) => this.entity(id));
+    }
+    globalIdOwners(globalId) {
+        var _a, _b, _c;
+        const owners = [...((_a = this.overlayIndexes().ownersOfGlobalId(globalId)) !== null && _a !== void 0 ? _a : NO_IDS)];
+        for (const id of (_c = (_b = this.source) === null || _b === void 0 ? void 0 : _b.ownersOfGlobalId(globalId)) !== null && _c !== void 0 ? _c : NO_IDS) {
+            if (!this.overlay.has(id)) {
+                owners.push(id);
+            }
+        }
+        return owners.sort(ascending);
+    }
+    byGlobalId(globalId) {
+        return this.globalIdOwners(globalId)[0];
+    }
+    referencesTo(id) {
+        var _a, _b, _c;
+        const users = [...((_a = this.overlayIndexes().usersOf(id)) !== null && _a !== void 0 ? _a : NO_IDS)];
+        for (const user of (_c = (_b = this.source) === null || _b === void 0 ? void 0 : _b.usersOf(id)) !== null && _c !== void 0 ? _c : NO_IDS) {
+            if (!this.overlay.has(user)) {
+                users.push(user);
+            }
+        }
+        return users.sort(ascending);
+    }
+    overlayIndexes() {
+        if (!this.indexes) {
+            this.indexes = new OverlayIndexes(this.schema, this.overlay);
+        }
+        return this.indexes;
+    }
+    releaseIndexes() {
+        const indexes = this.indexes;
+        this.indexes = undefined;
+        return indexes;
+    }
+    adoptIndexes(indexes) {
+        this.indexes = indexes;
+    }
+}

package/lib/model/source.d.ts

@@ -0,0 +1,29 @@
+import type { IfcSchema } from "../schema/schema";
+import type { IfcEntity, IfcValue, StepIndex } from "../step/step-types";
+export declare class IfcSource {
+    readonly index: StepIndex;
+    readonly schema: IfcSchema;
+    readonly maxId: number;
+    private readonly rows;
+    private readonly decoded;
+    private readonly typeOfCode;
+    private readonly spell;
+    private typeIds;
+    private globalIdOwners;
+    private users;
+    constructor(index: StepIndex, schema: IfcSchema);
+    has(id: number): boolean;
+    typeOf(id: number): string | undefined;
+    rawTypeOf(id: number): string | undefined;
+    get(id: number): IfcEntity | undefined;
+    peek(id: number): IfcEntity | undefined;
+    referenceList(id: number): number[] | undefined;
+    rawArguments(id: number): IfcValue[] | undefined;
+    private decode;
+    idsOfType(type: string): readonly number[];
+    ownersOfGlobalId(globalId: string): readonly number[];
+    usersOf(id: number): readonly number[];
+    private indexGlobalIds;
+    private typeOfRow;
+    private indexUsers;
+}