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

package/lib/build/entity-writer.d.ts

@@ -0,0 +1,23 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { IfcAttributes } from "../model/model-types";
+import type { IfcTransaction } from "../model/transaction";
+import type { Outline2 } from "./build-types";
+import type { Frame3 } from "./build-types";
+export declare class EntityWriter {
+    readonly tx: IfcTransaction;
+    constructor(tx: IfcTransaction);
+    create(type: string, attributes?: IfcAttributes): number;
+    point(point: Base.Point2 | Base.Point3): number;
+    direction(vector: Base.Vector2 | Base.Vector3): number;
+    placement3(frame: Frame3): number;
+    placement2(origin: Base.Point2, xAxis?: Base.Vector2): number;
+    localPlacement(relativeTo: number | undefined, frame: Frame3): number;
+    polyCurve2(points: readonly Base.Point2[], closed: boolean): number;
+    profile(outline: Outline2, name?: string): number;
+    extrusion(profile: number, position: Frame3, depth: number, direction?: Base.Vector3): number;
+    shapeRepresentation(context: number, identifier: string, type: string, items: readonly number[]): number;
+    productShape(representations: readonly number[]): number;
+    halfSpace(origin: Base.Point3, normal: Base.Vector3, xHint: Base.Vector3): number;
+    clipping(first: number, second: number): number;
+}
+export declare function planeFrame(origin: Base.Point3, normal: Base.Vector3, xHint: Base.Vector3): Frame3;

package/lib/build/entity-writer.js

@@ -0,0 +1,97 @@
+import { dot3, length3, scale3, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { enumValue, ref } from "../step/values";
+import { frameFrom, normalize3 } from "./math";
+const AXIS_TOLERANCE = 1e-12;
+function isUnit(vector, axis) {
+    return vector.every((value, index) => Math.abs(value - (index === axis ? 1 : 0)) <= AXIS_TOLERANCE);
+}
+function coordinates(values) {
+    return values.map((value) => (Object.is(value, -0) ? 0 : value));
+}
+export class EntityWriter {
+    constructor(tx) {
+        this.tx = tx;
+    }
+    create(type, attributes = {}) {
+        return this.tx.create(type, attributes);
+    }
+    point(point) {
+        return this.create("IfcCartesianPoint", { Coordinates: coordinates(point) });
+    }
+    direction(vector) {
+        return this.create("IfcDirection", { DirectionRatios: coordinates(vector) });
+    }
+    placement3(frame) {
+        const standardAxes = isUnit(frame.z, 2) && isUnit(frame.x, 0);
+        return this.create("IfcAxis2Placement3D", {
+            Location: ref(this.point(frame.origin)),
+            Axis: standardAxes ? null : ref(this.direction(frame.z)),
+            RefDirection: standardAxes ? null : ref(this.direction(frame.x)),
+        });
+    }
+    placement2(origin, xAxis) {
+        return this.create("IfcAxis2Placement2D", {
+            Location: ref(this.point(origin)),
+            RefDirection: xAxis === undefined ? null : ref(this.direction(xAxis)),
+        });
+    }
+    localPlacement(relativeTo, frame) {
+        return this.create("IfcLocalPlacement", {
+            PlacementRelTo: relativeTo === undefined ? null : ref(relativeTo),
+            RelativePlacement: ref(this.placement3(frame)),
+        });
+    }
+    polyCurve2(points, closed) {
+        const list = this.create("IfcCartesianPointList2D", { CoordList: points.map((point) => coordinates(point)) });
+        const indices = points.map((_, index) => index + 1);
+        return this.create("IfcIndexedPolyCurve", {
+            Points: ref(list),
+            Segments: [{ type: "IfcLineIndex", value: closed ? [...indices, 1] : indices }],
+            SelfIntersect: false,
+        });
+    }
+    profile(outline, name) {
+        const outer = ref(this.polyCurve2(outline.outer, true));
+        if (!outline.holes.length) {
+            return this.create("IfcArbitraryClosedProfileDef", { ProfileType: enumValue("AREA"), ProfileName: name !== null && name !== void 0 ? name : null, OuterCurve: outer });
+        }
+        return this.create("IfcArbitraryProfileDefWithVoids", {
+            ProfileType: enumValue("AREA"),
+            ProfileName: name !== null && name !== void 0 ? name : null,
+            OuterCurve: outer,
+            InnerCurves: outline.holes.map((hole) => ref(this.polyCurve2(hole, true))),
+        });
+    }
+    extrusion(profile, position, depth, direction = [0, 0, 1]) {
+        return this.create("IfcExtrudedAreaSolid", {
+            SweptArea: ref(profile),
+            Position: ref(this.placement3(position)),
+            ExtrudedDirection: ref(this.direction(direction)),
+            Depth: depth,
+        });
+    }
+    shapeRepresentation(context, identifier, type, items) {
+        return this.create("IfcShapeRepresentation", {
+            ContextOfItems: ref(context),
+            RepresentationIdentifier: identifier,
+            RepresentationType: type,
+            Items: items.map(ref),
+        });
+    }
+    productShape(representations) {
+        return this.create("IfcProductDefinitionShape", { Representations: representations.map(ref) });
+    }
+    halfSpace(origin, normal, xHint) {
+        const plane = this.create("IfcPlane", { Position: ref(this.placement3(planeFrame(origin, normal, xHint))) });
+        return this.create("IfcHalfSpaceSolid", { BaseSurface: ref(plane), AgreementFlag: false });
+    }
+    clipping(first, second) {
+        return this.create("IfcBooleanClippingResult", { Operator: enumValue("DIFFERENCE"), FirstOperand: ref(first), SecondOperand: ref(second) });
+    }
+}
+export function planeFrame(origin, normal, xHint) {
+    const z = normalize3(normal);
+    const projected = subtract3(xHint, scale3(z, dot3(xHint, z)));
+    const fallback = Math.abs(z[0]) < Math.abs(z[1]) ? [1, 0, 0] : [0, 1, 0];
+    return frameFrom(origin, z, length3(projected) > AXIS_TOLERANCE ? projected : fallback);
+}

package/lib/build/fillings.d.ts

@@ -0,0 +1,7 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { DoorTypeSpec, FillingSpec, ModelReader, TypeBounds, WindowTypeSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function createDoorType(tx: IfcTransaction, writer: EntityWriter, spec: DoorTypeSpec): number;
+export declare function createWindowType(tx: IfcTransaction, writer: EntityWriter, spec: WindowTypeSpec): number;
+export declare function typeBounds(reader: ModelReader, type: number, map: number): TypeBounds;
+export declare function createFilling(tx: IfcTransaction, writer: EntityWriter, kind: "IfcDoor" | "IfcWindow", spec: FillingSpec, tolerance: number): number;

package/lib/build/fillings.js

@@ -0,0 +1,182 @@
+import { WORLD_AXES, pointToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { enumValue, isList, isReference, ref } from "../step/values";
+import { requirePositive } from "./checks";
+import { bodyContext } from "./contexts";
+import { extrusionCorners, frameOf } from "./solids";
+import { dressParts, materialsOfParts } from "./materials";
+import { createWallOpening } from "./openings";
+import { containIn, containerOf, describeObject } from "./spatial";
+import { declareInProject, defineByType } from "./type-objects";
+import * as Inputs from "../api/inputs";
+const RIGHT_HINGE = "_RIGHT";
+const PULL_BAR_SHARE_OF_HEIGHT = 0.45;
+function box(writer, min, max) {
+    const width = max[0] - min[0];
+    const depth = max[1] - min[1];
+    const profile = writer.create("IfcRectangleProfileDef", {
+        ProfileType: enumValue("AREA"),
+        Position: ref(writer.placement2([min[0] + width / 2, min[1] + depth / 2])),
+        XDim: width,
+        YDim: depth,
+    });
+    return writer.extrusion(profile, Object.assign(Object.assign({}, WORLD_AXES), { origin: [0, 0, min[2]] }), max[2] - min[2]);
+}
+function positiveSizes(sizes) {
+    Object.entries(sizes).forEach(([name, value]) => requirePositive(value, name));
+}
+function handleEdge(spec) {
+    const reach = spec.liningThickness + spec.hardware.inset;
+    return spec.operation.endsWith(RIGHT_HINGE) ? reach : spec.width - reach;
+}
+function handleItems(writer, spec, panelFront) {
+    if (spec.handle === Inputs.IFC.doorHandleEnum.none) {
+        return [];
+    }
+    const size = spec.hardware;
+    const edge = handleEdge(spec);
+    const inwards = edge < spec.width / 2 ? 1 : -1;
+    const outwardOf = (face, side, from, to) => {
+        const ends = [face + side * from, face + side * to];
+        return [Math.min(...ends), Math.max(...ends)];
+    };
+    const items = [];
+    for (const [face, side] of [[panelFront, -1], [panelFront + spec.panelThickness, 1]]) {
+        if (spec.handle === Inputs.IFC.doorHandleEnum.lever) {
+            const z = Math.min(size.leverHeight, spec.height - spec.liningThickness - size.leverSection);
+            const [neckFrom, neckTo] = outwardOf(face, side, 0, size.leverStandoff);
+            const [barFrom, barTo] = outwardOf(face, side, size.leverStandoff, size.leverStandoff + size.leverSection);
+            const [x0, x1] = [edge - inwards * size.leverSection / 2, edge + inwards * size.leverLength].sort((a, b) => a - b);
+            items.push(box(writer, [edge - size.leverSection / 2, neckFrom, z - size.leverSection / 2], [edge + size.leverSection / 2, neckTo, z + size.leverSection / 2]));
+            items.push(box(writer, [x0, barFrom, z - size.leverSection / 2], [x1, barTo, z + size.leverSection / 2]));
+        }
+        else {
+            const length = Math.min(size.pullBarLength, spec.height * PULL_BAR_SHARE_OF_HEIGHT);
+            const middle = Math.min(size.pullBarMiddle, spec.height / 2);
+            const [postFrom, postTo] = outwardOf(face, side, 0, size.pullBarStandoff);
+            const [barFrom, barTo] = outwardOf(face, side, size.pullBarStandoff, size.pullBarStandoff + size.pullBarSection);
+            for (const end of [-1, 1]) {
+                const z = middle + end * (length / 2 - size.pullBarPostInset);
+                items.push(box(writer, [edge - size.pullBarPost / 2, postFrom, z - size.pullBarPost / 2], [edge + size.pullBarPost / 2, postTo, z + size.pullBarPost / 2]));
+            }
+            items.push(box(writer, [edge - size.pullBarSection / 2, barFrom, middle - length / 2], [edge + size.pullBarSection / 2, barTo, middle + length / 2]));
+        }
+    }
+    return items;
+}
+function representationMap(writer, items) {
+    const body = writer.shapeRepresentation(bodyContext(writer.tx, writer), "Body", "SweptSolid", items);
+    return writer.create("IfcRepresentationMap", { MappingOrigin: ref(writer.placement3(WORLD_AXES)), MappedRepresentation: ref(body) });
+}
+export function createDoorType(tx, writer, spec) {
+    positiveSizes({ width: spec.width, height: spec.height, "lining thickness": spec.liningThickness, "lining depth": spec.liningDepth, "panel thickness": spec.panelThickness });
+    const lining = spec.liningThickness;
+    if (2 * lining >= spec.width || lining >= spec.height || spec.panelThickness > spec.liningDepth) {
+        throw new Error("The door's lining and panel do not fit inside its width, height and depth");
+    }
+    const panelFront = (spec.liningDepth - spec.panelThickness) / 2;
+    const linings = [
+        box(writer, [0, 0, 0], [lining, spec.liningDepth, spec.height]),
+        box(writer, [spec.width - lining, 0, 0], [spec.width, spec.liningDepth, spec.height]),
+        box(writer, [lining, 0, spec.height - lining], [spec.width - lining, spec.liningDepth, spec.height]),
+    ];
+    const panel = box(writer, [lining, panelFront, 0], [spec.width - lining, panelFront + spec.panelThickness, spec.height - lining]);
+    const handles = handleItems(writer, spec, panelFront);
+    const parts = [
+        { name: "Lining", items: linings, material: spec.liningMaterial },
+        { name: "Panel", items: [panel], material: spec.panelMaterial },
+        ...(handles.length ? [{ name: "Hardware", items: handles, material: spec.handleMaterial }] : []),
+    ];
+    const materials = materialsOfParts(tx, parts);
+    const type = writer.create("IfcDoorType", {
+        GlobalId: tx.globalId(spec.id),
+        Name: spec.name,
+        RepresentationMaps: [ref(representationMap(writer, [...linings, panel, ...handles]))],
+        PredefinedType: enumValue("DOOR"),
+        OperationType: enumValue(spec.operation),
+    });
+    dressParts(tx, writer, type, parts, materials);
+    declareInProject(tx, writer, type);
+    return type;
+}
+export function createWindowType(tx, writer, spec) {
+    positiveSizes({ width: spec.width, height: spec.height, "frame thickness": spec.frameThickness, "frame depth": spec.frameDepth, "glass thickness": spec.glassThickness });
+    const frame = spec.frameThickness;
+    if (2 * frame >= spec.width || 2 * frame >= spec.height || spec.glassThickness > spec.frameDepth) {
+        throw new Error("The window's frame and glass do not fit inside its width, height and depth");
+    }
+    const glassFront = (spec.frameDepth - spec.glassThickness) / 2;
+    const frames = [
+        box(writer, [0, 0, 0], [frame, spec.frameDepth, spec.height]),
+        box(writer, [spec.width - frame, 0, 0], [spec.width, spec.frameDepth, spec.height]),
+        box(writer, [frame, 0, 0], [spec.width - frame, spec.frameDepth, frame]),
+        box(writer, [frame, 0, spec.height - frame], [spec.width - frame, spec.frameDepth, spec.height]),
+    ];
+    const glass = box(writer, [frame, glassFront, frame], [spec.width - frame, glassFront + spec.glassThickness, spec.height - frame]);
+    const parts = [{ name: "Framing", items: frames, material: spec.frameMaterial }, { name: "Glazing", items: [glass], material: spec.glassMaterial }];
+    const materials = materialsOfParts(tx, parts);
+    const type = writer.create("IfcWindowType", {
+        GlobalId: tx.globalId(spec.id),
+        Name: spec.name,
+        RepresentationMaps: [ref(representationMap(writer, [...frames, glass]))],
+        PredefinedType: enumValue("WINDOW"),
+        PartitioningType: enumValue("SINGLE_PANEL"),
+    });
+    dressParts(tx, writer, type, parts, materials);
+    declareInProject(tx, writer, type);
+    return type;
+}
+function bodyMapOf(reader, type) {
+    var _a;
+    const maps = reader.attribute(type, "RepresentationMaps");
+    const all = (isList(maps) ? maps : []).filter(isReference).map((map) => map.ref);
+    const isBody = (map) => {
+        const representation = reader.attribute(map, "MappedRepresentation");
+        return isReference(representation) && reader.attribute(representation.ref, "RepresentationIdentifier") === "Body";
+    };
+    return (_a = all.find(isBody)) !== null && _a !== void 0 ? _a : all[0];
+}
+export function typeBounds(reader, type, map) {
+    const origin = frameOf(reader, reader.attribute(map, "MappingOrigin"));
+    const representation = reader.attribute(map, "MappedRepresentation");
+    const items = isReference(representation) ? reader.attribute(representation.ref, "Items") : null;
+    const corners = (isList(items) ? items : []).filter(isReference).flatMap((item) => extrusionCorners(reader, item.ref)).map((corner) => pointToWorld(origin, corner));
+    if (!corners.length) {
+        throw new Error(`${describeObject(reader, type)} has no geometry this library can size, so it cannot be placed in a wall`);
+    }
+    const along = (axis) => corners.map((corner) => corner[axis]);
+    return {
+        min: [Math.min(...along(0)), Math.min(...along(1)), Math.min(...along(2))],
+        max: [Math.max(...along(0)), Math.max(...along(1)), Math.max(...along(2))],
+    };
+}
+export function createFilling(tx, writer, kind, spec, tolerance) {
+    var _a;
+    const map = bodyMapOf(tx, spec.type);
+    if (map === undefined) {
+        throw new Error(`${describeObject(tx, spec.type)} has no representation map`);
+    }
+    const { min, max } = typeBounds(tx, spec.type, map);
+    const width = max[0] - min[0];
+    const height = max[2] - min[2];
+    const depth = max[1] - min[1];
+    const opening = createWallOpening(tx, writer, { wall: spec.wall, id: undefined, name: undefined, offset: spec.offset, sill: spec.sill, width, height }, tolerance);
+    const placement = writer.localPlacement(opening.placement, Object.assign(Object.assign({}, WORLD_AXES), { origin: [-min[0], opening.wallFace + (opening.thickness - depth) / 2 - min[1], -min[2]] }));
+    const operator = writer.create("IfcCartesianTransformationOperator3D", { LocalOrigin: ref(writer.point([0, 0, 0])) });
+    const mapped = writer.create("IfcMappedItem", { MappingSource: ref(map), MappingTarget: ref(operator) });
+    const body = writer.shapeRepresentation(bodyContext(tx, writer), "Body", "MappedRepresentation", [mapped]);
+    const element = writer.create(kind, {
+        GlobalId: tx.globalId(spec.id),
+        Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+        ObjectPlacement: ref(placement),
+        Representation: ref(writer.productShape([body])),
+        OverallHeight: height,
+        OverallWidth: width,
+    });
+    writer.create("IfcRelFillsElement", { GlobalId: tx.globalId(undefined), RelatingOpeningElement: ref(opening.opening), RelatedBuildingElement: ref(element) });
+    const storey = containerOf(tx, spec.wall);
+    if (storey !== undefined) {
+        containIn(tx, writer, storey, element);
+    }
+    defineByType(tx, writer, element, spec.type);
+    return element;
+}

package/lib/build/georeference.d.ts

@@ -0,0 +1,5 @@
+import type * as Inputs from "../api/inputs";
+import type { IfcValue } from "../step/step-types";
+import type { ModelReader } from "./build-types";
+export declare function decimalDegrees(value: IfcValue): number | undefined;
+export declare function georeferenceOf(model: ModelReader): Inputs.IFC.GeoreferenceDto;

package/lib/build/georeference.js

@@ -0,0 +1,44 @@
+import { isList, isReference, textValue } from "../step/values";
+import { COMPOUND_ANGLE_PARTS, MILLIONTHS_PER_SECOND, MINUTES_PER_DEGREE, SECONDS_PER_DEGREE } from "./constants";
+const MODEL_CONTEXT = "Model";
+function numberOr(value, fallback) {
+    return typeof value === "number" ? value : fallback;
+}
+export function decimalDegrees(value) {
+    if (!isList(value) || value.length < COMPOUND_ANGLE_PARTS || !value.every((part) => typeof part === "number")) {
+        return undefined;
+    }
+    const [degrees, minutes, seconds, millionths = 0] = value;
+    return degrees + minutes / MINUTES_PER_DEGREE + (seconds + millionths / MILLIONTHS_PER_SECOND) / SECONDS_PER_DEGREE;
+}
+function mapConversionOf(model) {
+    const conversions = model.byType("IfcMapConversion").map((conversion) => conversion.id);
+    const ofModel = conversions.find((conversion) => {
+        const source = model.attribute(conversion, "SourceCRS");
+        return isReference(source) && model.attribute(source.ref, "ContextType") === MODEL_CONTEXT;
+    });
+    return ofModel !== null && ofModel !== void 0 ? ofModel : conversions[0];
+}
+export function georeferenceOf(model) {
+    var _a, _b;
+    const conversion = mapConversionOf(model);
+    const target = conversion === undefined ? null : model.attribute(conversion, "TargetCRS");
+    const site = (_a = model.byType("IfcSite")[0]) === null || _a === void 0 ? void 0 : _a.id;
+    const latitude = site === undefined ? undefined : decimalDegrees(model.attribute(site, "RefLatitude"));
+    const longitude = site === undefined ? undefined : decimalDegrees(model.attribute(site, "RefLongitude"));
+    const located = latitude !== undefined && longitude !== undefined;
+    return {
+        mapped: conversion !== undefined,
+        crs: isReference(target) ? (_b = textValue(model.attribute(target.ref, "Name"))) !== null && _b !== void 0 ? _b : "" : "",
+        eastings: conversion === undefined ? 0 : numberOr(model.attribute(conversion, "Eastings"), 0),
+        northings: conversion === undefined ? 0 : numberOr(model.attribute(conversion, "Northings"), 0),
+        orthogonalHeight: conversion === undefined ? 0 : numberOr(model.attribute(conversion, "OrthogonalHeight"), 0),
+        xAxisAbscissa: conversion === undefined ? 1 : numberOr(model.attribute(conversion, "XAxisAbscissa"), 1),
+        xAxisOrdinate: conversion === undefined ? 0 : numberOr(model.attribute(conversion, "XAxisOrdinate"), 0),
+        scale: conversion === undefined ? 1 : numberOr(model.attribute(conversion, "Scale"), 1),
+        located,
+        latitude: located ? latitude : 0,
+        longitude: located ? longitude : 0,
+        elevation: site === undefined ? 0 : numberOr(model.attribute(site, "RefElevation"), 0),
+    };
+}

package/lib/build/materials.d.ts

@@ -0,0 +1,18 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { LayerSpec, MaterialPart, ModelReader, SurfaceColour } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function findMaterial(reader: ModelReader, name: string): number | undefined;
+export declare function findLayerSet(reader: ModelReader, name: string): number | undefined;
+export declare function requireMaterial(reader: ModelReader, name: string): number;
+export declare function requireLayerSet(reader: ModelReader, name: string): number;
+export declare function materialStyle(reader: ModelReader, material: number): number | undefined;
+export declare function createMaterial(tx: IfcTransaction, writer: EntityWriter, name: string, category: string | undefined, colour: SurfaceColour | undefined): number;
+export declare function createLayerSet(tx: IfcTransaction, writer: EntityWriter, name: string, layers: readonly LayerSpec[]): number;
+export declare function layerSetThickness(reader: ModelReader, layerSet: number): number;
+export declare function layerSetFor(tx: IfcTransaction, writer: EntityWriter, named: string | undefined, thickness: number, kind: string): number;
+export declare function associateMaterial(tx: IfcTransaction, writer: EntityWriter, objects: readonly number[], material: number): void;
+export declare function associateNewMaterial(tx: IfcTransaction, writer: EntityWriter, objects: readonly number[], material: number): void;
+export declare function materialOf(reader: ModelReader, object: number): number | undefined;
+export declare function layerSetUsage(writer: EntityWriter, layerSet: number, direction: "AXIS2" | "AXIS3", sense: "POSITIVE" | "NEGATIVE", offset: number): number;
+export declare function materialsOfParts(tx: IfcTransaction, parts: readonly MaterialPart[]): (number | undefined)[];
+export declare function dressParts(tx: IfcTransaction, writer: EntityWriter, type: number, parts: readonly MaterialPart[], materials: readonly (number | undefined)[]): void;

package/lib/build/materials.js

@@ -0,0 +1,166 @@
+import { enumValue, isList, isReference, ref } from "../step/values";
+import { MATERIAL_ASSOCIATION } from "./constants";
+import { bodyContext } from "./contexts";
+import { appendToRelationship, relate, relatingOf } from "./relationships";
+const MATERIAL = { type: "IfcMaterial", name: "Name", what: "material" };
+const LAYER_SET = { type: "IfcMaterialLayerSet", name: "LayerSetName", what: "layer set" };
+const MATERIAL_REPRESENTATION = "IfcMaterialDefinitionRepresentation";
+function findNamed(reader, type, nameAttribute, name) {
+    var _a;
+    return (_a = reader.byType(type).find((entity) => reader.attribute(entity.id, nameAttribute) === name)) === null || _a === void 0 ? void 0 : _a.id;
+}
+export function findMaterial(reader, name) {
+    return findNamed(reader, MATERIAL.type, MATERIAL.name, name);
+}
+export function findLayerSet(reader, name) {
+    return findNamed(reader, LAYER_SET.type, LAYER_SET.name, name);
+}
+export function requireMaterial(reader, name) {
+    const material = findMaterial(reader, name);
+    if (material === undefined) {
+        throw new Error(`The model has no ${MATERIAL.what} named '${name}'`);
+    }
+    return material;
+}
+export function requireLayerSet(reader, name) {
+    const layerSet = findLayerSet(reader, name);
+    if (layerSet === undefined) {
+        throw new Error(`The model has no ${LAYER_SET.what} named '${name}'`);
+    }
+    return layerSet;
+}
+function surfaceStyle(writer, name, colour) {
+    const rgb = writer.create("IfcColourRgb", { Red: colour.red, Green: colour.green, Blue: colour.blue });
+    const shading = writer.create("IfcSurfaceStyleShading", { SurfaceColour: ref(rgb), Transparency: colour.transparency > 0 ? colour.transparency : null });
+    return writer.create("IfcSurfaceStyle", { Name: name, Side: enumValue("BOTH"), Styles: [ref(shading)] });
+}
+export function materialStyle(reader, material) {
+    for (const user of reader.referencesTo(material)) {
+        if (reader.typeOf(user) !== MATERIAL_REPRESENTATION) {
+            continue;
+        }
+        const representations = reader.attribute(user, "Representations");
+        for (const representation of (isList(representations) ? representations : []).filter(isReference)) {
+            const items = reader.attribute(representation.ref, "Items");
+            for (const item of (isList(items) ? items : []).filter(isReference)) {
+                const styles = reader.attribute(item.ref, "Styles");
+                const style = (isList(styles) ? styles : []).find(isReference);
+                if (style) {
+                    return style.ref;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export function createMaterial(tx, writer, name, category, colour) {
+    if (findMaterial(tx, name) !== undefined) {
+        throw new Error(`The model already has a material named '${name}'`);
+    }
+    const material = writer.create("IfcMaterial", { Name: name, Category: category !== null && category !== void 0 ? category : null });
+    if (colour) {
+        const styled = writer.create("IfcStyledItem", { Styles: [ref(surfaceStyle(writer, name, colour))], Name: name });
+        const representation = writer.create("IfcStyledRepresentation", {
+            ContextOfItems: ref(bodyContext(tx, writer)),
+            RepresentationIdentifier: "Style",
+            RepresentationType: "Material",
+            Items: [ref(styled)],
+        });
+        writer.create("IfcMaterialDefinitionRepresentation", { Representations: [ref(representation)], RepresentedMaterial: ref(material) });
+    }
+    return material;
+}
+export function createLayerSet(tx, writer, name, layers) {
+    if (!layers.length) {
+        throw new Error("A layer set needs at least one layer");
+    }
+    if (findLayerSet(tx, name) !== undefined) {
+        throw new Error(`The model already has a layer set named '${name}'`);
+    }
+    const layerIds = layers.map((layer) => {
+        var _a;
+        if (!(layer.thickness >= 0) || !Number.isFinite(layer.thickness)) {
+            throw new Error(`A layer's thickness must be zero or more, got ${layer.thickness}`);
+        }
+        return writer.create("IfcMaterialLayer", {
+            Material: layer.material === undefined ? null : ref(requireMaterial(tx, layer.material)),
+            LayerThickness: layer.thickness,
+            Name: (_a = layer.name) !== null && _a !== void 0 ? _a : null,
+        });
+    });
+    return writer.create("IfcMaterialLayerSet", { MaterialLayers: layerIds.map(ref), LayerSetName: name });
+}
+export function layerSetThickness(reader, layerSet) {
+    const layers = reader.attribute(layerSet, "MaterialLayers");
+    let total = 0;
+    for (const layer of isList(layers) ? layers : []) {
+        if (isReference(layer)) {
+            const thickness = reader.attribute(layer.ref, "LayerThickness");
+            total += typeof thickness === "number" ? thickness : 0;
+        }
+    }
+    return total;
+}
+function isPlainLayerSet(reader, layerSet, thickness) {
+    const layers = reader.attribute(layerSet, "MaterialLayers");
+    const only = isList(layers) && layers.length === 1 ? layers[0] : undefined;
+    return isReference(only) && reader.attribute(only.ref, "Material") === null && layerSetThickness(reader, layerSet) === thickness;
+}
+export function layerSetFor(tx, writer, named, thickness, kind) {
+    if (named !== undefined) {
+        return requireLayerSet(tx, named);
+    }
+    if (!(thickness > 0) || !Number.isFinite(thickness)) {
+        throw new RangeError(`A ${kind.toLowerCase()}'s thickness must be more than zero, got ${thickness}`);
+    }
+    let name = `${kind} ${thickness}`;
+    for (let copy = 2;; copy++) {
+        const existing = findLayerSet(tx, name);
+        if (existing === undefined) {
+            break;
+        }
+        if (isPlainLayerSet(tx, existing, thickness)) {
+            return existing;
+        }
+        name = `${kind} ${thickness} (${copy})`;
+    }
+    const layer = writer.create("IfcMaterialLayer", { LayerThickness: thickness });
+    return writer.create("IfcMaterialLayerSet", { MaterialLayers: [ref(layer)], LayerSetName: name });
+}
+export function associateMaterial(tx, writer, objects, material) {
+    appendToRelationship(tx, writer, MATERIAL_ASSOCIATION, material, objects);
+}
+export function associateNewMaterial(tx, writer, objects, material) {
+    relate(tx, writer, MATERIAL_ASSOCIATION, material, objects);
+}
+export function materialOf(reader, object) {
+    return relatingOf(reader, MATERIAL_ASSOCIATION, object);
+}
+export function layerSetUsage(writer, layerSet, direction, sense, offset) {
+    return writer.create("IfcMaterialLayerSetUsage", {
+        ForLayerSet: ref(layerSet),
+        LayerSetDirection: enumValue(direction),
+        DirectionSense: enumValue(sense),
+        OffsetFromReferenceLine: offset,
+    });
+}
+export function materialsOfParts(tx, parts) {
+    return parts.map((part) => (part.material === undefined ? undefined : requireMaterial(tx, part.material)));
+}
+export function dressParts(tx, writer, type, parts, materials) {
+    const constituents = [];
+    parts.forEach((part, index) => {
+        const material = materials[index];
+        if (material === undefined) {
+            return;
+        }
+        const style = materialStyle(tx, material);
+        if (style !== undefined) {
+            part.items.forEach((item) => writer.create("IfcStyledItem", { Item: ref(item), Styles: [ref(style)], Name: null }));
+        }
+        constituents.push(writer.create("IfcMaterialConstituent", { Name: part.name, Material: ref(material), Category: part.name }));
+    });
+    if (constituents.length) {
+        associateNewMaterial(tx, writer, [type], writer.create("IfcMaterialConstituentSet", { MaterialConstituents: constituents.map(ref) }));
+    }
+}

package/lib/build/math.d.ts

@@ -0,0 +1,10 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { Frame3, Line2 } from "./build-types";
+export declare function normalize2(a: Base.Vector2): Base.Vector2;
+export declare function normalize3(a: Base.Vector3): Base.Vector3;
+export declare function frameFrom(origin: Base.Point3, zAxis: Base.Vector3, xHint: Base.Vector3): Frame3;
+export declare function intersectLines(first: Line2, second: Line2, parallelTolerance: number): Base.Point2 | undefined;
+export declare function distanceToLine(point: Base.Point2, line: Line2): number;
+export declare function distanceToSegment(point: Base.Point2, start: Base.Point2, end: Base.Point2): number;
+export declare function parameterOnLine(point: Base.Point2, line: Line2): number;
+export declare function placedOnPlan(frame: Frame3, point: Base.Point2): Base.Point2;

package/lib/build/math.js

@@ -0,0 +1,47 @@
+import { pointToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { add2, cross2, cross3, dot2, dot3, length2, length3, scale2, scale3, subtract2, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+const ZERO_LENGTH = "A direction of zero length has no direction";
+export function normalize2(a) {
+    const length = length2(a);
+    if (!(length > 0)) {
+        throw new RangeError(ZERO_LENGTH);
+    }
+    return [a[0] / length, a[1] / length];
+}
+export function normalize3(a) {
+    const length = length3(a);
+    if (!(length > 0)) {
+        throw new RangeError(ZERO_LENGTH);
+    }
+    return [a[0] / length, a[1] / length, a[2] / length];
+}
+export function frameFrom(origin, zAxis, xHint) {
+    const z = normalize3(zAxis);
+    const x = normalize3(subtract3(xHint, scale3(z, dot3(xHint, z))));
+    return { origin, x, y: cross3(z, x), z };
+}
+export function intersectLines(first, second, parallelTolerance) {
+    const denominator = cross2(first.direction, second.direction);
+    if (Math.abs(denominator) <= parallelTolerance) {
+        return undefined;
+    }
+    const along = cross2(subtract2(second.point, first.point), second.direction) / denominator;
+    return add2(first.point, scale2(first.direction, along));
+}
+export function distanceToLine(point, line) {
+    return cross2(line.direction, subtract2(point, line.point));
+}
+export function distanceToSegment(point, start, end) {
+    const along = subtract2(end, start);
+    const squared = dot2(along, along);
+    const offset = subtract2(point, start);
+    const fraction = squared > 0 ? Math.min(1, Math.max(0, dot2(offset, along) / squared)) : 0;
+    return length2(subtract2(point, add2(start, scale2(along, fraction))));
+}
+export function parameterOnLine(point, line) {
+    return dot2(subtract2(point, line.point), line.direction);
+}
+export function placedOnPlan(frame, point) {
+    const [x, y] = pointToWorld(frame, [point[0], point[1], 0]);
+    return [x, y];
+}

package/lib/build/measure.d.ts

@@ -0,0 +1,9 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { Bounds, ExtrudedBody, Linear2, ModelReader, Plane3, ProfileShape } from "./build-types";
+export declare function profileShape(reader: ModelReader, profile: number): ProfileShape | undefined;
+export declare function volumeBetween(footprint: readonly Base.Point2[], bounds: Bounds): number;
+export declare function areaWithin(footprint: readonly Base.Point2[], sides: readonly Linear2[]): number;
+export declare function areaBetween(start: Base.Point2, end: Base.Point2, bounds: Bounds): number;
+export declare function withLevels(bounds: Bounds, bottom: number, top: number): Bounds;
+export declare function boundsOf(base: number, top: number, planes: readonly Plane3[]): Bounds;
+export declare function extrudedBodyOf(reader: ModelReader, product: number): ExtrudedBody | undefined;