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

package/lib/build/project.js

@@ -0,0 +1,134 @@
+import { WORLD_AXES } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { projectGlobalId, randomGlobalId } from "../model/guid";
+import { emptyModel } from "../model/io";
+import { IfcTransaction } from "../model/transaction";
+import { DERIVED, enumValue, isEnumeration, isList, isReference, isTyped, ref } from "../step/values";
+import * as Inputs from "../api/inputs";
+import { AGGREGATION, DEFAULT_PRECISION_METRES, LENGTH_PREFIXES, METRES_TO_MILLIMETRES } from "./constants";
+import { EntityWriter } from "./entity-writer";
+import { relate } from "./relationships";
+export const SCHEMA_FOR_NEW_MODELS = "IFC4";
+export const DESIGN_TRANSFER_VIEW = "ViewDefinition [DesignTransferView_V1.0]";
+const PREFIX_OF_UNIT = {
+    [Inputs.IFC.lengthUnitEnum.millimetre]: "MILLI",
+    [Inputs.IFC.lengthUnitEnum.centimetre]: "CENTI",
+    [Inputs.IFC.lengthUnitEnum.metre]: undefined,
+};
+function siUnit(writer, unitType, name, prefix) {
+    return writer.create("IfcSIUnit", { Dimensions: DERIVED, UnitType: enumValue(unitType), Prefix: prefix === undefined ? null : enumValue(prefix), Name: enumValue(name) });
+}
+export function precisionFor(unit) {
+    return DEFAULT_PRECISION_METRES / metresPerUnit(PREFIX_OF_UNIT[unit]);
+}
+const UNIT_POWERS = { LENGTHUNIT: 1, AREAUNIT: 2, VOLUMEUNIT: 3, PLANEANGLEUNIT: 1 };
+const NAMED_UNIT = "IfcNamedUnit";
+const MAX_UNIT_DEPTH = 8;
+function metresPerUnit(prefix) {
+    var _a;
+    return prefix === undefined ? 1 : (_a = LENGTH_PREFIXES[prefix]) !== null && _a !== void 0 ? _a : 1;
+}
+export function createProject(project) {
+    const globalId = project.seed === undefined ? randomGlobalId() : projectGlobalId(project.seed);
+    const tx = new IfcTransaction(emptyModel(SCHEMA_FOR_NEW_MODELS, project.header), globalId);
+    const writer = new EntityWriter(tx);
+    const precision = precisionFor(project.lengthUnit);
+    const units = writer.create("IfcUnitAssignment", {
+        Units: [
+            siUnit(writer, "LENGTHUNIT", "METRE", PREFIX_OF_UNIT[project.lengthUnit]),
+            siUnit(writer, "AREAUNIT", "SQUARE_METRE"),
+            siUnit(writer, "VOLUMEUNIT", "CUBIC_METRE"),
+            siUnit(writer, "PLANEANGLEUNIT", "RADIAN"),
+        ].map(ref),
+    });
+    const model3d = writer.create("IfcGeometricRepresentationContext", {
+        ContextType: "Model",
+        CoordinateSpaceDimension: 3,
+        Precision: precision,
+        WorldCoordinateSystem: ref(writer.placement3(WORLD_AXES)),
+        TrueNorth: ref(writer.direction([0, 1])),
+    });
+    const plan = writer.create("IfcGeometricRepresentationContext", {
+        ContextType: "Plan",
+        CoordinateSpaceDimension: 2,
+        Precision: precision,
+        WorldCoordinateSystem: ref(writer.placement2([0, 0])),
+    });
+    const subContext = (parent, identifier, type, view) => writer.create("IfcGeometricRepresentationSubContext", {
+        ContextIdentifier: identifier,
+        ContextType: type,
+        ParentContext: ref(parent),
+        TargetView: enumValue(view),
+    });
+    subContext(model3d, "Body", "Model", "MODEL_VIEW");
+    subContext(model3d, "Axis", "Model", "GRAPH_VIEW");
+    subContext(model3d, "Box", "Model", "MODEL_VIEW");
+    subContext(plan, "Axis", "Plan", "GRAPH_VIEW");
+    subContext(plan, "FootPrint", "Plan", "PLAN_VIEW");
+    const projectId = writer.create("IfcProject", {
+        GlobalId: tx.givenGlobalId(globalId),
+        Name: project.name,
+        RepresentationContexts: [ref(model3d), ref(plan)],
+        UnitsInContext: ref(units),
+    });
+    const sitePlacement = writer.localPlacement(undefined, WORLD_AXES);
+    const site = writer.create("IfcSite", {
+        GlobalId: tx.structureGlobalId("site"),
+        Name: project.siteName,
+        ObjectPlacement: ref(sitePlacement),
+        CompositionType: enumValue("ELEMENT"),
+    });
+    const building = writer.create("IfcBuilding", {
+        GlobalId: tx.structureGlobalId("building"),
+        Name: project.buildingName,
+        ObjectPlacement: ref(writer.localPlacement(sitePlacement, WORLD_AXES)),
+        CompositionType: enumValue("ELEMENT"),
+    });
+    relate(tx, writer, AGGREGATION, projectId, [site]);
+    relate(tx, writer, AGGREGATION, site, [building]);
+    return tx.commit();
+}
+export function projectOf(model) {
+    const project = model.byType("IfcProject")[0];
+    if (!project) {
+        throw new Error("The model has no IfcProject");
+    }
+    return project.id;
+}
+function siFactor(model, unit, power, depth) {
+    if (depth > MAX_UNIT_DEPTH) {
+        throw new Error(`The unit #${unit} is converted through more than ${MAX_UNIT_DEPTH} other units, or through itself`);
+    }
+    const entity = model.entity(unit);
+    if (entity.type === "IfcSIUnit") {
+        const prefix = model.attribute(unit, "Prefix");
+        return Math.pow(metresPerUnit(isEnumeration(prefix) ? prefix.enum : undefined), power);
+    }
+    const measure = model.schema.isSubtypeOf(entity.type, "IfcConversionBasedUnit") ? model.attribute(unit, "ConversionFactor") : null;
+    if (!isReference(measure)) {
+        return 1;
+    }
+    const value = model.attribute(measure.ref, "ValueComponent");
+    const base = model.attribute(measure.ref, "UnitComponent");
+    const factor = isTyped(value) && typeof value.value === "number" ? value.value : 1;
+    return factor * (isReference(base) ? siFactor(model, base.ref, power, depth + 1) : 1);
+}
+export function siPerUnit(model, unitType) {
+    const units = model.attribute(projectOf(model), "UnitsInContext");
+    const list = isReference(units) ? model.attribute(units.ref, "Units") : null;
+    for (const unit of isList(list) ? list : []) {
+        if (!isReference(unit) || !model.schema.isSubtypeOf(model.entity(unit.ref).type, NAMED_UNIT)) {
+            continue;
+        }
+        const type = model.attribute(unit.ref, "UnitType");
+        if (isEnumeration(type) && type.enum === unitType) {
+            return siFactor(model, unit.ref, UNIT_POWERS[unitType], 0);
+        }
+    }
+    return 1;
+}
+export function millimetresPerUnit(model) {
+    return siPerUnit(model, "LENGTHUNIT") * METRES_TO_MILLIMETRES;
+}
+export function radiansPerUnit(model) {
+    return siPerUnit(model, "PLANEANGLEUNIT");
+}

package/lib/build/properties.d.ts

@@ -0,0 +1,10 @@
+import type * as Inputs from "../api/inputs";
+import type { IfcTransaction } from "../model/transaction";
+import type { ModelReader, PropertySpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function addPropertySet(tx: IfcTransaction, writer: EntityWriter, objects: readonly number[], name: string, properties: readonly PropertySpec[]): number;
+export declare function definitionsOf(reader: ModelReader, object: number): number[];
+export declare function propertySetsOf(reader: ModelReader, object: number): Inputs.IFC.PropertySetInfoDto[];
+export declare function setPropertyValues(tx: IfcTransaction, writer: EntityWriter, object: number, name: string, properties: readonly PropertySpec[]): void;
+export declare function removePropertyValues(tx: IfcTransaction, writer: EntityWriter, object: number, name: string, names: readonly string[]): void;
+export declare function removePropertySet(tx: IfcTransaction, writer: EntityWriter, object: number, name: string): void;

package/lib/build/properties.js

@@ -0,0 +1,182 @@
+import { isList, isReference, isTyped, ref, typed } from "../step/values";
+import { PROPERTY_DEFINITION } from "./constants";
+import { relate } from "./relationships";
+import { describeObject } from "./spatial";
+const TYPE_OBJECT = "IfcTypeObject";
+function nominalValue(property) {
+    if (property.type !== undefined) {
+        return typed(property.type, property.value);
+    }
+    if (typeof property.value === "string") {
+        return typed("IfcLabel", property.value);
+    }
+    if (typeof property.value === "boolean") {
+        return typed("IfcBoolean", property.value);
+    }
+    return typed(Number.isSafeInteger(property.value) ? "IfcInteger" : "IfcReal", property.value);
+}
+function referencesOf(value) {
+    if (isReference(value)) {
+        return [value.ref];
+    }
+    const items = isTyped(value) ? value.value : value;
+    return isList(items) ? items.filter(isReference).map((item) => item.ref) : [];
+}
+function isType(reader, object) {
+    return reader.schema.isSubtypeOf(reader.entity(object).type, TYPE_OBJECT);
+}
+function writeProperties(writer, properties) {
+    const names = new Set();
+    return properties.map((property) => {
+        if (names.has(property.name)) {
+            throw new Error(`The property set names '${property.name}' twice`);
+        }
+        names.add(property.name);
+        return writer.create("IfcPropertySingleValue", { Name: property.name, NominalValue: nominalValue(property) });
+    });
+}
+function attach(tx, writer, objects, set) {
+    const types = objects.filter((object) => isType(tx, object));
+    const occurrences = objects.filter((object) => !types.includes(object));
+    for (const type of types) {
+        tx.update(type, { HasPropertySets: [...referencesOf(tx.attribute(type, "HasPropertySets")).map(ref), ref(set)] });
+    }
+    if (occurrences.length) {
+        relate(tx, writer, PROPERTY_DEFINITION, set, occurrences);
+    }
+}
+export function addPropertySet(tx, writer, objects, name, properties) {
+    if (!properties.length) {
+        throw new Error("A property set needs at least one property");
+    }
+    const propertyIds = writeProperties(writer, properties);
+    const set = writer.create("IfcPropertySet", { GlobalId: tx.globalId(undefined), Name: name, HasProperties: propertyIds.map(ref) });
+    attach(tx, writer, objects, set);
+    return set;
+}
+export function definitionsOf(reader, object) {
+    if (isType(reader, object)) {
+        return referencesOf(reader.attribute(object, "HasPropertySets"));
+    }
+    return reader.referencesTo(object)
+        .filter((user) => reader.typeOf(user) === PROPERTY_DEFINITION.relationship && referencesOf(reader.attribute(user, PROPERTY_DEFINITION.related)).includes(object))
+        .flatMap((user) => referencesOf(reader.attribute(user, PROPERTY_DEFINITION.relating)));
+}
+function singleValues(reader, set) {
+    const values = {};
+    for (const property of referencesOf(reader.attribute(set, "HasProperties"))) {
+        if (reader.entity(property).type !== "IfcPropertySingleValue") {
+            continue;
+        }
+        const name = reader.attribute(property, "Name");
+        const value = reader.attribute(property, "NominalValue");
+        const inner = isTyped(value) ? value.value : null;
+        if (typeof name === "string" && (typeof inner === "string" || typeof inner === "number" || typeof inner === "boolean")) {
+            values[name] = inner;
+        }
+    }
+    return values;
+}
+export function propertySetsOf(reader, object) {
+    return definitionsOf(reader, object)
+        .filter((definition) => reader.entity(definition).type === "IfcPropertySet")
+        .map((set) => {
+        const name = reader.attribute(set, "Name");
+        return { name: typeof name === "string" ? name : "", properties: singleValues(reader, set) };
+    });
+}
+function nameOf(reader, id) {
+    const name = reader.attribute(id, "Name");
+    return typeof name === "string" ? name : "";
+}
+function findSet(reader, object, name) {
+    return definitionsOf(reader, object).find((definition) => reader.entity(definition).type === "IfcPropertySet" && nameOf(reader, definition) === name);
+}
+function namedSet(reader, object, name) {
+    const set = findSet(reader, object, name);
+    if (set === undefined) {
+        throw new Error(`${describeObject(reader, object)} has no property set named '${name}'`);
+    }
+    return set;
+}
+function holdersOf(reader, set) {
+    return reader.referencesTo(set).reduce((count, user) => {
+        if (reader.typeOf(user) === PROPERTY_DEFINITION.relationship) {
+            return count + referencesOf(reader.attribute(user, PROPERTY_DEFINITION.related)).length;
+        }
+        return count + (isType(reader, user) ? 1 : 0);
+    }, 0);
+}
+function detachSet(tx, writer, object, set) {
+    if (isType(tx, object)) {
+        const kept = referencesOf(tx.attribute(object, "HasPropertySets")).filter((id) => id !== set);
+        tx.update(object, { HasPropertySets: kept.length ? kept.map(ref) : null });
+        return;
+    }
+    for (const user of tx.referencesTo(set)) {
+        const related = tx.typeOf(user) === PROPERTY_DEFINITION.relationship ? referencesOf(tx.attribute(user, PROPERTY_DEFINITION.related)) : [];
+        if (!related.includes(object)) {
+            continue;
+        }
+        const siblings = referencesOf(tx.attribute(user, PROPERTY_DEFINITION.relating)).filter((id) => id !== set);
+        const kept = related.filter((id) => id !== object);
+        if (kept.length) {
+            tx.update(user, { [PROPERTY_DEFINITION.related]: kept.map(ref) });
+        }
+        else {
+            tx.delete(user);
+        }
+        siblings.forEach((sibling) => relate(tx, writer, PROPERTY_DEFINITION, sibling, [object]));
+    }
+}
+function ownSet(tx, writer, object, set) {
+    if (holdersOf(tx, set) <= 1) {
+        return set;
+    }
+    const copy = writer.create("IfcPropertySet", {
+        GlobalId: tx.globalId(undefined),
+        Name: tx.attribute(set, "Name"),
+        Description: tx.attribute(set, "Description"),
+        HasProperties: tx.attribute(set, "HasProperties"),
+    });
+    detachSet(tx, writer, object, set);
+    attach(tx, writer, [object], copy);
+    return copy;
+}
+export function setPropertyValues(tx, writer, object, name, properties) {
+    if (!properties.length) {
+        throw new Error("Give at least one property to set");
+    }
+    const found = findSet(tx, object, name);
+    if (found === undefined) {
+        addPropertySet(tx, writer, [object], name, properties);
+        return;
+    }
+    const set = ownSet(tx, writer, object, found);
+    const changed = new Set(properties.map((property) => property.name));
+    const current = referencesOf(tx.attribute(set, "HasProperties"));
+    const kept = current.filter((property) => !changed.has(nameOf(tx, property)));
+    tx.update(set, { HasProperties: [...kept, ...writeProperties(writer, properties)].map(ref) });
+    tx.dropIfUnused(current.filter((property) => !kept.includes(property)));
+}
+export function removePropertyValues(tx, writer, object, name, names) {
+    const found = namedSet(tx, object, name);
+    const current = referencesOf(tx.attribute(found, "HasProperties"));
+    const missing = names.find((property) => !current.some((id) => nameOf(tx, id) === property));
+    if (missing !== undefined) {
+        throw new Error(`The property set '${name}' of ${describeObject(tx, object)} has no property named '${missing}'`);
+    }
+    const kept = current.filter((property) => !names.includes(nameOf(tx, property)));
+    if (!kept.length) {
+        removePropertySet(tx, writer, object, name);
+        return;
+    }
+    const set = ownSet(tx, writer, object, found);
+    tx.update(set, { HasProperties: kept.map(ref) });
+    tx.dropIfUnused(current.filter((property) => !kept.includes(property)));
+}
+export function removePropertySet(tx, writer, object, name) {
+    const set = namedSet(tx, object, name);
+    detachSet(tx, writer, object, set);
+    tx.dropIfUnused([set]);
+}

package/lib/build/quantities.d.ts

@@ -0,0 +1,7 @@
+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";
+export declare function computeQuantities(tx: IfcTransaction, writer: EntityWriter, model: ModelSnapshot, elements: readonly number[] | undefined, tolerance: number): void;
+export declare function quantitiesOf(reader: ModelReader, element: number): Inputs.IFC.QuantitySetInfoDto[];

package/lib/build/quantities.js

@@ -0,0 +1,262 @@
+import { composeAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { add2, scale2 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { isList, isReference, ref, textValue } from "../step/values";
+import { AGGREGATION, PROPERTY_DEFINITION, VOIDING } from "./constants";
+import { areaBetween, areaWithin, boundsOf, extrudedBodyOf, profileShape, volumeBetween, withLevels } from "./measure";
+import { openingsOf, readWallOpening } from "./openings";
+import { absoluteFrame, objectPlacementOf } from "./placement";
+import { siPerUnit } from "./project";
+import { definitionsOf } from "./properties";
+import { relate, relatedOf, relatingOf } from "./relationships";
+import { firstItem, unwrapClippings } from "./representations";
+import { clippingPlanes } from "./roof-clipping";
+import { frameOf } from "./solids";
+import { describeObject } from "./spatial";
+import { readableWall, sideLine } from "./wall-geometry";
+import { placedOnPlan } from "./math";
+const QUANTITY_ENTITIES = { length: "IfcQuantityLength", area: "IfcQuantityArea", volume: "IfcQuantityVolume" };
+const VALUE_ATTRIBUTES = {
+    IfcQuantityLength: "LengthValue",
+    IfcQuantityArea: "AreaValue",
+    IfcQuantityVolume: "VolumeValue",
+    IfcQuantityCount: "CountValue",
+    IfcQuantityWeight: "WeightValue",
+    IfcQuantityTime: "TimeValue",
+};
+const MEMBER_SETS = { IfcColumn: "Qto_ColumnBaseQuantities", IfcBeam: "Qto_BeamBaseQuantities", IfcMember: "Qto_MemberBaseQuantities" };
+const FILLING_SETS = { IfcDoor: "Qto_DoorBaseQuantities", IfcWindow: "Qto_WindowBaseQuantities" };
+const MEASURED_TYPES = ["IfcWall", "IfcSlab", "IfcColumn", "IfcBeam", "IfcMember", "IfcDoor", "IfcWindow", "IfcOpeningElement", "IfcSpace", "IfcRoof"];
+const ELEMENT_QUANTITY = "IfcElementQuantity";
+const PLAIN_HALF_SPACE = "IfcHalfSpaceSolid";
+function quantity(name, kind, value) {
+    return { name, kind, value: Math.max(0, value) };
+}
+function wallSet(reader, wall, tolerance) {
+    var _a;
+    const geometry = readableWall(reader, wall);
+    const items = (geometry === null || geometry === void 0 ? void 0 : geometry.body) === undefined ? null : reader.attribute(geometry.body, "Items");
+    if (!(geometry === null || geometry === void 0 ? void 0 : geometry.body) || !isList(items) || items.length !== 1) {
+        return undefined;
+    }
+    const [solid, halfSpaces] = unwrapClippings(reader, firstItem(reader, geometry.body));
+    const profile = reader.entity(solid).type === "IfcExtrudedAreaSolid" ? reader.attribute(solid, "SweptArea") : null;
+    const outline = isReference(profile) ? (_a = profileShape(reader, profile.ref)) === null || _a === void 0 ? void 0 : _a.outline : undefined;
+    if (!outline || halfSpaces.some((halfSpace) => reader.entity(halfSpace).type !== PLAIN_HALF_SPACE)) {
+        return undefined;
+    }
+    const solidFrame = composeAxes(geometry.frame, frameOf(reader, reader.attribute(solid, "Position")));
+    const footprint = outline.map((point) => placedOnPlan(solidFrame, point));
+    const base = geometry.frame.origin[2] + geometry.base;
+    const bounds = boundsOf(base, base + geometry.height, clippingPlanes(reader, geometry, geometry.body));
+    const thickness = geometry.high - geometry.low;
+    const middle = sideLine(geometry, (geometry.low + geometry.high) / 2);
+    const along = (distance) => add2(middle.point, scale2(middle.direction, distance));
+    const grossSide = areaBetween(along(0), along(geometry.length), bounds);
+    const grossVolume = volumeBetween(footprint, bounds);
+    const footprintArea = areaWithin(footprint, bounds.sides);
+    const places = openingsOf(reader, wall).flatMap((opening) => { var _a; return (_a = readWallOpening(reader, geometry, objectPlacementOf(reader, wall), opening, tolerance)) !== null && _a !== void 0 ? _a : []; });
+    const cutSide = places.reduce((sum, place) => sum + areaBetween(along(place.offset), along(place.offset + place.width), withLevels(bounds, base + place.sill, base + place.sill + place.height)), 0);
+    const cutFootprint = places.filter((place) => place.sill <= tolerance).reduce((sum, place) => sum + place.width * thickness, 0);
+    return {
+        name: "Qto_WallBaseQuantities",
+        quantities: [
+            quantity("Length", "length", geometry.length),
+            quantity("Width", "length", thickness),
+            quantity("Height", "length", geometry.height),
+            quantity("GrossFootprintArea", "area", footprintArea),
+            quantity("NetFootprintArea", "area", footprintArea - cutFootprint),
+            quantity("GrossSideArea", "area", grossSide),
+            quantity("NetSideArea", "area", grossSide - cutSide),
+            quantity("GrossVolume", "volume", grossVolume),
+            quantity("NetVolume", "volume", grossVolume - cutSide * thickness),
+        ],
+    };
+}
+function slabSet(reader, slab) {
+    const extruded = extrudedBodyOf(reader, slab);
+    if (!extruded) {
+        return undefined;
+    }
+    const cut = openingsOf(reader, slab).reduce((sum, opening) => { var _a, _b; return sum + ((_b = (_a = extrudedBodyOf(reader, opening)) === null || _a === void 0 ? void 0 : _a.shape.area) !== null && _b !== void 0 ? _b : 0); }, 0);
+    const { area, perimeter } = extruded.shape;
+    return {
+        name: "Qto_SlabBaseQuantities",
+        quantities: [
+            quantity("Width", "length", extruded.depth),
+            quantity("Perimeter", "length", perimeter),
+            quantity("GrossArea", "area", area),
+            quantity("NetArea", "area", area - cut),
+            quantity("GrossVolume", "volume", area * extruded.depth),
+            quantity("NetVolume", "volume", (area - cut) * extruded.depth),
+        ],
+    };
+}
+function memberSet(reader, member, name) {
+    const extruded = extrudedBodyOf(reader, member);
+    if (!extruded) {
+        return undefined;
+    }
+    const { area, perimeter } = extruded.shape;
+    return {
+        name,
+        quantities: [
+            quantity("Length", "length", extruded.depth),
+            quantity("CrossSectionArea", "area", area),
+            quantity("OuterSurfaceArea", "area", perimeter * extruded.depth),
+            quantity("GrossVolume", "volume", area * extruded.depth),
+            quantity("NetVolume", "volume", area * extruded.depth),
+        ],
+    };
+}
+function fillingSet(reader, filling, name) {
+    const width = reader.attribute(filling, "OverallWidth");
+    const height = reader.attribute(filling, "OverallHeight");
+    if (typeof width !== "number" || typeof height !== "number") {
+        return undefined;
+    }
+    return {
+        name,
+        quantities: [
+            quantity("Width", "length", width),
+            quantity("Height", "length", height),
+            quantity("Perimeter", "length", 2 * (width + height)),
+            quantity("Area", "area", width * height),
+        ],
+    };
+}
+function openingSet(reader, opening, tolerance) {
+    const host = relatingOf(reader, VOIDING, opening);
+    const wall = host === undefined ? undefined : readableWall(reader, host);
+    const place = wall === undefined || host === undefined ? undefined : readWallOpening(reader, wall, objectPlacementOf(reader, host), opening, tolerance);
+    if (!wall || !place) {
+        return undefined;
+    }
+    return {
+        name: "Qto_OpeningElementBaseQuantities",
+        quantities: [quantity("Width", "length", place.width), quantity("Height", "length", place.height), quantity("Depth", "length", wall.high - wall.low)],
+    };
+}
+function spaceSet(reader, space) {
+    const extruded = extrudedBodyOf(reader, space);
+    if (!extruded) {
+        return undefined;
+    }
+    const { area, perimeter } = extruded.shape;
+    return {
+        name: "Qto_SpaceBaseQuantities",
+        quantities: [
+            quantity("Height", "length", extruded.depth),
+            quantity("GrossPerimeter", "length", perimeter),
+            quantity("GrossFloorArea", "area", area),
+            quantity("NetFloorArea", "area", area),
+            quantity("GrossVolume", "volume", area * extruded.depth),
+            quantity("NetVolume", "volume", area * extruded.depth),
+        ],
+    };
+}
+function roofSet(reader, roof) {
+    const parts = relatedOf(reader, AGGREGATION, roof);
+    const measured = parts.flatMap((part) => {
+        const extruded = extrudedBodyOf(reader, part);
+        if (!extruded) {
+            return [];
+        }
+        const frame = composeAxes(absoluteFrame(reader, objectPlacementOf(reader, part)), extruded.frame);
+        return [{ area: extruded.shape.area, projected: extruded.shape.area * Math.abs(frame.z[2]) }];
+    });
+    if (!measured.length || measured.length !== parts.length) {
+        return undefined;
+    }
+    const area = measured.reduce((sum, part) => sum + part.area, 0);
+    return {
+        name: "Qto_RoofBaseQuantities",
+        quantities: [
+            quantity("GrossArea", "area", area),
+            quantity("NetArea", "area", area),
+            quantity("ProjectedArea", "area", measured.reduce((sum, part) => sum + part.projected, 0)),
+        ],
+    };
+}
+function measuredSetOf(reader, element, tolerance) {
+    const type = reader.entity(element).type;
+    const is = (ancestor) => reader.schema.isSubtypeOf(type, ancestor);
+    if (is("IfcWall")) {
+        return wallSet(reader, element, tolerance);
+    }
+    if (is("IfcSlab")) {
+        return slabSet(reader, element);
+    }
+    const member = Object.keys(MEMBER_SETS).find(is);
+    if (member !== undefined) {
+        return memberSet(reader, element, MEMBER_SETS[member]);
+    }
+    const filling = Object.keys(FILLING_SETS).find(is);
+    if (filling !== undefined) {
+        return fillingSet(reader, element, FILLING_SETS[filling]);
+    }
+    if (is("IfcOpeningElement")) {
+        return openingSet(reader, element, tolerance);
+    }
+    if (is("IfcSpace")) {
+        return spaceSet(reader, element);
+    }
+    return is("IfcRoof") ? roofSet(reader, element) : undefined;
+}
+function scales(model) {
+    const metres = siPerUnit(model, "LENGTHUNIT");
+    return { length: 1, area: metres * metres / siPerUnit(model, "AREAUNIT"), volume: metres * metres * metres / siPerUnit(model, "VOLUMEUNIT") };
+}
+function replaceSet(tx, writer, element, set, scale) {
+    for (const user of tx.referencesTo(element)) {
+        const relating = tx.typeOf(user) === PROPERTY_DEFINITION.relationship ? tx.attribute(user, PROPERTY_DEFINITION.relating) : null;
+        if (!isReference(relating) || tx.entity(relating.ref).type !== ELEMENT_QUANTITY || tx.attribute(relating.ref, "Name") !== set.name) {
+            continue;
+        }
+        const related = tx.attribute(user, PROPERTY_DEFINITION.related);
+        const kept = (isList(related) ? related : []).filter((item) => !(isReference(item) && item.ref === element));
+        if (kept.length) {
+            tx.update(user, { [PROPERTY_DEFINITION.related]: kept });
+        }
+        else {
+            tx.delete(user);
+        }
+        tx.dropIfUnused([relating.ref]);
+    }
+    const quantities = set.quantities.map((measured) => {
+        const entity = QUANTITY_ENTITIES[measured.kind];
+        return writer.create(entity, { Name: measured.name, [VALUE_ATTRIBUTES[entity]]: measured.value * scale[measured.kind] });
+    });
+    const written = writer.create(ELEMENT_QUANTITY, { GlobalId: tx.globalId(undefined), Name: set.name, MethodOfMeasurement: "BaseQuantities", Quantities: quantities.map(ref) });
+    relate(tx, writer, PROPERTY_DEFINITION, written, [element]);
+}
+export function computeQuantities(tx, writer, model, elements, tolerance) {
+    const scale = scales(model);
+    const targets = elements !== null && elements !== void 0 ? elements : [...new Set(MEASURED_TYPES.flatMap((type) => model.byType(type).map((entity) => entity.id)))];
+    for (const element of targets) {
+        const set = measuredSetOf(tx, element, tolerance);
+        if (set) {
+            replaceSet(tx, writer, element, set, scale);
+        }
+        else if (elements) {
+            throw new Error(`${describeObject(tx, element)} is not an element whose base quantities this library measures`);
+        }
+    }
+}
+export function quantitiesOf(reader, element) {
+    return definitionsOf(reader, element)
+        .filter((definition) => reader.entity(definition).type === ELEMENT_QUANTITY)
+        .map((set) => {
+        var _a;
+        const values = {};
+        const quantities = reader.attribute(set, "Quantities");
+        for (const item of isList(quantities) ? quantities : []) {
+            const attribute = isReference(item) ? VALUE_ATTRIBUTES[reader.entity(item.ref).type] : undefined;
+            const name = isReference(item) ? reader.attribute(item.ref, "Name") : null;
+            const value = isReference(item) && attribute !== undefined ? reader.attribute(item.ref, attribute) : null;
+            if (typeof name === "string" && typeof value === "number") {
+                values[name] = value;
+            }
+        }
+        return { name: (_a = textValue(reader.attribute(set, "Name"))) !== null && _a !== void 0 ? _a : "", quantities: values };
+    });
+}

package/lib/build/relationships.d.ts

@@ -0,0 +1,9 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { ModelReader, RelationshipRoles } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function relatingOf(reader: ModelReader, roles: RelationshipRoles, part: number): number | undefined;
+export declare function relationshipsOf(reader: ModelReader, roles: RelationshipRoles, whole: number): number[];
+export declare function relate(tx: IfcTransaction, writer: EntityWriter, roles: RelationshipRoles, whole: number, parts: readonly number[]): number;
+export declare function appendToRelationship(tx: IfcTransaction, writer: EntityWriter, roles: RelationshipRoles, whole: number, parts: readonly number[]): number;
+export declare function detach(tx: IfcTransaction, roles: RelationshipRoles, part: number): number[];
+export declare function relatedOf(reader: ModelReader, roles: RelationshipRoles, whole: number): number[];