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

package/lib/api/services/model.js

@@ -0,0 +1,409 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { WORLD_AXES, vectorToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { textValue } from "../../step/values";
+import { createProject, DESIGN_TRANSFER_VIEW, millimetresPerUnit, projectOf, SCHEMA_FOR_NEW_MODELS } from "../../build/project";
+import { keyGlobalId } from "../../model/guid";
+import { readModel, writeModel, writeModelBytes } from "../../model/io";
+import { upgradeToIfc4 } from "../../model/upgrade";
+import { DEFAULT_IMPLEMENTATION_LEVEL } from "../../step/constants";
+import { isList, isReference } from "../../step/values";
+import * as Inputs from "../inputs";
+import { editModel, lengthTolerance, modelOf, oneOf, resolveId } from "./service-support";
+import { PARALLEL_TOLERANCE, POINT3_SIZE } from "../../build/constants";
+import { moveElement } from "../../build/moving";
+import { removeObject } from "../../build/removal";
+import { requireFinite, requirePoint } from "../../build/checks";
+import { standingIn, storeyFrame, storeyOf, storeysOf } from "../../build/spatial";
+import { georeferenceOf } from "../../build/georeference";
+const LIBRARY = "@bitbybit-dev/ifc";
+const ISO_SECONDS = 19;
+const MAX_PART_DEPTH = 32;
+function headerFor(model, resolved) {
+    var _a;
+    return Object.assign(Object.assign({}, model.header), { name: resolved.fileName, timeStamp: (_a = resolved.timeStamp) !== null && _a !== void 0 ? _a : new Date().toISOString().slice(0, ISO_SECONDS) });
+}
+function relatedPairs(model, relationship, relating, related) {
+    return model.byType(relationship).flatMap((rel) => {
+        const whole = model.attribute(rel.id, relating);
+        const parts = model.attribute(rel.id, related);
+        return isReference(whole) ? (isList(parts) ? parts : []).filter(isReference).map((part) => [part.ref, whole.ref]) : [];
+    });
+}
+function containers(model) {
+    var _a;
+    const container = new Map(relatedPairs(model, "IfcRelContainedInSpatialStructure", "RelatingStructure", "RelatedElements"));
+    const wholeOf = new Map(relatedPairs(model, "IfcRelAggregates", "RelatingObject", "RelatedObjects"));
+    for (const part of wholeOf.keys()) {
+        let whole = wholeOf.get(part);
+        for (let step = 0; whole !== undefined && !container.has(part) && step < MAX_PART_DEPTH; step++) {
+            const holder = container.get(whole);
+            if (holder !== undefined && !model.schema.isSubtypeOf((_a = model.typeOf(whole)) !== null && _a !== void 0 ? _a : "", "IfcSpatialElement")) {
+                container.set(part, holder);
+            }
+            whole = wholeOf.get(whole);
+        }
+    }
+    return container;
+}
+function infoOf(model, id, storey) {
+    var _a, _b;
+    const name = model.attribute(id, "Name");
+    const storeyGlobalId = storey === undefined ? null : model.attribute(storey, "GlobalId");
+    return {
+        globalId: (_a = textValue(model.attribute(id, "GlobalId"))) !== null && _a !== void 0 ? _a : "",
+        type: (_b = model.typeOf(id)) !== null && _b !== void 0 ? _b : "",
+        name: typeof name === "string" ? name : "",
+        storey: typeof storeyGlobalId === "string" ? storeyGlobalId : "",
+    };
+}
+/**
+ * Creates, reads, writes and inspects whole IFC models. A model is a value: every method that
+ * changes one returns a new model and leaves the one it was given as it was, so a change can be
+ * undone by keeping the earlier model.
+ *
+ * Objects are found by their GlobalId or by the id given when they were added, such as `north-wall`,
+ * which the model turns into a GlobalId of its own. Storeys are in `spatial`, building elements in
+ * `walls`, `slabs`, `doors` and the rest.
+ * @beta
+ */
+export class IFCModels {
+    /**
+     * Starts a new IFC4 model with a project, its site and one building, ready for storeys.
+     *
+     * Every length later given to the model is in `lengthUnit`, millimetres by default. With a
+     * `seed`, the same calls always write the same file; without one, the GlobalIds are random.
+     * @param inputs - The project's name, the site and building names, the length unit and a seed
+     * @returns A new model
+     * @group create
+     * @shortname create model
+     * @drawable false
+     * @example
+     * ```typescript
+     * let model = await bitbybit.ifc.model.create({ name: "House", seed: "house-1" });
+     * model = await bitbybit.ifc.spatial.addStorey({ model, id: "ground", name: "Ground floor", elevation: 0 });
+     * ```
+     */
+    create(inputs) {
+        var _a, _b;
+        const resolved = resolveDto(Inputs.IFC.CreateModelDto, inputs);
+        return createProject({
+            name: resolved.name,
+            siteName: resolved.siteName,
+            buildingName: resolved.buildingName,
+            lengthUnit: oneOf(resolved.lengthUnit, Inputs.IFC.lengthUnitEnum, "length unit"),
+            seed: resolved.seed,
+            header: {
+                description: [DESIGN_TRANSFER_VIEW],
+                implementationLevel: DEFAULT_IMPLEMENTATION_LEVEL,
+                name: "",
+                timeStamp: "",
+                author: [(_a = resolved.author) !== null && _a !== void 0 ? _a : ""],
+                organization: [(_b = resolved.organization) !== null && _b !== void 0 ? _b : ""],
+                preprocessorVersion: LIBRARY,
+                originatingSystem: LIBRARY,
+                authorization: "",
+                schemaIdentifiers: [SCHEMA_FOR_NEW_MODELS],
+            },
+        });
+    }
+    /**
+     * Reads an IFC file into a model to inspect, change and write back.
+     *
+     * Entities are decoded only when asked for, and unchanged ones are written back exactly as read.
+     * An IFC2X3 file is read through IFC4, to be shown and queried; `upgradeToIfc4` makes it
+     * editable. An `.ifczip` archive is read from the `.ifc` file it holds.
+     * @param inputs - The file's text or bytes
+     * @returns The model the file holds
+     * @group io
+     * @shortname read ifc
+     * @drawable false
+     * @example
+     * ```typescript
+     * const model = await bitbybit.ifc.model.read({ data: ifcText });
+     * const summary = await bitbybit.ifc.model.summary({ model });
+     * ```
+     */
+    read(inputs) {
+        if (typeof inputs.data !== "string" && !(inputs.data instanceof Uint8Array) && !(inputs.data instanceof ArrayBuffer)) {
+            throw new TypeError("Expected the IFC file as a text, a Uint8Array or an ArrayBuffer");
+        }
+        return readModel(inputs.data);
+    }
+    /**
+     * Turns a model read from an IFC2X3 file into an IFC4 model, which can be changed and is
+     * written as IFC4.
+     *
+     * New attributes stay unset, a newly required enumeration takes `NOTDEFINED`, sets lose repeats
+     * and a merged entity becomes its parent; other rows are written as read. Anything else stops
+     * the upgrade, naming the entity.
+     * @param inputs - The model
+     * @returns The upgraded model
+     * @group io
+     * @shortname upgrade to ifc4
+     * @drawable false
+     * @example
+     * ```typescript
+     * const old = await bitbybit.ifc.model.read({ data: ifc2x3Bytes });
+     * const model = await bitbybit.ifc.model.upgradeToIfc4({ model: old });
+     * ```
+     */
+    upgradeToIfc4(inputs) {
+        return upgradeToIfc4(modelOf(inputs.model));
+    }
+    /**
+     * Writes a model as the text of an `.ifc` file.
+     *
+     * The header records `fileName` and `timeStamp`; give a fixed `timeStamp` to write the same text
+     * every time. Entities read from a file and left unchanged are written as they were read, character
+     * for character.
+     * @param inputs - The model, the file name and the time stamp
+     * @returns The text of the IFC file
+     * @group io
+     * @shortname write ifc
+     * @drawable false
+     * @example
+     * ```typescript
+     * const text = await bitbybit.ifc.model.write({ model, fileName: "house.ifc" });
+     * ```
+     */
+    write(inputs) {
+        const resolved = resolveDto(Inputs.IFC.WriteModelDto, inputs);
+        const model = modelOf(resolved.model);
+        return writeModel(model, headerFor(model, resolved));
+    }
+    /**
+     * Writes a model as the bytes of an `.ifc` file, at any size.
+     *
+     * The header records `fileName` and `timeStamp`, as `model.write`'s does. Entities read from a file
+     * and left unchanged are copied byte for byte, so a file of hundreds of megabytes writes in a moment,
+     * where its text would not fit one JavaScript string.
+     * @param inputs - The model, the file name and the time stamp
+     * @returns The bytes of the IFC file
+     * @group io
+     * @shortname write ifc bytes
+     * @drawable false
+     * @example
+     * ```typescript
+     * const bytes = await bitbybit.ifc.model.writeBytes({ model, fileName: "house.ifc" });
+     * ```
+     */
+    writeBytes(inputs) {
+        const resolved = resolveDto(Inputs.IFC.WriteModelDto, inputs);
+        const model = modelOf(resolved.model);
+        return writeModelBytes(model, headerFor(model, resolved));
+    }
+    /**
+     * Describes what a model holds: its schema, its project, its unit, its storeys and how many
+     * elements of each type.
+     * @param inputs - The model
+     * @returns The model's summary
+     * @group query
+     * @shortname summary
+     * @drawable false
+     * @example
+     * ```typescript
+     * const summary = await bitbybit.ifc.model.summary({ model });
+     * console.log(summary.elementCounts.IfcWall);
+     * ```
+     */
+    summary(inputs) {
+        var _a;
+        const model = modelOf(inputs.model);
+        const counts = {};
+        for (const element of model.byType("IfcElement")) {
+            counts[element.type] = ((_a = counts[element.type]) !== null && _a !== void 0 ? _a : 0) + 1;
+        }
+        const project = model.attribute(projectOf(model), "Name");
+        return {
+            schema: model.schemaName,
+            editable: model.editable,
+            project: typeof project === "string" ? project : "",
+            millimetresPerUnit: millimetresPerUnit(model),
+            entities: model.size,
+            storeys: storeysOf(model),
+            elementCounts: counts,
+        };
+    }
+    /**
+     * Reads where a model sits on the Earth: the map conversion that places its coordinates in a
+     * projected coordinate reference system, and its site's reference latitude, longitude and
+     * elevation. A file without them gives the defaults, with `mapped` and `located` false.
+     * @param inputs - The model
+     * @returns The model's georeference
+     * @group query
+     * @shortname georeference
+     * @drawable false
+     * @example
+     * ```typescript
+     * const georeference = await bitbybit.ifc.model.georeference({ model });
+     * console.log(georeference.crs, georeference.eastings, georeference.northings);
+     * ```
+     */
+    georeference(inputs) {
+        return georeferenceOf(modelOf(inputs.model));
+    }
+    /**
+     * Lists the objects of one IFC type, its subtypes included, optionally only those standing in
+     * one storey or other spatial element. An aggregate's part stands where its whole stands.
+     *
+     * `type` is any type with a GlobalId, such as `IfcWall`, `IfcDoor` or `IfcElement` for every
+     * building element. The list is in the order the model holds them.
+     * @param inputs - The model, the type and an optional storey
+     * @returns Each object's GlobalId, type, name and the spatial element it stands in
+     * @group query
+     * @shortname elements
+     * @drawable false
+     * @example
+     * ```typescript
+     * const walls = await bitbybit.ifc.model.elements({ model, type: "IfcWall", storey: "ground" });
+     * ```
+     */
+    elements(inputs) {
+        const resolved = resolveDto(Inputs.IFC.ElementsDto, inputs);
+        const model = modelOf(resolved.model);
+        if (!model.schema.hasEntity(resolved.type) || !model.schema.isSubtypeOf(resolved.type, "IfcRoot")) {
+            throw new Error(`${resolved.type} is not an IFC type with a GlobalId`);
+        }
+        const storey = resolved.storey === undefined ? undefined : resolveId(model, resolved.storey, "IfcSpatialElement", "storey");
+        const container = containers(model);
+        return model.byType(resolved.type)
+            .filter((entity) => storey === undefined || container.get(entity.id) === storey)
+            .map((entity) => infoOf(model, entity.id, container.get(entity.id)));
+    }
+    /**
+     * Describes one object of a model: its GlobalId, its type, its name and the spatial element it
+     * stands in.
+     * @param inputs - The model and the object
+     * @returns The object's GlobalId, type, name and the spatial element it stands in
+     * @group query
+     * @shortname element
+     * @drawable false
+     * @example
+     * ```typescript
+     * const wall = await bitbybit.ifc.model.element({ model, element: "north-wall" });
+     * ```
+     */
+    element(inputs) {
+        const model = modelOf(inputs.model);
+        const element = resolveId(model, inputs.element, "IfcRoot", "object");
+        return infoOf(model, element, standingIn(model, element));
+    }
+    /**
+     * Removes an element, an empty storey or space, or a type nothing is of, with what only it uses.
+     * A wall takes its openings with their doors and windows, and the walls it was joined to are
+     * trimmed again; a door or window leaves its opening; an opening takes its doors and windows.
+     * @param inputs - The model and the object
+     * @returns A new model without the object
+     * @group edit
+     * @shortname remove
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.model.remove({ model, element: "partition" });
+     * ```
+     */
+    remove(inputs) {
+        const model = modelOf(inputs.model);
+        const object = resolveId(model, inputs.element, "IfcObjectDefinition", "object");
+        return editModel(model, (tx, writer) => {
+            removeObject(tx, writer, object, lengthTolerance(model), PARALLEL_TOLERANCE);
+        });
+    }
+    /**
+     * Moves an element or a space, and turns it about the vertical through its own origin; what is
+     * placed on it, such as a wall's openings, moves with it. A joined wall moves with `walls.edit`,
+     * and an opening, door or window with `openings.edit`.
+     * @param inputs - The model, the element, how far to move it and how far to turn it
+     * @returns A new model with the element moved
+     * @group edit
+     * @shortname move
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.model.move({ model, element: "column-1", translation: [500, 0, 0], rotation: 45 });
+     * ```
+     */
+    move(inputs) {
+        const resolved = resolveDto(Inputs.IFC.MoveElementDto, inputs);
+        const model = modelOf(resolved.model);
+        requirePoint(resolved.translation, POINT3_SIZE, "translation");
+        requireFinite(resolved.rotation, "rotation in degrees");
+        const element = resolveId(model, resolved.element, "IfcProduct", "element");
+        const storey = storeyOf(model, element);
+        const plan = storey === undefined ? WORLD_AXES : storeyFrame(model, storey);
+        return editModel(model, (tx, writer) => {
+            moveElement(tx, writer, element, vectorToWorld(plan, resolved.translation), resolved.rotation);
+        });
+    }
+    /**
+     * Sets one attribute of an object to a text, a number, true or false, such as a wall's `Name`,
+     * `Description` or `Tag`.
+     *
+     * The value is checked against the IFC schema, and an attribute that holds a reference, a derived
+     * attribute or the `GlobalId` cannot be set this way.
+     * @param inputs - The model, the object, the attribute's name and the new value
+     * @returns A new model with the attribute set
+     * @group edit
+     * @shortname set attribute
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.model.setAttribute({ model, element: "north-wall", attribute: "Description", value: "Load bearing" });
+     * ```
+     */
+    setAttribute(inputs) {
+        const resolved = resolveDto(Inputs.IFC.SetAttributeDto, inputs);
+        const model = modelOf(resolved.model);
+        if (resolved.attribute === "GlobalId") {
+            throw new Error("An object's GlobalId identifies it and cannot be changed");
+        }
+        if (typeof resolved.value !== "string" && typeof resolved.value !== "number" && typeof resolved.value !== "boolean") {
+            throw new TypeError("An attribute is set to a text, a number, or true or false");
+        }
+        const element = resolveId(model, resolved.element, "IfcRoot", "object");
+        return editModel(model, (tx) => tx.update(element, { [resolved.attribute]: resolved.value }));
+    }
+    /**
+     * Reads one attribute of an object, such as a wall's `Name`, `Description` or `Tag`.
+     *
+     * The value comes back as the model holds it: a text, a number, true or false, `null` when the
+     * attribute is unset, `{ enum }` for an enumeration value, `{ type, value }` for a typed value,
+     * `{ ref }` for a reference to another entity, or a list of these.
+     * @param inputs - The model, the object and the attribute's name
+     * @returns The attribute's value
+     * @group query
+     * @shortname get attribute
+     * @drawable false
+     * @example
+     * ```typescript
+     * const description = await bitbybit.ifc.model.getAttribute({ model, element: "north-wall", attribute: "Description" });
+     * ```
+     */
+    getAttribute(inputs) {
+        const resolved = resolveDto(Inputs.IFC.GetAttributeDto, inputs);
+        const model = modelOf(resolved.model);
+        return model.attribute(resolveId(model, resolved.element, "IfcRoot", "object"), resolved.attribute);
+    }
+    /**
+     * Says which GlobalId an id stands for in a model: the GlobalId itself, or the one the model
+     * derives from an id of your own such as `north-wall`.
+     *
+     * The answer does not depend on whether the model holds such an object yet.
+     * @param inputs - The model and the id
+     * @returns The GlobalId, 22 characters
+     * @group query
+     * @shortname global id of
+     * @drawable false
+     * @example
+     * ```typescript
+     * const globalId = await bitbybit.ifc.model.globalIdOf({ model, id: "north-wall" });
+     * ```
+     */
+    globalIdOf(inputs) {
+        const model = modelOf(inputs.model);
+        if (typeof inputs.id !== "string" || inputs.id.length === 0) {
+            throw new TypeError("Expected an id as a text");
+        }
+        return model.byGlobalId(inputs.id) !== undefined ? inputs.id : keyGlobalId(model.keySeed, inputs.id);
+    }
+}

package/lib/api/services/openings.d.ts

@@ -0,0 +1,57 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Openings: voids cut through walls and slabs, the holes doors and windows sit in. Doors and windows
+ * cut their own openings, so this is for an opening that stays empty, such as a pass-through or a
+ * stairwell, and for moving an opening along its wall.
+ * @beta
+ */
+export declare class IFCOpenings {
+    /**
+     * Cuts a rectangular opening through a wall, `offset` along its axis from its start and `sill`
+     * above its base.
+     *
+     * The opening goes through the wall's whole thickness and stays with the wall when its joins
+     * change. It must fit along the wall.
+     * @param inputs - The model, the wall, and the opening's position and size
+     * @returns A new model with the wall cut
+     * @group create
+     * @shortname add opening in wall
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.openings.add({ model, wall: "inner", offset: 1500, width: 1200, height: 2200 });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddOpeningDto<IfcModel>): IfcModel;
+    /**
+     * Moves an opening along its wall or up and down it, or resizes it. Given a door or window, it
+     * moves it with the opening it is in, which keeps its size. A door or window placed elsewhere than
+     * on its opening or wall is refused, as it would stay behind.
+     * @param inputs - The model, the opening or the door or window in it, and its new position or size
+     * @returns A new model with the opening moved or resized
+     * @group edit
+     * @shortname edit opening
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.openings.edit({ model, opening: "front-door", offset: 2500 });
+     * ```
+     */
+    edit(inputs: Inputs.IFC.EditOpeningDto<IfcModel>): IfcModel;
+    /**
+     * Cuts an opening of any outline, such as a stairwell or a shaft, through a slab's whole thickness.
+     * The outline is given in the plan of the slab's storey and must lie inside the slab's outline or on
+     * its edge, which is checked when that outline is a polyline, as in the slabs this library adds.
+     * @param inputs - The model, the slab and the opening's outline
+     * @returns A new model with the slab cut
+     * @group create
+     * @shortname add opening in slab
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.openings.addInSlab({ model, slab: "first-floor", outline: [[1000, 1000], [3500, 1000], [3500, 2200], [1000, 2200]] });
+     * ```
+     */
+    addInSlab(inputs: Inputs.IFC.AddSlabOpeningDto<IfcModel>): IfcModel;
+}

package/lib/api/services/openings.js

@@ -0,0 +1,102 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { WORLD_AXES, pointToLocal, pointToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { requireOutline } from "../../build/checks";
+import { createWallOpening, editWallOpening } from "../../build/openings";
+import { absoluteFrame, objectPlacementOf } from "../../build/placement";
+import { createSlabOpening } from "../../build/slab-openings";
+import { containerOf, storeyFrame } from "../../build/spatial";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, lengthTolerance, modelOf, resolveId } from "./service-support";
+/**
+ * Openings: voids cut through walls and slabs, the holes doors and windows sit in. Doors and windows
+ * cut their own openings, so this is for an opening that stays empty, such as a pass-through or a
+ * stairwell, and for moving an opening along its wall.
+ * @beta
+ */
+export class IFCOpenings {
+    /**
+     * Cuts a rectangular opening through a wall, `offset` along its axis from its start and `sill`
+     * above its base.
+     *
+     * The opening goes through the wall's whole thickness and stays with the wall when its joins
+     * change. It must fit along the wall.
+     * @param inputs - The model, the wall, and the opening's position and size
+     * @returns A new model with the wall cut
+     * @group create
+     * @shortname add opening in wall
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.openings.add({ model, wall: "inner", offset: 1500, width: 1200, height: 2200 });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddOpeningDto, inputs);
+        const model = modelOf(resolved.model);
+        const wall = resolveId(model, resolved.wall, "IfcWall", "wall");
+        return editModel(model, (tx, writer) => {
+            createWallOpening(tx, writer, {
+                wall,
+                id: resolved.id,
+                name: resolved.name,
+                offset: lengthIn(model, resolved.offset, DEFAULT_MILLIMETRES.openingOffset),
+                sill: resolved.sill,
+                width: lengthIn(model, resolved.width, DEFAULT_MILLIMETRES.openingWidth),
+                height: lengthIn(model, resolved.height, DEFAULT_MILLIMETRES.openingHeight),
+            }, lengthTolerance(model));
+        });
+    }
+    /**
+     * Moves an opening along its wall or up and down it, or resizes it. Given a door or window, it
+     * moves it with the opening it is in, which keeps its size. A door or window placed elsewhere than
+     * on its opening or wall is refused, as it would stay behind.
+     * @param inputs - The model, the opening or the door or window in it, and its new position or size
+     * @returns A new model with the opening moved or resized
+     * @group edit
+     * @shortname edit opening
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.openings.edit({ model, opening: "front-door", offset: 2500 });
+     * ```
+     */
+    edit(inputs) {
+        const resolved = resolveDto(Inputs.IFC.EditOpeningDto, inputs);
+        const model = modelOf(resolved.model);
+        const element = resolveId(model, resolved.opening, "IfcElement", "opening");
+        return editModel(model, (tx, writer) => {
+            editWallOpening(tx, writer, element, { offset: resolved.offset, sill: resolved.sill, width: resolved.width, height: resolved.height }, lengthTolerance(model));
+        });
+    }
+    /**
+     * Cuts an opening of any outline, such as a stairwell or a shaft, through a slab's whole thickness.
+     * The outline is given in the plan of the slab's storey and must lie inside the slab's outline or on
+     * its edge, which is checked when that outline is a polyline, as in the slabs this library adds.
+     * @param inputs - The model, the slab and the opening's outline
+     * @returns A new model with the slab cut
+     * @group create
+     * @shortname add opening in slab
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.openings.addInSlab({ model, slab: "first-floor", outline: [[1000, 1000], [3500, 1000], [3500, 2200], [1000, 2200]] });
+     * ```
+     */
+    addInSlab(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddSlabOpeningDto, inputs);
+        const model = modelOf(resolved.model);
+        requireOutline(resolved.outline, "outline");
+        const slab = resolveId(model, resolved.slab, "IfcSlab", "slab");
+        const storey = containerOf(model, slab);
+        const plan = storey === undefined ? WORLD_AXES : storeyFrame(model, storey);
+        const slabFrame = absoluteFrame(model, objectPlacementOf(model, slab));
+        const outline = resolved.outline.map((point) => {
+            const local = pointToLocal(slabFrame, pointToWorld(plan, [point[0], point[1], 0]));
+            return [local[0], local[1]];
+        });
+        return editModel(model, (tx, writer) => {
+            createSlabOpening(tx, writer, { slab, id: resolved.id, name: resolved.name, outline }, lengthTolerance(model));
+        });
+    }
+}

package/lib/api/services/properties.d.ts

@@ -0,0 +1,89 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Properties: named sets of values attached to elements and types, such as `Pset_WallCommon` with
+ * `IsExternal` and `FireRating`, which other tools list, filter and schedule by.
+ * @beta
+ */
+export declare class IFCProperties {
+    /**
+     * Attaches a property set to one or more objects: walls, doors, types or any object with a
+     * GlobalId.
+     *
+     * Each value is written as its `type`, or as a label, an integer, a real or a boolean by the
+     * kind of value. One set is shared by every object it is attached to.
+     * @param inputs - The model, the objects, the set's name and its properties
+     * @returns A new model with the property set
+     * @group properties
+     * @shortname add property set
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.properties.addSet({
+     *     model,
+     *     elements: ["south", "east"],
+     *     name: "Pset_WallCommon",
+     *     properties: [{ name: "IsExternal", value: true }, { name: "FireRating", value: "REI 60" }],
+     * });
+     * ```
+     */
+    addSet(inputs: Inputs.IFC.AddPropertySetDto<IfcModel>): IfcModel;
+    /**
+     * Reads the property sets attached to an object, with each single value by name.
+     *
+     * Values of other kinds of property, such as lists and tables, and logical values that are
+     * unknown are left out.
+     * @param inputs - The model and the object
+     * @returns The object's property sets
+     * @group properties
+     * @shortname get property sets
+     * @drawable false
+     * @example
+     * ```typescript
+     * const sets = await bitbybit.ifc.properties.getSets({ model, element: "south" });
+     * ```
+     */
+    getSets(inputs: Inputs.IFC.ElementDto<IfcModel>): Inputs.IFC.PropertySetInfoDto[];
+    /**
+     * Sets property values of one object, in its property set of the given name, and makes the set
+     * when the object has none. A set the object shares with other objects is copied first, so only
+     * this object's values change.
+     * @param inputs - The model, the object, the set's name and the properties
+     * @returns A new model with the values set
+     * @group properties
+     * @shortname set property values
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.properties.setValues({ model, element: "south", name: "Pset_WallCommon", properties: [{ name: "FireRating", value: "REI 90" }] });
+     * ```
+     */
+    setValues(inputs: Inputs.IFC.SetPropertyValuesDto<IfcModel>): IfcModel;
+    /**
+     * Takes properties out of one object's property set; the set goes when none are left. A set the
+     * object shares with other objects is copied first, so the others keep their values.
+     * @param inputs - The model, the object, the set's name and the names of the properties
+     * @returns A new model without the properties
+     * @group properties
+     * @shortname remove property values
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.properties.removeValues({ model, element: "south", name: "Pset_WallCommon", names: ["FireRating"] });
+     * ```
+     */
+    removeValues(inputs: Inputs.IFC.RemovePropertyValuesDto<IfcModel>): IfcModel;
+    /**
+     * Takes a property set away from one object. Other objects that share the set keep it.
+     * @param inputs - The model, the object and the set's name
+     * @returns A new model without the set on the object
+     * @group properties
+     * @shortname remove property set
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.properties.removeSet({ model, element: "south", name: "Pset_WallCommon" });
+     * ```
+     */
+    removeSet(inputs: Inputs.IFC.RemovePropertySetDto<IfcModel>): IfcModel;
+}