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

package/lib/geometry/elements.js

@@ -0,0 +1,152 @@
+import { axesToMatrix, relativeAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { absoluteFrame, objectPlacementOf } from "../build/placement";
+import { isList, isReference } from "../step/values";
+import { colourOf } from "./colours";
+import { ItemConverter } from "./items";
+import { RecipeGroups } from "./groups";
+import { RecipeBuilder } from "./recipe-builder";
+const BODY = "Body";
+const PRODUCT = "IfcProduct";
+const VOIDS = "IfcRelVoidsElement";
+const MODEL_CONTEXT = "Model";
+const SUB_CONTEXT = "IfcGeometricRepresentationSubContext";
+const REACH_MILLIMETRES = 1e6;
+const NO_BODY = `The element has no '${BODY}' representation in a '${MODEL_CONTEXT}' context`;
+const SKIPPED = {
+    IfcOpeningElement: "is cut from the element it voids, not described on its own",
+    IfcSpatialElement: "is a spatial element, which a recipe does not describe",
+    IfcAnnotation: "is an annotation, which a recipe does not describe",
+};
+function skipReason(model, type) {
+    for (const [skipped, reason] of Object.entries(SKIPPED)) {
+        if (model.schema.isSubtypeOf(type, skipped)) {
+            return `An ${type} ${reason}`;
+        }
+    }
+    return undefined;
+}
+function isModelContext(model, context) {
+    const own = model.attribute(context, "ContextType");
+    if (typeof own === "string" || !model.schema.isSubtypeOf(model.entity(context).type, SUB_CONTEXT)) {
+        return own === MODEL_CONTEXT;
+    }
+    const parent = model.attribute(context, "ParentContext");
+    return isReference(parent) && model.attribute(parent.ref, "ContextType") === MODEL_CONTEXT;
+}
+function bodyOf(model, product) {
+    const shape = model.attribute(product, "Representation");
+    if (!isReference(shape)) {
+        return undefined;
+    }
+    const representations = model.attribute(shape.ref, "Representations");
+    for (const representation of isList(representations) ? representations : []) {
+        if (!isReference(representation) || model.attribute(representation.ref, "RepresentationIdentifier") !== BODY) {
+            continue;
+        }
+        const context = model.attribute(representation.ref, "ContextOfItems");
+        if (isReference(context) && isModelContext(model, context.ref)) {
+            return representation.ref;
+        }
+    }
+    return undefined;
+}
+function addOpening(openings, model, rel) {
+    const host = model.attribute(rel, "RelatingBuildingElement");
+    const opening = model.attribute(rel, "RelatedOpeningElement");
+    if (!isReference(host) || !isReference(opening)) {
+        return;
+    }
+    const known = openings.get(host.ref);
+    if (known) {
+        known.push(opening.ref);
+    }
+    else {
+        openings.set(host.ref, [opening.ref]);
+    }
+}
+function openingsOf(model, products) {
+    const openings = new Map();
+    if (products === undefined) {
+        model.byType(VOIDS).forEach((rel) => addOpening(openings, model, rel.id));
+        return openings;
+    }
+    for (const product of products) {
+        const voids = model.referencesTo(product.id).filter((user) => { var _a; return model.schema.isSubtypeOf((_a = model.typeOf(user)) !== null && _a !== void 0 ? _a : "", VOIDS); });
+        voids.forEach((rel) => addOpening(openings, model, rel));
+    }
+    return openings;
+}
+function productsOf(model, wanted) {
+    if (wanted === undefined) {
+        return model.byType(PRODUCT);
+    }
+    const ids = new Set([...wanted].flatMap((globalId) => model.globalIdOwners(globalId)));
+    return [...ids].filter((id) => { var _a; return model.schema.isSubtypeOf((_a = model.typeOf(id)) !== null && _a !== void 0 ? _a : "", PRODUCT); }).sort((a, b) => a - b).map((id) => model.entity(id));
+}
+function frameOf(model, product, known) {
+    return absoluteFrame(model, objectPlacementOf(model, product), known);
+}
+function precisionOf(model, fallback) {
+    for (const context of model.byType("IfcGeometricRepresentationContext", false)) {
+        const precision = model.attribute(context.id, "Precision");
+        if (model.attribute(context.id, "ContextType") === MODEL_CONTEXT && typeof precision === "number" && precision > 0) {
+            return precision;
+        }
+    }
+    return fallback;
+}
+export function modelRecipe(model, globalIds, millimetresPerUnit, fallbackTolerance, isGroupedByClass = true) {
+    var _a, _b;
+    const builder = new RecipeBuilder();
+    const groups = new RecipeGroups(model, isGroupedByClass);
+    const converter = new ItemConverter(model, builder, REACH_MILLIMETRES / millimetresPerUnit);
+    const colours = new Map();
+    const frames = new Map();
+    const problems = [];
+    const wanted = globalIds === undefined ? undefined : new Set(globalIds);
+    const products = productsOf(model, wanted);
+    const openings = openingsOf(model, wanted === undefined ? undefined : products);
+    for (const product of products) {
+        const globalId = model.attribute(product.id, "GlobalId");
+        if (typeof globalId !== "string" || (wanted && !wanted.has(globalId))) {
+            continue;
+        }
+        const skipped = skipReason(model, product.type);
+        if (skipped !== undefined) {
+            if (wanted) {
+                problems.push({ globalId, type: product.type, message: skipped });
+            }
+            continue;
+        }
+        try {
+            const body = bodyOf(model, product.id);
+            if (body === undefined) {
+                if (wanted) {
+                    problems.push({ globalId, type: product.type, message: NO_BODY });
+                }
+                continue;
+            }
+            const frame = frameOf(model, product.id, frames);
+            const parts = converter.parts(body);
+            const cuts = ((_a = openings.get(product.id)) !== null && _a !== void 0 ? _a : []).flatMap((opening) => {
+                const openingBody = bodyOf(model, opening);
+                if (openingBody === undefined) {
+                    return [];
+                }
+                const matrix = axesToMatrix(relativeAxes(frame, frameOf(model, opening, frames)));
+                return [builder.node({ op: "transform", of: converter.representation(openingBody), matrix })];
+            });
+            const name = model.attribute(product.id, "Name");
+            const material = parts.some((part) => !part.rgba) ? colourOf(model, colours, product.id) : undefined;
+            const group = groups.groupOf(product.id);
+            for (const part of parts) {
+                const rgba = (_b = part.rgba) !== null && _b !== void 0 ? _b : material;
+                builder.root(Object.assign({ node: cuts.length ? builder.node({ op: "voids", host: part.node, openings: cuts }) : part.node, matrix: axesToMatrix(frame), tag: Object.assign({ globalId, type: product.type, name: typeof name === "string" ? name : "" }, (rgba ? { rgba: [...rgba] } : {})) }, (group === undefined ? {} : { group })));
+            }
+        }
+        catch (error) {
+            problems.push({ globalId, type: product.type, message: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return { recipe: builder.build(millimetresPerUnit, precisionOf(model, fallbackTolerance), groups.list()), problems };
+}

package/lib/geometry/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class UnsupportedGeometryError extends Error {
+    constructor(message: string);
+}

package/lib/geometry/errors.js

@@ -0,0 +1,6 @@
+export class UnsupportedGeometryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UnsupportedGeometryError";
+    }
+}

package/lib/geometry/faceted.d.ts

@@ -0,0 +1,31 @@
+import type { ModelSnapshot } from "../model/snapshot";
+import type { IfcValue } from "../step/step-types";
+import type { TriangleMesh } from "./geometry-types";
+export declare const OUTWARD = 1;
+export declare const INWARD = -1;
+export declare const UNORIENTED = 0;
+export declare function zeroBased(value: IfcValue, count: number, what: string, of: string): number[];
+export declare function concatenated(meshes: readonly TriangleMesh[]): TriangleMesh;
+export declare class MeshCollector {
+    private readonly model;
+    private readonly positions;
+    private readonly indices;
+    private readonly vertexOfPoint;
+    private readonly vertexAt;
+    private advanced;
+    constructor(model: ModelSnapshot);
+    get mesh(): TriangleMesh;
+    shell(shell: number, sense: number): void;
+    triangulatedFaces(item: number): void;
+    polygonalFaces(item: number): void;
+    private indexedPoints;
+    private references;
+    private face;
+    private loopTypeOf;
+    private surfaceMesh;
+    private loop;
+    private vertex;
+    private welded;
+    private add;
+    private orient;
+}

package/lib/geometry/faceted.js

@@ -0,0 +1,214 @@
+import { signedVolumeOf } from "@bitbybit-dev/base/lib/api/services/helpers/mesh-measures";
+import { newellNormal, triangulateFace } from "@bitbybit-dev/base/lib/api/services/helpers/triangulation";
+import { POINT3_SIZE } from "../build/constants";
+import { numbersOf } from "../build/placement";
+import { isList, isReference } from "../step/values";
+import { AdvancedFaces, faceBounds } from "./advanced";
+import { CurveSampler } from "./curves";
+import { EdgeSampler } from "./edges";
+import { referencesIn, referencesOf } from "./references";
+import { UnsupportedGeometryError } from "./errors";
+export const OUTWARD = 1;
+export const INWARD = -1;
+export const UNORIENTED = 0;
+const TRIANGLE_CORNERS = 3;
+const OUTER_BOUND = "IfcFaceOuterBound";
+const POLY_LOOP = "IfcPolyLoop";
+const FACE_WITH_VOIDS = "IfcIndexedPolygonalFaceWithVoids";
+const SURFACE_FACES = new Set(["IfcAdvancedFace", "IfcFaceSurface"]);
+export function zeroBased(value, count, what, of) {
+    if (!isList(value) || !value.every((index) => typeof index === "number" && Number.isSafeInteger(index))) {
+        throw new UnsupportedGeometryError(`${what} is not a list of indices`);
+    }
+    return value.map((index) => {
+        if (index < 1 || index > count) {
+            throw new UnsupportedGeometryError(`${what} names ${index}, outside the ${count} ${of}`);
+        }
+        return index - 1;
+    });
+}
+export function concatenated(meshes) {
+    const positions = [];
+    const indices = [];
+    for (const mesh of meshes) {
+        const offset = positions.length / POINT3_SIZE;
+        for (const value of mesh.positions) {
+            positions.push(value);
+        }
+        for (const vertex of mesh.indices) {
+            indices.push(vertex + offset);
+        }
+    }
+    return { positions, indices };
+}
+function isPointIndex(value) {
+    return isList(value) && value.length > 0 && !value.some(isList);
+}
+export class MeshCollector {
+    constructor(model) {
+        this.positions = [];
+        this.indices = [];
+        this.vertexOfPoint = new Map();
+        this.vertexAt = new Map();
+        this.model = model;
+    }
+    get mesh() {
+        return { positions: this.positions, indices: this.indices };
+    }
+    shell(shell, sense) {
+        const first = this.indices.length;
+        for (const face of this.references(shell, "CfsFaces")) {
+            this.face(face);
+        }
+        this.orient(first, sense);
+    }
+    triangulatedFaces(item) {
+        const entity = this.model.peek(item);
+        const vertices = this.indexedPoints(item, entity);
+        const first = this.indices.length;
+        const triangles = this.model.valueOf(entity, "CoordIndex");
+        (isList(triangles) ? triangles : []).forEach((triangle, at) => {
+            const what = `#${item} triangle ${at}`;
+            const corners = vertices(triangle, what);
+            if (corners.length !== TRIANGLE_CORNERS) {
+                throw new UnsupportedGeometryError(`${what} has ${corners.length} corners, not ${TRIANGLE_CORNERS}`);
+            }
+            this.add(corners);
+        });
+        this.orient(first, this.model.valueOf(entity, "Closed") === true ? OUTWARD : UNORIENTED);
+    }
+    polygonalFaces(item) {
+        const entity = this.model.peek(item);
+        const vertices = this.indexedPoints(item, entity);
+        const first = this.indices.length;
+        for (const face of referencesOf(this.model.valueOf(entity, "Faces"), `#${item} Faces`)) {
+            const faceEntity = this.model.peek(face);
+            const outer = vertices(this.model.valueOf(faceEntity, "CoordIndex"), `#${face} CoordIndex`);
+            const inner = this.model.schema.isSubtypeOf(faceEntity.type, FACE_WITH_VOIDS) ? this.model.valueOf(faceEntity, "InnerCoordIndices") : null;
+            const holes = (isList(inner) ? inner : []).map((hole, at) => vertices(hole, `#${face} inner loop ${at}`));
+            this.add(triangulateFace(this.positions, [outer, ...holes]));
+        }
+        this.orient(first, this.model.valueOf(entity, "Closed") === true ? OUTWARD : UNORIENTED);
+    }
+    indexedPoints(item, entity) {
+        const coordinates = this.model.valueOf(entity, "Coordinates");
+        if (!isReference(coordinates)) {
+            throw new UnsupportedGeometryError(`#${item} has no coordinates`);
+        }
+        const list = this.model.valueOf(this.model.peek(coordinates.ref), "CoordList");
+        const points = isList(list) ? list : [];
+        const offset = this.positions.length / POINT3_SIZE;
+        points.forEach((point, index) => {
+            var _a, _b, _c;
+            const numbers = numbersOf(point, `#${coordinates.ref} point ${index}`);
+            this.positions.push((_a = numbers[0]) !== null && _a !== void 0 ? _a : 0, (_b = numbers[1]) !== null && _b !== void 0 ? _b : 0, (_c = numbers[2]) !== null && _c !== void 0 ? _c : 0);
+        });
+        const pointIndex = this.model.valueOf(entity, "PnIndex");
+        const lookup = isPointIndex(pointIndex) ? zeroBased(pointIndex, points.length, `#${item} PnIndex`, "points") : undefined;
+        return (value, what) => (lookup
+            ? zeroBased(value, lookup.length, what, "entries of PnIndex").map((entry) => lookup[entry] + offset)
+            : zeroBased(value, points.length, what, "points").map((index) => index + offset));
+    }
+    references(id, attribute) {
+        return referencesIn(this.model, id, attribute);
+    }
+    face(face) {
+        var _a, _b;
+        const bounds = faceBounds(this.model, face);
+        if (SURFACE_FACES.has((_a = this.model.typeOf(face)) !== null && _a !== void 0 ? _a : "") || bounds.some((bound) => this.loopTypeOf(bound) !== POLY_LOOP)) {
+            if (!this.advanced) {
+                const curves = new CurveSampler(this.model);
+                this.advanced = new AdvancedFaces(this.model, curves, new EdgeSampler(this.model, curves));
+            }
+            this.surfaceMesh(this.advanced.face(face, bounds));
+            return;
+        }
+        const loops = [];
+        let outer = -1;
+        for (const bound of bounds) {
+            const boundEntity = this.model.peek(bound);
+            const loop = this.model.valueOf(boundEntity, "Bound");
+            if (!isReference(loop)) {
+                throw new UnsupportedGeometryError(`#${bound} has no loop`);
+            }
+            const vertices = this.loop(loop.ref);
+            if (this.model.valueOf(boundEntity, "Orientation") === false) {
+                vertices.reverse();
+            }
+            if (outer < 0 && this.model.schema.isSubtypeOf(boundEntity.type, OUTER_BOUND)) {
+                outer = loops.length;
+            }
+            loops.push(vertices);
+        }
+        if (outer < 0) {
+            const spans = loops.map((loop) => Math.hypot(...newellNormal(this.positions, loop)));
+            outer = spans.indexOf(Math.max(...spans));
+        }
+        this.add(triangulateFace(this.positions, [(_b = loops[outer]) !== null && _b !== void 0 ? _b : [], ...loops.filter((_, at) => at !== outer)]));
+    }
+    loopTypeOf(bound) {
+        const loop = this.model.valueOf(this.model.peek(bound), "Bound");
+        return isReference(loop) ? this.model.typeOf(loop.ref) : undefined;
+    }
+    surfaceMesh(mesh) {
+        const vertices = mesh.positions.map(([x, y, z]) => this.welded(x, y, z));
+        for (let at = 0; at + 2 < mesh.triangles.length; at += TRIANGLE_CORNERS) {
+            const [a, b, c] = [vertices[mesh.triangles[at]], vertices[mesh.triangles[at + 1]], vertices[mesh.triangles[at + 2]]];
+            if (a !== b && b !== c && c !== a) {
+                this.indices.push(a, b, c);
+            }
+        }
+    }
+    loop(loop) {
+        const type = this.model.typeOf(loop);
+        if (type !== POLY_LOOP) {
+            throw new UnsupportedGeometryError(`A face bounded by an ${type !== null && type !== void 0 ? type : `unknown #${loop}`} is not supported yet`);
+        }
+        return this.references(loop, "Polygon").map((point) => this.vertex(point));
+    }
+    vertex(point) {
+        var _a, _b, _c;
+        const known = this.vertexOfPoint.get(point);
+        if (known !== undefined) {
+            return known;
+        }
+        const coordinates = numbersOf(this.model.valueOf(this.model.peek(point), "Coordinates"), `#${point} Coordinates`);
+        const vertex = this.welded((_a = coordinates[0]) !== null && _a !== void 0 ? _a : 0, (_b = coordinates[1]) !== null && _b !== void 0 ? _b : 0, (_c = coordinates[2]) !== null && _c !== void 0 ? _c : 0);
+        this.vertexOfPoint.set(point, vertex);
+        return vertex;
+    }
+    welded(x, y, z) {
+        let byY = this.vertexAt.get(x);
+        if (!byY) {
+            byY = new Map();
+            this.vertexAt.set(x, byY);
+        }
+        let byZ = byY.get(y);
+        if (!byZ) {
+            byZ = new Map();
+            byY.set(y, byZ);
+        }
+        let vertex = byZ.get(z);
+        if (vertex === undefined) {
+            vertex = this.positions.length / POINT3_SIZE;
+            this.positions.push(x, y, z);
+            byZ.set(z, vertex);
+        }
+        return vertex;
+    }
+    add(triangles) {
+        for (const vertex of triangles) {
+            this.indices.push(vertex);
+        }
+    }
+    orient(first, sense) {
+        if (sense === UNORIENTED || signedVolumeOf(this.positions, this.indices, first) * sense >= 0) {
+            return;
+        }
+        for (let at = first; at < this.indices.length; at += POINT3_SIZE) {
+            const second = this.indices[at + 1];
+            this.indices[at + 1] = this.indices[at + 2];
+            this.indices[at + 2] = second;
+        }
+    }
+}

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

@@ -0,0 +1,103 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { FrameAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import type * as Inputs from "../api/inputs";
+export type ProfileRegion = PolygonRegion | CircleRegion | CompositeRegion;
+export interface PolygonRegion {
+    readonly kind: "polygon";
+    readonly outer: Base.Point2[];
+    readonly holes: Base.Point2[][];
+    readonly plane?: FrameAxes;
+}
+export interface CircleRegion {
+    readonly kind: "circle";
+    readonly center: Base.Point2;
+    readonly radius: number;
+    readonly innerRadius: number;
+}
+export interface CompositeRegion {
+    readonly kind: "composite";
+    readonly parts: readonly ProfileRegion[];
+}
+export interface ProfileCorner {
+    readonly point: Base.Point2;
+    readonly radius: number;
+}
+export interface ModelRecipe {
+    readonly recipe: Base.Recipe;
+    readonly problems: Inputs.IFC.GeometryProblemDto[];
+}
+export interface DescribedModel {
+    readonly key: string;
+    readonly described: ModelRecipe;
+}
+export interface TriangleMesh {
+    readonly positions: readonly number[];
+    readonly indices: readonly number[];
+}
+export interface CurveTrim {
+    readonly point: Base.Point3 | undefined;
+    readonly parameter: number | undefined;
+}
+export interface ParametricSurface {
+    readonly periods: readonly [number | undefined, number | undefined];
+    point(u: number, v: number): Base.Point3;
+    parameters(point: Base.Point3, near: Base.Point2 | undefined): Base.Point2;
+    pole(axis: number, side: number): number | undefined;
+}
+export interface SurfaceFit {
+    readonly uv: Base.Point2;
+    readonly miss: number;
+}
+export interface PolePoint {
+    readonly axis: number;
+    readonly at: number;
+}
+export interface CutEdge {
+    readonly uv: Base.Point2[];
+    readonly points: Base.Point3[];
+}
+export interface FaceLoop {
+    readonly points: readonly Base.Point3[];
+    readonly uv: readonly Base.Point2[];
+    readonly winding: readonly [number, number];
+}
+export interface BoundLoop extends FaceLoop {
+    readonly outer: boolean;
+}
+export interface AssembledFace {
+    readonly uv: Base.Point2[];
+    readonly positions: Base.Point3[];
+    readonly indices: number[][];
+}
+export interface ProfilePolyline {
+    readonly points: readonly Base.Point3[];
+    readonly lengths: readonly number[];
+    readonly closed: boolean;
+}
+export interface BSplineCurve {
+    readonly degree: number;
+    readonly points: readonly Base.Point3[];
+    readonly weights: readonly number[] | undefined;
+    readonly knots: readonly number[];
+}
+export interface ConicFrame {
+    readonly origin: Base.Point3;
+    readonly x: Base.Vector3;
+    readonly y: Base.Vector3;
+    readonly radii: readonly [number, number];
+}
+export interface RecipePart {
+    readonly node: number;
+    readonly rgba: readonly number[] | undefined;
+}
+export interface ItemEntry {
+    readonly item: number;
+}
+export interface NodeEntry {
+    readonly node: number;
+}
+export type PartEntry = ItemEntry | NodeEntry;
+export interface PartGroup {
+    readonly rgba: readonly number[] | undefined;
+    readonly entries: PartEntry[];
+}

package/lib/geometry/geometry-types.js

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

package/lib/geometry/groups.d.ts

@@ -0,0 +1,21 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { ModelSnapshot } from "../model/snapshot";
+export declare function classLabelOf(type: string): string;
+export declare class RecipeGroups {
+    private readonly model;
+    private readonly isByClass;
+    private readonly groups;
+    private readonly ofObject;
+    private readonly ofClass;
+    constructor(model: ModelSnapshot, isByClass: boolean);
+    groupOf(element: number): number | undefined;
+    list(): Base.RecipeGroup[];
+    private groupAt;
+    private isSpatial;
+    private add;
+    private nameOf;
+    private tagOf;
+    private spatialGroup;
+    private wholeGroup;
+    private classGroup;
+}

package/lib/geometry/groups.js

@@ -0,0 +1,106 @@
+import { containerOf } from "../build/spatial";
+import { relatingOf } from "../build/relationships";
+import { AGGREGATION } from "../build/constants";
+import { textValue } from "../step/values";
+const PROJECT = "IfcProject";
+const SPATIAL_ELEMENT = "IfcSpatialElement";
+const IFC_PREFIX = "Ifc";
+const UNCOUNTED = new Set(["Furniture", "Equipment"]);
+const MAX_NESTING = 64;
+function pluralOf(words) {
+    var _a;
+    const last = (_a = words.split(" ").at(-1)) !== null && _a !== void 0 ? _a : words;
+    if (UNCOUNTED.has(last.charAt(0).toUpperCase() + last.slice(1))) {
+        return words;
+    }
+    if (/[^aeiou]y$/.test(words)) {
+        return `${words.slice(0, -1)}ies`;
+    }
+    return /(s|x|ch|sh)$/.test(words) ? `${words}es` : `${words}s`;
+}
+function wordsOf(type) {
+    const bare = type.startsWith(IFC_PREFIX) ? type.slice(IFC_PREFIX.length) : type;
+    const words = bare.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+export function classLabelOf(type) {
+    return pluralOf(wordsOf(type));
+}
+export class RecipeGroups {
+    constructor(model, isByClass) {
+        this.model = model;
+        this.isByClass = isByClass;
+        this.groups = [];
+        this.ofObject = new Map();
+        this.ofClass = new Map();
+    }
+    groupOf(element) {
+        return this.groupAt(element, 0);
+    }
+    list() {
+        return this.groups;
+    }
+    groupAt(element, depth) {
+        var _a;
+        const whole = relatingOf(this.model, AGGREGATION, element);
+        if (whole !== undefined && !this.isSpatial(whole) && depth < MAX_NESTING) {
+            return this.wholeGroup(whole, depth);
+        }
+        const container = (_a = containerOf(this.model, element)) !== null && _a !== void 0 ? _a : whole;
+        const structure = container === undefined ? undefined : this.spatialGroup(container, depth);
+        return this.isByClass ? this.classGroup(structure, this.model.entity(element).type) : structure;
+    }
+    isSpatial(object) {
+        return this.model.schema.isSubtypeOf(this.model.entity(object).type, SPATIAL_ELEMENT);
+    }
+    add(group) {
+        this.groups.push(group);
+        return this.groups.length - 1;
+    }
+    nameOf(object) {
+        var _a;
+        return ((_a = textValue(this.model.attribute(object, "Name"))) === null || _a === void 0 ? void 0 : _a.trim()) || wordsOf(this.model.entity(object).type);
+    }
+    tagOf(object) {
+        var _a, _b;
+        return {
+            globalId: (_a = textValue(this.model.attribute(object, "GlobalId"))) !== null && _a !== void 0 ? _a : "",
+            type: this.model.entity(object).type,
+            name: (_b = textValue(this.model.attribute(object, "Name"))) !== null && _b !== void 0 ? _b : "",
+        };
+    }
+    spatialGroup(structure, depth) {
+        if (this.ofObject.has(structure)) {
+            return this.ofObject.get(structure);
+        }
+        if (this.model.schema.isSubtypeOf(this.model.entity(structure).type, PROJECT) || depth >= MAX_NESTING) {
+            this.ofObject.set(structure, undefined);
+            return undefined;
+        }
+        const holder = relatingOf(this.model, AGGREGATION, structure);
+        const parent = holder === undefined ? undefined : this.spatialGroup(holder, depth + 1);
+        const group = this.add(Object.assign(Object.assign({ name: this.nameOf(structure) }, (parent === undefined ? {} : { parent })), { tag: this.tagOf(structure) }));
+        this.ofObject.set(structure, group);
+        return group;
+    }
+    wholeGroup(whole, depth) {
+        const known = this.ofObject.get(whole);
+        if (known !== undefined) {
+            return known;
+        }
+        const parent = this.groupAt(whole, depth + 1);
+        const group = this.add(Object.assign(Object.assign({ name: this.nameOf(whole) }, (parent === undefined ? {} : { parent })), { tag: this.tagOf(whole) }));
+        this.ofObject.set(whole, group);
+        return group;
+    }
+    classGroup(structure, type) {
+        const key = `${structure !== null && structure !== void 0 ? structure : "top"}:${type}`;
+        const known = this.ofClass.get(key);
+        if (known !== undefined) {
+            return known;
+        }
+        const group = this.add(Object.assign(Object.assign({ name: classLabelOf(type) }, (structure === undefined ? {} : { parent: structure })), { tag: { type } }));
+        this.ofClass.set(key, group);
+        return group;
+    }
+}

package/lib/geometry/items.d.ts

@@ -0,0 +1,34 @@
+import type { ModelSnapshot } from "../model/snapshot";
+import type { RecipePart } from "./geometry-types";
+import type { RecipeBuilder } from "./recipe-builder";
+export declare class ItemConverter {
+    private readonly model;
+    private readonly builder;
+    private readonly curves;
+    private readonly reach;
+    private readonly items;
+    private readonly maps;
+    private readonly representations;
+    private readonly itemColours;
+    private readonly solids;
+    constructor(model: ModelSnapshot, builder: RecipeBuilder, reach: number);
+    representation(representation: number): number;
+    parts(representation: number): readonly RecipePart[];
+    item(item: number): number;
+    private convert;
+    private placedBy;
+    private extrusion;
+    private extruded;
+    private boolean;
+    private tool;
+    private boundedHalfSpace;
+    private halfSpace;
+    private joined;
+    private groupNode;
+    private mapped;
+    private mappedParts;
+    private meshNode;
+    private meshOf;
+    private facetedBrep;
+    private surfaceModel;
+}