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

package/lib/build/slabs-columns-beams.d.ts

@@ -0,0 +1,8 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { IfcTransaction } from "../model/transaction";
+import type { MemberSpec, SlabSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+import type { Frame3 } from "./build-types";
+export declare function createSlab(tx: IfcTransaction, writer: EntityWriter, spec: SlabSpec, tolerance: number): number;
+export declare function memberFrame(start: Base.Point3, end: Base.Point3, rotationDegrees: number): Frame3;
+export declare function createMember(tx: IfcTransaction, writer: EntityWriter, kind: "IfcColumn" | "IfcBeam" | "IfcMember", spec: MemberSpec): number;

package/lib/build/slabs-columns-beams.js

@@ -0,0 +1,73 @@
+import { WORLD_AXES } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { cross3, length3, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { isInsidePolygon2, wound2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { enumValue, ref } from "../step/values";
+import { DEGREES_TO_RADIANS, VERTICAL_COSINE } from "./constants";
+import { bodyContext } from "./contexts";
+import { associateMaterial, associateNewMaterial, layerSetThickness, layerSetUsage } from "./materials";
+import { frameFrom, normalize3 } from "./math";
+import { objectPlacementOf } from "./placement";
+import { writeProfile } from "./profiles";
+import { containIn } from "./spatial";
+import { cleanOutline } from "./outlines";
+export function createSlab(tx, writer, spec, tolerance) {
+    var _a;
+    const thickness = layerSetThickness(tx, spec.layerSet);
+    if (!(thickness > 0)) {
+        throw new Error("A slab's layers must add up to more than zero thickness");
+    }
+    const outer = wound2(cleanOutline(spec.outline, tolerance, "outline"), true);
+    const holes = spec.holes.map((hole, index) => {
+        const cleaned = cleanOutline(hole, tolerance, `hole ${index}`);
+        if (!cleaned.every((point) => isInsidePolygon2(point, outer))) {
+            throw new Error(`Hole ${index} reaches outside the slab's outline`);
+        }
+        return wound2(cleaned, false);
+    });
+    const placement = writer.localPlacement(objectPlacementOf(tx, spec.storey), Object.assign(Object.assign({}, WORLD_AXES), { origin: [0, 0, spec.topOffset] }));
+    const solid = writer.extrusion(writer.profile({ outer, holes }), WORLD_AXES, thickness, [0, 0, -1]);
+    const body = writer.shapeRepresentation(bodyContext(tx, writer), "Body", "SweptSolid", [solid]);
+    const slab = writer.create("IfcSlab", {
+        GlobalId: tx.globalId(spec.id),
+        Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+        ObjectPlacement: ref(placement),
+        Representation: ref(writer.productShape([body])),
+        PredefinedType: enumValue(spec.predefinedType),
+    });
+    containIn(tx, writer, spec.storey, slab);
+    associateNewMaterial(tx, writer, [slab], layerSetUsage(writer, spec.layerSet, "AXIS3", "NEGATIVE", 0));
+    return slab;
+}
+export function memberFrame(start, end, rotationDegrees) {
+    const along = subtract3(end, start);
+    if (!(length3(along) > 0)) {
+        throw new Error("A member's start and end must be apart");
+    }
+    const z = normalize3(along);
+    const horizontal = Math.abs(z[2]) >= VERTICAL_COSINE ? [1, 0, 0] : normalize3(cross3([0, 0, 1], z));
+    const base = frameFrom(start, z, horizontal);
+    const angle = rotationDegrees * DEGREES_TO_RADIANS;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const x = [base.x[0] * cos + base.y[0] * sin, base.x[1] * cos + base.y[1] * sin, base.x[2] * cos + base.y[2] * sin];
+    return frameFrom(start, z, x);
+}
+export function createMember(tx, writer, kind, spec) {
+    var _a;
+    const frame = memberFrame(spec.start, spec.end, spec.rotation);
+    const placement = writer.localPlacement(objectPlacementOf(tx, spec.storey), frame);
+    const solid = writer.extrusion(writeProfile(writer, spec.profile, undefined), WORLD_AXES, length3(subtract3(spec.end, spec.start)));
+    const body = writer.shapeRepresentation(bodyContext(tx, writer), "Body", "SweptSolid", [solid]);
+    const member = 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])),
+        PredefinedType: enumValue(spec.predefinedType),
+    });
+    containIn(tx, writer, spec.storey, member);
+    if (spec.material !== undefined) {
+        associateMaterial(tx, writer, [member], spec.material);
+    }
+    return member;
+}

package/lib/build/solids.d.ts

@@ -0,0 +1,5 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { IfcValue } from "../step/step-types";
+import type { Frame3, ModelReader } from "./build-types";
+export declare function frameOf(reader: ModelReader, placement: IfcValue): Frame3;
+export declare function extrusionCorners(reader: ModelReader, item: number): Base.Point3[];

package/lib/build/solids.js

@@ -0,0 +1,33 @@
+import { WORLD_AXES, pointToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { isReference } from "../step/values";
+import { axisPlacementFrame, directionOf } from "./placement";
+export function frameOf(reader, placement) {
+    return isReference(placement) ? axisPlacementFrame(reader, placement.ref) : WORLD_AXES;
+}
+export function extrusionCorners(reader, item) {
+    if (reader.entity(item).type !== "IfcExtrudedAreaSolid") {
+        return [];
+    }
+    const profile = reader.attribute(item, "SweptArea");
+    const depth = reader.attribute(item, "Depth");
+    if (!isReference(profile) || reader.entity(profile.ref).type !== "IfcRectangleProfileDef" || typeof depth !== "number") {
+        return [];
+    }
+    const xDim = reader.attribute(profile.ref, "XDim");
+    const yDim = reader.attribute(profile.ref, "YDim");
+    if (typeof xDim !== "number" || typeof yDim !== "number") {
+        return [];
+    }
+    const profileFrame = frameOf(reader, reader.attribute(profile.ref, "Position"));
+    const solidFrame = frameOf(reader, reader.attribute(item, "Position"));
+    const direction = directionOf(reader, reader.attribute(item, "ExtrudedDirection"), [0, 0, 1]);
+    const scale = depth / Math.hypot(direction[0], direction[1], direction[2]);
+    const corners = [];
+    for (const x of [-xDim / 2, xDim / 2]) {
+        for (const y of [-yDim / 2, yDim / 2]) {
+            const base = pointToWorld(profileFrame, [x, y, 0]);
+            corners.push(pointToWorld(solidFrame, base), pointToWorld(solidFrame, [base[0] + direction[0] * scale, base[1] + direction[1] * scale, direction[2] * scale]));
+        }
+    }
+    return corners;
+}

package/lib/build/spaces.d.ts

@@ -0,0 +1,6 @@
+import type * as Inputs from "../api/inputs";
+import type { IfcTransaction } from "../model/transaction";
+import type { ModelReader, SpaceSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function createSpace(tx: IfcTransaction, writer: EntityWriter, spec: SpaceSpec, tolerance: number): number;
+export declare function spacesOf(reader: ModelReader, storey: number | undefined): Inputs.IFC.SpaceInfoDto[];

package/lib/build/spaces.js

@@ -0,0 +1,55 @@
+import { WORLD_AXES, composeAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { wound2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { enumValue, ref, textValue } from "../step/values";
+import { AGGREGATION, VERTICAL_COSINE } from "./constants";
+import { bodyContext } from "./contexts";
+import { extrudedBodyOf } from "./measure";
+import { cleanOutline } from "./outlines";
+import { absoluteFrame, directionOf, objectPlacementOf } from "./placement";
+import { appendToRelationship, relatingOf } from "./relationships";
+const SPACE = "IfcSpace";
+export function createSpace(tx, writer, spec, tolerance) {
+    var _a, _b;
+    if (!(spec.height > 0)) {
+        throw new Error(`A space's height must be more than zero, got ${spec.height}`);
+    }
+    const outline = wound2(cleanOutline(spec.outline, tolerance, "outline"), true);
+    const placement = writer.localPlacement(objectPlacementOf(tx, spec.storey), Object.assign(Object.assign({}, WORLD_AXES), { origin: [0, 0, spec.baseOffset] }));
+    const solid = writer.extrusion(writer.profile({ outer: outline, holes: [] }), WORLD_AXES, spec.height);
+    const body = writer.shapeRepresentation(bodyContext(tx, writer), "Body", "SweptSolid", [solid]);
+    const space = writer.create(SPACE, {
+        GlobalId: tx.globalId(spec.id),
+        Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+        ObjectPlacement: ref(placement),
+        Representation: ref(writer.productShape([body])),
+        LongName: (_b = spec.longName) !== null && _b !== void 0 ? _b : null,
+        CompositionType: enumValue("ELEMENT"),
+        PredefinedType: enumValue(spec.predefinedType),
+    });
+    appendToRelationship(tx, writer, AGGREGATION, spec.storey, [space]);
+    return space;
+}
+function extentOf(reader, space) {
+    const extruded = extrudedBodyOf(reader, space);
+    const frame = extruded === undefined ? undefined : composeAxes(absoluteFrame(reader, objectPlacementOf(reader, space)), extruded.frame);
+    const direction = extruded === undefined ? undefined : directionOf(reader, reader.attribute(extruded.solid, "ExtrudedDirection"), [0, 0, 1]);
+    const upright = frame !== undefined && direction !== undefined && frame.z[2] >= VERTICAL_COSINE && direction[2] / Math.hypot(direction[0], direction[1], direction[2]) >= VERTICAL_COSINE;
+    return extruded && upright ? [extruded.shape.area, extruded.depth] : [0, 0];
+}
+export function spacesOf(reader, storey) {
+    return reader.byType(SPACE)
+        .map((entity) => ({ id: entity.id, storey: relatingOf(reader, AGGREGATION, entity.id) }))
+        .filter((space) => storey === undefined || space.storey === storey)
+        .map(({ id, storey: holder }) => {
+        var _a, _b, _c, _d;
+        const [area, height] = extentOf(reader, id);
+        return {
+            globalId: (_a = textValue(reader.attribute(id, "GlobalId"))) !== null && _a !== void 0 ? _a : "",
+            name: (_b = textValue(reader.attribute(id, "Name"))) !== null && _b !== void 0 ? _b : "",
+            longName: (_c = textValue(reader.attribute(id, "LongName"))) !== null && _c !== void 0 ? _c : "",
+            storey: holder === undefined ? "" : (_d = textValue(reader.attribute(holder, "GlobalId"))) !== null && _d !== void 0 ? _d : "",
+            area,
+            height,
+        };
+    });
+}

package/lib/build/spatial.d.ts

@@ -0,0 +1,17 @@
+import type * as Inputs from "../api/inputs";
+import type { ModelSnapshot } from "../model/snapshot";
+import type { IfcTransaction } from "../model/transaction";
+import type { ModelReader } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+import type { Frame3 } from "./build-types";
+export declare function resolveObject(model: ModelSnapshot, idOrGlobalId: string, type: string, what: string): number;
+export declare function describeObject(reader: ModelReader, id: number): string;
+export declare function onlyBuilding(model: ModelSnapshot): number;
+export declare function containIn(tx: IfcTransaction, writer: EntityWriter, structure: number, element: number): void;
+export declare function containerOf(reader: ModelReader, element: number): number | undefined;
+export declare function standingIn(reader: ModelReader, element: number): number | undefined;
+export declare function storeysOf(model: ModelSnapshot): Inputs.IFC.StoreyInfoDto[];
+export declare function addStorey(tx: IfcTransaction, writer: EntityWriter, building: number, id: string | undefined, name: string, elevation: number): number;
+export declare function storeyFrame(reader: ModelReader, storey: number): Frame3;
+export declare function storeyOf(reader: ModelReader, element: number): number | undefined;
+export declare function setStoreyElevation(tx: IfcTransaction, writer: EntityWriter, storey: number, elevation: number): void;

package/lib/build/spatial.js

@@ -0,0 +1,111 @@
+import { WORLD_AXES } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { keyGlobalId } from "../model/guid";
+import { enumValue, ref, textValue } from "../step/values";
+import { AGGREGATION, CONTAINMENT } from "./constants";
+import { absoluteFrame, movePlacement, objectPlacementOf, productsPlacedBy, relativeFrame } from "./placement";
+import { appendToRelationship, relatingOf } from "./relationships";
+const STOREY = "IfcBuildingStorey";
+const SPATIAL_ELEMENT = "IfcSpatialElement";
+const MAX_STRUCTURE_DEPTH = 32;
+function article(word) {
+    return /^[aeiou]/i.test(word) ? "an" : "a";
+}
+export function resolveObject(model, idOrGlobalId, type, what) {
+    const owners = model.globalIdOwners(idOrGlobalId);
+    if (owners.length > 1) {
+        throw new Error(`The GlobalId '${idOrGlobalId}' belongs to ${owners.length} entities (${owners.map((owner) => `#${owner}`).join(", ")}), so it names no single ${what}`);
+    }
+    const held = owners[0];
+    const id = held !== null && held !== void 0 ? held : model.byGlobalId(keyGlobalId(model.keySeed, idOrGlobalId));
+    if (id === undefined) {
+        throw new Error(`The model has no ${what} '${idOrGlobalId}'`);
+    }
+    const actual = model.typeOf(id);
+    if (!model.schema.isSubtypeOf(actual, type)) {
+        throw new Error(`'${idOrGlobalId}' is ${article(actual)} ${actual}, not ${article(what)} ${what}`);
+    }
+    return id;
+}
+export function describeObject(reader, id) {
+    var _a, _b, _c, _d;
+    const entity = reader.entity(id);
+    const name = (_b = textValue((_a = entity.args[2]) !== null && _a !== void 0 ? _a : null)) !== null && _b !== void 0 ? _b : "";
+    const globalId = (_d = textValue((_c = entity.args[0]) !== null && _c !== void 0 ? _c : null)) !== null && _d !== void 0 ? _d : "";
+    return name ? `the ${entity.type} '${name}'` : globalId ? `the ${entity.type} ${globalId}` : `#${id}`;
+}
+export function onlyBuilding(model) {
+    const buildings = model.byType("IfcBuilding");
+    if (buildings.length !== 1) {
+        throw new Error(`Storeys are added to the model's one building, and it has ${buildings.length}`);
+    }
+    return buildings[0].id;
+}
+export function containIn(tx, writer, structure, element) {
+    appendToRelationship(tx, writer, CONTAINMENT, structure, [element]);
+}
+export function containerOf(reader, element) {
+    return relatingOf(reader, CONTAINMENT, element);
+}
+export function standingIn(reader, element) {
+    let current = element;
+    for (let step = 0; current !== undefined && step < MAX_STRUCTURE_DEPTH; step++) {
+        const container = containerOf(reader, current);
+        if (container !== undefined) {
+            return container;
+        }
+        const whole = relatingOf(reader, AGGREGATION, current);
+        current = whole !== undefined && !reader.schema.isSubtypeOf(reader.entity(whole).type, SPATIAL_ELEMENT) ? whole : undefined;
+    }
+    return undefined;
+}
+export function storeysOf(model) {
+    return model.byType("IfcBuildingStorey")
+        .map((storey) => {
+        var _a, _b;
+        const elevation = model.attribute(storey.id, "Elevation");
+        return {
+            globalId: (_a = textValue(model.attribute(storey.id, "GlobalId"))) !== null && _a !== void 0 ? _a : "",
+            name: (_b = textValue(model.attribute(storey.id, "Name"))) !== null && _b !== void 0 ? _b : "",
+            elevation: typeof elevation === "number" ? elevation : 0,
+        };
+    })
+        .sort((a, b) => a.elevation - b.elevation);
+}
+export function addStorey(tx, writer, building, id, name, elevation) {
+    const storey = writer.create("IfcBuildingStorey", {
+        GlobalId: tx.globalId(id),
+        Name: name,
+        ObjectPlacement: ref(writer.localPlacement(objectPlacementOf(tx, building), Object.assign(Object.assign({}, WORLD_AXES), { origin: [0, 0, elevation] }))),
+        CompositionType: enumValue("ELEMENT"),
+        Elevation: elevation,
+    });
+    appendToRelationship(tx, writer, AGGREGATION, building, [storey]);
+    return storey;
+}
+export function storeyFrame(reader, storey) {
+    return absoluteFrame(reader, objectPlacementOf(reader, storey));
+}
+export function storeyOf(reader, element) {
+    var _a;
+    let current = element;
+    for (let step = 0; current !== undefined && step < MAX_STRUCTURE_DEPTH; step++) {
+        const holder = (_a = containerOf(reader, current)) !== null && _a !== void 0 ? _a : relatingOf(reader, AGGREGATION, current);
+        if (holder !== undefined && reader.schema.isSubtypeOf(reader.entity(holder).type, STOREY)) {
+            return holder;
+        }
+        current = holder;
+    }
+    return undefined;
+}
+export function setStoreyElevation(tx, writer, storey, elevation) {
+    const placement = objectPlacementOf(tx, storey);
+    const sharer = productsPlacedBy(tx, placement).find((product) => product !== storey);
+    if (sharer !== undefined) {
+        throw new Error(`${describeObject(tx, storey)} shares its placement with ${describeObject(tx, sharer)}, so it cannot move on its own`);
+    }
+    const frame = relativeFrame(tx, placement);
+    const recorded = tx.attribute(storey, "Elevation");
+    const rise = elevation - (typeof recorded === "number" ? recorded : frame.origin[2]);
+    movePlacement(tx, writer, placement, Object.assign(Object.assign({}, frame), { origin: [frame.origin[0], frame.origin[1], frame.origin[2] + rise] }));
+    tx.update(storey, { Elevation: elevation });
+}

package/lib/build/type-objects.d.ts

@@ -0,0 +1,4 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { EntityWriter } from "./entity-writer";
+export declare function defineByType(tx: IfcTransaction, writer: EntityWriter, occurrence: number, type: number): void;
+export declare function declareInProject(tx: IfcTransaction, writer: EntityWriter, definition: number): void;

package/lib/build/type-objects.js

@@ -0,0 +1,9 @@
+import { DECLARATION, TYPE_DEFINITION } from "./constants";
+import { projectOf } from "./project";
+import { appendToRelationship } from "./relationships";
+export function defineByType(tx, writer, occurrence, type) {
+    appendToRelationship(tx, writer, TYPE_DEFINITION, type, [occurrence]);
+}
+export function declareInProject(tx, writer, definition) {
+    appendToRelationship(tx, writer, DECLARATION, projectOf(tx.base), [definition]);
+}

package/lib/build/wall-edits.d.ts

@@ -0,0 +1,5 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { WallChange } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function editWall(tx: IfcTransaction, writer: EntityWriter, wall: number, change: WallChange, tolerance: number, parallelTolerance: number): void;
+export declare function disconnectWalls(tx: IfcTransaction, writer: EntityWriter, first: number, second: number, tolerance: number, parallelTolerance: number): void;

package/lib/build/wall-edits.js

@@ -0,0 +1,138 @@
+import { WORLD_AXES, composeAxes, pointToWorld, relativeAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { length2, length3, subtract2, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { isReference, ref } from "../step/values";
+import { MATERIAL_ASSOCIATION, TYPE_DEFINITION } from "./constants";
+import { axisContext } from "./contexts";
+import { requiredReference } from "./checks";
+import { associateNewMaterial, layerSetThickness, layerSetUsage, materialOf } from "./materials";
+import { normalize2 } from "./math";
+import { carriedWith, carryOpening, openingsOf, readWallOpening } from "./openings";
+import { absoluteFrame, axisPlacementFrame, movePlacement, objectPlacementOf } from "./placement";
+import { detach, relatingOf } from "./relationships";
+import { describeObject } from "./spatial";
+import { alignmentOf, axisFrame, layerSetOf, readWall } from "./wall-geometry";
+import { joinsOf, offsetFor, regenerateWall, stillMeet } from "./walls";
+import { firstItem, replaceRepresentation, representationOf, unwrapClippings } from "./representations";
+function movesAny(from, to, points, tolerance) {
+    return points.some((point) => length3(subtract3(pointToWorld(to, point), pointToWorld(from, point))) > tolerance);
+}
+function wallFrame(start, end, bottom) {
+    const direction = normalize2(subtract2(end, start));
+    return {
+        origin: [start[0], start[1], bottom],
+        x: [direction[0], direction[1], 0],
+        y: [-direction[1], direction[0], 0],
+        z: [0, 0, 1],
+    };
+}
+function rebasedHalfSpace(tx, writer, halfSpace, from, to) {
+    const type = tx.entity(halfSpace).type;
+    const surface = tx.attribute(halfSpace, "BaseSurface");
+    if ((type !== "IfcHalfSpaceSolid" && type !== "IfcPolygonalBoundedHalfSpace") || !isReference(surface) || tx.entity(surface.ref).type !== "IfcPlane") {
+        throw new Error(`The wall is clipped by an ${type} this library does not move with a wall`);
+    }
+    const moved = (owner) => writer.placement3(relativeAxes(to, composeAxes(from, axisPlacementFrame(tx, requiredReference(tx, owner, "Position")))));
+    const plane = writer.create("IfcPlane", { Position: ref(moved(surface.ref)) });
+    const agreement = tx.attribute(halfSpace, "AgreementFlag");
+    if (type === "IfcHalfSpaceSolid") {
+        return writer.create(type, { BaseSurface: ref(plane), AgreementFlag: agreement });
+    }
+    return writer.create(type, { BaseSurface: ref(plane), AgreementFlag: agreement, Position: ref(moved(halfSpace)), PolygonalBoundary: tx.attribute(halfSpace, "PolygonalBoundary") });
+}
+function refuseTypedLayers(tx, wall) {
+    const type = relatingOf(tx, TYPE_DEFINITION, wall);
+    if (type !== undefined && materialOf(tx, type) !== undefined) {
+        throw new Error(`${describeObject(tx, wall)} takes its layers from ${describeObject(tx, type)}, so its layer set cannot change on its own`);
+    }
+}
+function placeOpenings(tx, before, after, moves, tolerance) {
+    const placement = objectPlacementOf(tx, before.wall);
+    const facesMove = Math.abs(after.low - before.low) > tolerance || Math.abs(after.high - before.high) > tolerance;
+    const places = [];
+    for (const opening of openingsOf(tx, before.wall)) {
+        const place = readWallOpening(tx, before, placement, opening, tolerance);
+        if ((facesMove && place === undefined) || ((facesMove || moves) && !carriedWith(tx, opening, placement))) {
+            throw new Error(`${describeObject(tx, opening)} is not an opening this library can carry with the wall, so the wall cannot change this way`);
+        }
+        if (place !== undefined && (place.offset < -tolerance || place.offset + place.width > after.length + tolerance)) {
+            throw new Error(`${describeObject(tx, opening)}, from ${place.offset} to ${place.offset + place.width} along the wall, would not fit on a wall ${after.length} long; move it first with openings.edit`);
+        }
+        if (place !== undefined && facesMove) {
+            places.push(place);
+        }
+    }
+    return places;
+}
+export function editWall(tx, writer, wall, change, tolerance, parallelTolerance) {
+    var _a, _b, _c, _d, _e, _f;
+    const before = readWall(tx, wall);
+    if (before.body === undefined) {
+        throw new Error(`${describeObject(tx, wall)} has no Body representation, so this library cannot rebuild it`);
+    }
+    const start = (_a = change.start) !== null && _a !== void 0 ? _a : before.start;
+    const end = (_b = change.end) !== null && _b !== void 0 ? _b : before.end;
+    const height = (_c = change.height) !== null && _c !== void 0 ? _c : before.height;
+    const length = length2(subtract2(end, start));
+    if (!(length > tolerance)) {
+        throw new Error("A wall's start and end must be apart");
+    }
+    if (!(height > 0)) {
+        throw new Error(`A wall's height must be more than zero, got ${height}`);
+    }
+    const layerSet = (_d = change.layerSet) !== null && _d !== void 0 ? _d : layerSetOf(tx, before);
+    const layersChange = layerSet !== layerSetOf(tx, before);
+    if (layersChange) {
+        refuseTypedLayers(tx, wall);
+    }
+    const thickness = layerSetThickness(tx, layerSet);
+    if (!(thickness > 0)) {
+        throw new Error("A wall's layers must add up to more than zero thickness");
+    }
+    const alignment = (_e = change.alignment) !== null && _e !== void 0 ? _e : alignmentOf(before, tolerance);
+    const low = alignment === undefined ? before.low : offsetFor(alignment, thickness);
+    const axis = axisFrame(before);
+    const target = wallFrame(start, end, (_f = change.bottom) !== null && _f !== void 0 ? _f : pointToWorld(before.frame, axis.origin)[2]);
+    const frame = composeAxes(target, relativeAxes(axis, WORLD_AXES));
+    const after = Object.assign(Object.assign({}, before), { frame, start, end, direction: [target.x[0], target.x[1]], length, low, high: low + thickness, height });
+    for (const join of joinsOf(tx, wall)) {
+        if (!stillMeet(after, join.mine, readWall(tx, join.other), join.theirs, tolerance, parallelTolerance)) {
+            throw new Error(`The change takes ${describeObject(tx, wall)} away from ${describeObject(tx, join.other)}, which it is joined to; disconnect them first with walls.disconnect`);
+        }
+    }
+    const reach = Math.max(before.length, length);
+    const top = Math.max(before.height, height);
+    const corners = [0, reach].flatMap((along) => [before.low, before.high].flatMap((across) => [0, top].map((up) => [along, across, up])));
+    const moves = movesAny(composeAxes(before.frame, axis), target, corners, tolerance);
+    const places = placeOpenings(tx, before, after, moves, tolerance);
+    const halfSpaces = unwrapClippings(tx, firstItem(tx, before.body))[1].map((halfSpace) => (moves ? rebasedHalfSpace(tx, writer, halfSpace, before.frame, frame) : halfSpace));
+    const placement = objectPlacementOf(tx, wall);
+    const parent = tx.attribute(placement, "PlacementRelTo");
+    movePlacement(tx, writer, placement, relativeAxes(isReference(parent) ? absoluteFrame(tx, parent.ref) : WORLD_AXES, frame));
+    const axisEnd = pointToWorld(axis, [length, 0, 0]);
+    const axisCurve = writer.polyCurve2([[axis.origin[0], axis.origin[1]], [axisEnd[0], axisEnd[1]]], false);
+    replaceRepresentation(tx, wall, representationOf(tx, wall, "Axis"), writer.shapeRepresentation(axisContext(tx, writer), "Axis", "Curve2D", [axisCurve]));
+    if (layersChange || Math.abs(low - before.low) > tolerance) {
+        tx.dropIfUnused(detach(tx, MATERIAL_ASSOCIATION, wall));
+        associateNewMaterial(tx, writer, [wall], layerSetUsage(writer, layerSet, "AXIS2", "POSITIVE", low));
+    }
+    places.forEach((place) => carryOpening(tx, writer, place, place, before, after));
+    regenerateWall(tx, writer, wall, tolerance, parallelTolerance, { height, base: before.base, halfSpaces });
+    for (const join of joinsOf(tx, wall)) {
+        if (join.theirs !== "ATPATH") {
+            regenerateWall(tx, writer, join.other, tolerance, parallelTolerance);
+        }
+    }
+}
+export function disconnectWalls(tx, writer, first, second, tolerance, parallelTolerance) {
+    const joins = joinsOf(tx, first).filter((join) => join.other === second);
+    if (!joins.length) {
+        throw new Error(`${describeObject(tx, first)} and ${describeObject(tx, second)} are not joined`);
+    }
+    joins.forEach((join) => tx.delete(join.relationship));
+    if (joins.some((join) => join.mine !== "ATPATH")) {
+        regenerateWall(tx, writer, first, tolerance, parallelTolerance);
+    }
+    if (joins.some((join) => join.theirs !== "ATPATH")) {
+        regenerateWall(tx, writer, second, tolerance, parallelTolerance);
+    }
+}

package/lib/build/wall-geometry.d.ts

@@ -0,0 +1,15 @@
+import type { Base } from "@bitbybit-dev/base";
+import * as Inputs from "../api/inputs";
+import type { ModelReader, WallCuts, WallEnd, WallGeometry } from "./build-types";
+import type { Frame3, Line2 } from "./build-types";
+export declare function readWall(reader: ModelReader, wall: number): WallGeometry;
+export declare function axisFrame(geometry: WallGeometry): Frame3;
+export declare function alignmentOf(geometry: WallGeometry, tolerance: number): Inputs.IFC.wallAlignmentEnum | undefined;
+export declare function layerSetOf(reader: ModelReader, geometry: WallGeometry): number;
+export declare function sideLine(geometry: WallGeometry, across: number): Line2;
+export declare function axisLine(geometry: WallGeometry): Line2;
+export declare function endPoint(geometry: WallGeometry, end: WallEnd): Base.Point2;
+export declare function mitreCut(wall: WallGeometry, wallEnd: WallEnd, other: WallGeometry, otherEnd: WallEnd, tolerance: number, parallelTolerance: number): Line2 | undefined;
+export declare function buttCut(stem: WallGeometry, stemEnd: WallEnd, through: WallGeometry): Line2;
+export declare function footprintOf(geometry: WallGeometry, cuts: WallCuts, tolerance: number, parallelTolerance: number): Base.Point2[];
+export declare function readableWall(reader: ModelReader, wall: number): WallGeometry | undefined;