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

package/lib/api/services/windows.js

@@ -0,0 +1,76 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { createFilling, createWindowType } from "../../build/fillings";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, lengthTolerance, modelOf, resolveId } from "./service-support";
+/**
+ * Windows: window types, each a frame around one pane of glass, and windows of those types placed
+ * in walls. A window cuts its own opening and shares its type's geometry, so a type placed many
+ * times is written once.
+ * @beta
+ */
+export class IFCWindows {
+    /**
+     * Adds a window type: a frame around one pane, `width` by `height`, which windows are then
+     * placed from.
+     *
+     * The frame's members are `frameThickness` wide and `frameDepth` deep; the glass sits in the
+     * middle of the depth. A `frameMaterial` and a `glassMaterial` give each part its material and
+     * colour.
+     * @param inputs - The model, the type's id and name, and its sizes
+     * @returns A new model with the window type
+     * @group types
+     * @shortname add window type
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.materials.add({ model, name: "Glass", color: "#a9c7d6", transparency: 0.7 });
+     * model = await bitbybit.ifc.windows.addType({ model, id: "window-120", name: "Window 1200", width: 1200, height: 1400, glassMaterial: "Glass" });
+     * ```
+     */
+    addType(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddWindowTypeDto, inputs);
+        const model = modelOf(resolved.model);
+        const spec = {
+            id: resolved.id,
+            name: resolved.name,
+            width: lengthIn(model, resolved.width, DEFAULT_MILLIMETRES.windowWidth),
+            height: lengthIn(model, resolved.height, DEFAULT_MILLIMETRES.windowHeight),
+            frameThickness: lengthIn(model, resolved.frameThickness, DEFAULT_MILLIMETRES.frameThickness),
+            frameDepth: lengthIn(model, resolved.frameDepth, DEFAULT_MILLIMETRES.frameDepth),
+            glassThickness: lengthIn(model, resolved.glassThickness, DEFAULT_MILLIMETRES.glassThickness),
+            frameMaterial: resolved.frameMaterial,
+            glassMaterial: resolved.glassMaterial,
+        };
+        return editModel(model, (tx, writer) => {
+            createWindowType(tx, writer, spec);
+        });
+    }
+    /**
+     * Places a window of a window type in a wall, `offset` along the wall's axis from its start and
+     * `sill` above its base, cutting an opening as wide and high as the type.
+     *
+     * The window is centred in the wall's thickness and belongs to the wall's storey. It must fit
+     * along the wall.
+     * @param inputs - The model, the wall, the window type, and where the window goes
+     * @returns A new model with the window
+     * @group create
+     * @shortname add window
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.windows.add({ model, wall: "south", windowType: "window-120", offset: 6000, sill: 900 });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddWindowDto, inputs);
+        const model = modelOf(resolved.model);
+        const wall = resolveId(model, resolved.wall, "IfcWall", "wall");
+        const type = resolveId(model, resolved.windowType, "IfcWindowType", "window type");
+        return editModel(model, (tx, writer) => {
+            const offset = lengthIn(model, resolved.offset, DEFAULT_MILLIMETRES.openingOffset);
+            const sill = lengthIn(model, resolved.sill, DEFAULT_MILLIMETRES.windowSill);
+            createFilling(tx, writer, "IfcWindow", { wall, type, id: resolved.id, name: resolved.name, offset, sill }, lengthTolerance(model));
+        });
+    }
+}

package/lib/build/assemblies.d.ts

@@ -0,0 +1,4 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { EntityWriter } from "./entity-writer";
+import type { AssemblySpec } from "./build-types";
+export declare function createAssembly(tx: IfcTransaction, writer: EntityWriter, spec: AssemblySpec): number;

package/lib/build/assemblies.js

@@ -0,0 +1,45 @@
+import { WORLD_AXES } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { enumValue, ref } from "../step/values";
+import { AGGREGATION, CONTAINMENT } from "./constants";
+import { objectPlacementOf } from "./placement";
+import { detach, relate, relatingOf } from "./relationships";
+import { containIn, containerOf, describeObject } from "./spatial";
+const FEATURE_ELEMENT = "IfcFeatureElement";
+function containerOfParts(tx, parts) {
+    const containers = new Set();
+    for (const part of parts) {
+        if (tx.schema.isSubtypeOf(tx.entity(part).type, FEATURE_ELEMENT)) {
+            throw new Error(`${describeObject(tx, part)} cuts or adds to another element, so it cannot be part of an assembly`);
+        }
+        const whole = relatingOf(tx, AGGREGATION, part);
+        if (whole !== undefined) {
+            throw new Error(`${describeObject(tx, part)} is already part of ${describeObject(tx, whole)}`);
+        }
+        const container = containerOf(tx, part);
+        if (container === undefined) {
+            throw new Error(`${describeObject(tx, part)} stands in no storey or other part of the structure, so an assembly of it has nowhere to stand`);
+        }
+        containers.add(container);
+    }
+    if (containers.size !== 1) {
+        throw new Error(`The parts stand in ${containers.size} parts of the structure; an assembly stands in one`);
+    }
+    return [...containers][0];
+}
+export function createAssembly(tx, writer, spec) {
+    var _a, _b;
+    const container = containerOfParts(tx, spec.parts);
+    const assembly = writer.create("IfcElementAssembly", {
+        GlobalId: tx.globalId(spec.id),
+        Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+        ObjectType: (_b = spec.objectType) !== null && _b !== void 0 ? _b : null,
+        ObjectPlacement: ref(writer.localPlacement(objectPlacementOf(tx, container), WORLD_AXES)),
+        PredefinedType: enumValue(spec.predefinedType),
+    });
+    for (const part of spec.parts) {
+        detach(tx, CONTAINMENT, part);
+    }
+    containIn(tx, writer, container, assembly);
+    relate(tx, writer, AGGREGATION, assembly, spec.parts);
+    return assembly;
+}

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

@@ -0,0 +1,345 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { MeshArrays } from "@bitbybit-dev/base/lib/api/services/helpers/helper-types";
+import type { FrameAxes } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import type * as Inputs from "../api/inputs";
+import type { IfcSchema } from "../schema/schema";
+import type { IfcEntity, IfcFileHeader, IfcValue } from "../step/step-types";
+export type Frame3 = FrameAxes;
+export interface Line2 {
+    readonly point: Base.Point2;
+    readonly direction: Base.Vector2;
+}
+export interface EntityReader {
+    entity(id: number): IfcEntity;
+    attribute(id: number, name: string): IfcValue;
+}
+export interface ModelReader extends EntityReader {
+    readonly schema: IfcSchema;
+    get(id: number): IfcEntity | undefined;
+    typeOf(id: number): string | undefined;
+    byType(type: string): IfcEntity[];
+    referencesTo(id: number): readonly number[];
+}
+export interface RelationshipRoles {
+    readonly relationship: string;
+    readonly relating: string;
+    readonly related: string;
+}
+export interface Outline2 {
+    readonly outer: readonly Base.Point2[];
+    readonly holes: readonly (readonly Base.Point2[])[];
+}
+export type MeasuredUnit = "LENGTHUNIT" | "AREAUNIT" | "VOLUMEUNIT" | "PLANEANGLEUNIT";
+export interface NewProject {
+    readonly name: string;
+    readonly siteName: string;
+    readonly buildingName: string;
+    readonly lengthUnit: Inputs.IFC.lengthUnitEnum;
+    readonly seed: string | undefined;
+    readonly header: IfcFileHeader;
+}
+export interface LayerSpec {
+    readonly material: string | undefined;
+    readonly thickness: number;
+    readonly name: string | undefined;
+}
+export interface SurfaceColour {
+    readonly red: number;
+    readonly green: number;
+    readonly blue: number;
+    readonly transparency: number;
+}
+export interface PropertySpec {
+    readonly name: string;
+    readonly value: string | number | boolean;
+    readonly type: string | undefined;
+}
+export interface WallSpec {
+    readonly storey: number;
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly start: Base.Point2;
+    readonly end: Base.Point2;
+    readonly height: number;
+    readonly baseOffset: number;
+    readonly layerSet: number;
+    readonly alignment: Inputs.IFC.wallAlignmentEnum;
+    readonly wallType: number | undefined;
+    readonly predefinedType: string | undefined;
+}
+export type WallEnd = "ATSTART" | "ATEND" | "ATPATH";
+export interface WallGeometry {
+    readonly wall: number;
+    readonly frame: Frame3;
+    readonly start: Base.Point2;
+    readonly end: Base.Point2;
+    readonly direction: Base.Vector2;
+    readonly length: number;
+    readonly low: number;
+    readonly high: number;
+    readonly height: number;
+    readonly base: number;
+    readonly body: number | undefined;
+    readonly usage: number;
+}
+export interface WallCuts {
+    readonly start: Line2 | undefined;
+    readonly end: Line2 | undefined;
+}
+export interface WallJoin {
+    readonly mine: WallEnd;
+    readonly other: number;
+    readonly theirs: WallEnd;
+    readonly relationship: number;
+}
+export interface Meeting {
+    readonly stemEnd: WallEnd;
+    readonly otherEnd: WallEnd;
+    readonly gap: number;
+}
+export interface WallChange {
+    readonly start: Base.Point2 | undefined;
+    readonly end: Base.Point2 | undefined;
+    readonly bottom: number | undefined;
+    readonly height: number | undefined;
+    readonly layerSet: number | undefined;
+    readonly alignment: Inputs.IFC.wallAlignmentEnum | undefined;
+}
+export interface WallBody {
+    readonly height: number;
+    readonly base: number;
+    readonly halfSpaces: readonly number[];
+}
+export interface OpeningChange {
+    readonly offset: number | undefined;
+    readonly sill: number | undefined;
+    readonly width: number | undefined;
+    readonly height: number | undefined;
+}
+export interface SlabOpeningSpec {
+    readonly slab: number;
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly outline: readonly Base.Point2[];
+}
+export interface WallOpeningPlace {
+    readonly opening: number;
+    readonly placement: number;
+    readonly offset: number;
+    readonly sill: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface WallOpeningSpec {
+    readonly wall: number;
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly offset: number;
+    readonly sill: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface WallOpening {
+    readonly opening: number;
+    readonly placement: number;
+    readonly wallFace: number;
+    readonly thickness: number;
+}
+export interface DoorTypeSpec {
+    readonly id: string | undefined;
+    readonly name: string;
+    readonly width: number;
+    readonly height: number;
+    readonly liningThickness: number;
+    readonly liningDepth: number;
+    readonly panelThickness: number;
+    readonly operation: Inputs.IFC.doorOperationEnum;
+    readonly liningMaterial: string | undefined;
+    readonly panelMaterial: string | undefined;
+    readonly handle: Inputs.IFC.doorHandleEnum;
+    readonly handleMaterial: string | undefined;
+    readonly hardware: HandleSizes;
+}
+export interface HandleSizes {
+    readonly inset: number;
+    readonly leverHeight: number;
+    readonly leverStandoff: number;
+    readonly leverSection: number;
+    readonly leverLength: number;
+    readonly pullBarLength: number;
+    readonly pullBarMiddle: number;
+    readonly pullBarStandoff: number;
+    readonly pullBarSection: number;
+    readonly pullBarPost: number;
+    readonly pullBarPostInset: number;
+}
+export interface WindowTypeSpec {
+    readonly id: string | undefined;
+    readonly name: string;
+    readonly width: number;
+    readonly height: number;
+    readonly frameThickness: number;
+    readonly frameDepth: number;
+    readonly glassThickness: number;
+    readonly frameMaterial: string | undefined;
+    readonly glassMaterial: string | undefined;
+}
+export interface TerrainSpec {
+    readonly id: string | undefined;
+    readonly name: string;
+    readonly outline: readonly Base.Point2[];
+    readonly holes: readonly (readonly Base.Point2[])[];
+    readonly depth: number;
+    readonly elevation: number;
+    readonly material: string | undefined;
+}
+export interface AssemblySpec {
+    readonly parts: readonly number[];
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly predefinedType: string;
+    readonly objectType: string | undefined;
+}
+export interface TreeSpec {
+    readonly id: string | undefined;
+    readonly name: string;
+    readonly species: string;
+    readonly position: Base.Point2;
+    readonly elevation: number;
+    readonly height: number;
+    readonly crownRadius: number;
+    readonly trunkRadius: number;
+    readonly crownMaterial: string | undefined;
+    readonly trunkMaterial: string | undefined;
+}
+export interface CrownMesh {
+    readonly mesh: MeshArrays;
+    readonly centre: number;
+}
+export interface MaterialPart {
+    readonly name: string;
+    readonly items: readonly number[];
+    readonly material: string | undefined;
+}
+export interface FillingSpec {
+    readonly wall: number;
+    readonly type: number;
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly offset: number;
+    readonly sill: number;
+}
+export interface TypeBounds {
+    readonly min: Base.Point3;
+    readonly max: Base.Point3;
+}
+export interface RectangleProfile {
+    readonly kind: Inputs.IFC.profileKindEnum.rectangle;
+    readonly width: number;
+    readonly depth: number;
+}
+export interface CircleProfile {
+    readonly kind: Inputs.IFC.profileKindEnum.circle;
+    readonly radius: number;
+}
+export interface IShapeProfile {
+    readonly kind: Inputs.IFC.profileKindEnum.iShape;
+    readonly width: number;
+    readonly depth: number;
+    readonly webThickness: number;
+    readonly flangeThickness: number;
+}
+export type ProfileSpec = RectangleProfile | CircleProfile | IShapeProfile;
+export interface SpaceSpec {
+    readonly storey: number;
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly longName: string | undefined;
+    readonly outline: readonly Base.Point2[];
+    readonly height: number;
+    readonly baseOffset: number;
+    readonly predefinedType: string;
+}
+export interface RoofSpec {
+    readonly storey: number;
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly outline: readonly Base.Point2[];
+    readonly kind: Inputs.IFC.roofKindEnum;
+    readonly pitch: number;
+    readonly layerSet: number;
+    readonly overhang: number;
+    readonly baseOffset: number;
+}
+export interface RoofPlane {
+    readonly origin: Base.Point2;
+    readonly along: Base.Vector2;
+    readonly inward: Base.Vector2;
+    readonly outline: readonly Base.Point2[];
+}
+export interface Linear2 {
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+}
+export interface Bounds {
+    readonly tops: readonly Linear2[];
+    readonly bottoms: readonly Linear2[];
+    readonly sides: readonly Linear2[];
+}
+export interface BoundPair {
+    readonly top: Linear2;
+    readonly bottom: Linear2;
+    readonly keeps: readonly Linear2[];
+}
+export interface ProfileShape {
+    readonly area: number;
+    readonly perimeter: number;
+    readonly outline: readonly Base.Point2[] | undefined;
+}
+export interface Plane3 {
+    readonly origin: Base.Point3;
+    readonly normal: Base.Vector3;
+}
+export type QuantityKind = "length" | "area" | "volume";
+export interface MeasuredQuantity {
+    readonly name: string;
+    readonly kind: QuantityKind;
+    readonly value: number;
+}
+export interface MeasuredSet {
+    readonly name: string;
+    readonly quantities: readonly MeasuredQuantity[];
+}
+export interface ExtrudedBody {
+    readonly solid: number;
+    readonly frame: Frame3;
+    readonly depth: number;
+    readonly shape: ProfileShape;
+}
+export interface SlabSpec {
+    readonly storey: number;
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly outline: readonly Base.Point2[];
+    readonly holes: readonly (readonly Base.Point2[])[];
+    readonly layerSet: number;
+    readonly topOffset: number;
+    readonly predefinedType: string;
+}
+export interface MemberSpec {
+    readonly storey: number;
+    readonly id: string | undefined;
+    readonly name: string | undefined;
+    readonly start: Base.Point3;
+    readonly end: Base.Point3;
+    readonly profile: ProfileSpec;
+    readonly rotation: number;
+    readonly material: number | undefined;
+    readonly predefinedType: string;
+}
+export interface ContextKey {
+    readonly contextType: string;
+    readonly identifier: string;
+    readonly view: string;
+}

package/lib/build/build-types.js

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

package/lib/build/checks.d.ts

@@ -0,0 +1,6 @@
+import type { EntityReader } from "./build-types";
+export declare function requirePoint(point: unknown, size: number, what: string): void;
+export declare function requireOutline(points: unknown, what: string): void;
+export declare function requirePositive(value: number, what: string): void;
+export declare function requireFinite(value: number, what: string): void;
+export declare function requiredReference(reader: EntityReader, id: number, attribute: string): number;

package/lib/build/checks.js

@@ -0,0 +1,32 @@
+import { isReference } from "../step/values";
+import { MIN_OUTLINE_POINTS, POINT2_SIZE } from "./constants";
+const COUNT_WORDS = ["no", "one", "two", "three"];
+export function requirePoint(point, size, what) {
+    var _a;
+    if (!Array.isArray(point) || point.length !== size || !point.every(Number.isFinite)) {
+        throw new TypeError(`The ${what} must be ${(_a = COUNT_WORDS[size]) !== null && _a !== void 0 ? _a : size} finite numbers`);
+    }
+}
+export function requireOutline(points, what) {
+    if (!Array.isArray(points) || points.length < MIN_OUTLINE_POINTS) {
+        throw new TypeError(`The ${what} must be a list of at least ${MIN_OUTLINE_POINTS} [x, y] points`);
+    }
+    points.forEach((point, index) => requirePoint(point, POINT2_SIZE, `${what}'s point ${index}`));
+}
+export function requirePositive(value, what) {
+    if (!(value > 0) || !Number.isFinite(value)) {
+        throw new RangeError(`The ${what} must be more than zero, got ${value}`);
+    }
+}
+export function requireFinite(value, what) {
+    if (!Number.isFinite(value)) {
+        throw new RangeError(`The ${what} must be a finite number, got ${value}`);
+    }
+}
+export function requiredReference(reader, id, attribute) {
+    const value = reader.attribute(id, attribute);
+    if (!isReference(value)) {
+        throw new Error(`#${id} has no ${attribute}`);
+    }
+    return value.ref;
+}

package/lib/build/constants.d.ts

@@ -0,0 +1,27 @@
+import type { RelationshipRoles } from "./build-types";
+export declare const DEFAULT_PRECISION_METRES = 0.00001;
+export declare const METRES_TO_MILLIMETRES = 1000;
+export declare const LENGTH_PREFIXES: Readonly<Record<string, number>>;
+export declare const GEOMETRY_TOLERANCE_METRES = 0.000001;
+export declare const PARALLEL_TOLERANCE = 1e-9;
+export declare const OPENING_MARGIN_RATIO = 0.25;
+export declare const DEGREES_TO_RADIANS: number;
+export declare const VERTICAL_COSINE: number;
+export declare const POINT2_SIZE = 2;
+export declare const POINT3_SIZE = 3;
+export declare const TRIANGLE_CORNERS = 3;
+export declare const MIN_OUTLINE_POINTS = 3;
+export declare const CONTAINMENT: RelationshipRoles;
+export declare const MATERIAL_ASSOCIATION: RelationshipRoles;
+export declare const TYPE_DEFINITION: RelationshipRoles;
+export declare const AGGREGATION: RelationshipRoles;
+export declare const DECLARATION: RelationshipRoles;
+export declare const PROPERTY_DEFINITION: RelationshipRoles;
+export declare const VOIDING: RelationshipRoles;
+export declare const FILLING: RelationshipRoles;
+export declare const WALL_CONNECTION = "IfcRelConnectsPathElements";
+export declare const WALL_ENDS: readonly ["ATSTART", "ATEND", "ATPATH"];
+export declare const MINUTES_PER_DEGREE = 60;
+export declare const SECONDS_PER_DEGREE = 3600;
+export declare const MILLIONTHS_PER_SECOND = 1000000;
+export declare const COMPOUND_ANGLE_PARTS = 3;

package/lib/build/constants.js

@@ -0,0 +1,43 @@
+export const DEFAULT_PRECISION_METRES = 1e-5;
+export const METRES_TO_MILLIMETRES = 1000;
+export const LENGTH_PREFIXES = {
+    EXA: 1e18,
+    PETA: 1e15,
+    TERA: 1e12,
+    GIGA: 1e9,
+    MEGA: 1e6,
+    KILO: 1e3,
+    HECTO: 1e2,
+    DECA: 1e1,
+    DECI: 1e-1,
+    CENTI: 1e-2,
+    MILLI: 1e-3,
+    MICRO: 1e-6,
+    NANO: 1e-9,
+    PICO: 1e-12,
+    FEMTO: 1e-15,
+    ATTO: 1e-18,
+};
+export const GEOMETRY_TOLERANCE_METRES = 1e-6;
+export const PARALLEL_TOLERANCE = 1e-9;
+export const OPENING_MARGIN_RATIO = 0.25;
+export const DEGREES_TO_RADIANS = Math.PI / 180;
+export const VERTICAL_COSINE = 1 - 1e-9;
+export const POINT2_SIZE = 2;
+export const POINT3_SIZE = 3;
+export const TRIANGLE_CORNERS = 3;
+export const MIN_OUTLINE_POINTS = 3;
+export const CONTAINMENT = { relationship: "IfcRelContainedInSpatialStructure", relating: "RelatingStructure", related: "RelatedElements" };
+export const MATERIAL_ASSOCIATION = { relationship: "IfcRelAssociatesMaterial", relating: "RelatingMaterial", related: "RelatedObjects" };
+export const TYPE_DEFINITION = { relationship: "IfcRelDefinesByType", relating: "RelatingType", related: "RelatedObjects" };
+export const AGGREGATION = { relationship: "IfcRelAggregates", relating: "RelatingObject", related: "RelatedObjects" };
+export const DECLARATION = { relationship: "IfcRelDeclares", relating: "RelatingContext", related: "RelatedDefinitions" };
+export const PROPERTY_DEFINITION = { relationship: "IfcRelDefinesByProperties", relating: "RelatingPropertyDefinition", related: "RelatedObjects" };
+export const VOIDING = { relationship: "IfcRelVoidsElement", relating: "RelatingBuildingElement", related: "RelatedOpeningElement" };
+export const FILLING = { relationship: "IfcRelFillsElement", relating: "RelatingOpeningElement", related: "RelatedBuildingElement" };
+export const WALL_CONNECTION = "IfcRelConnectsPathElements";
+export const WALL_ENDS = ["ATSTART", "ATEND", "ATPATH"];
+export const MINUTES_PER_DEGREE = 60;
+export const SECONDS_PER_DEGREE = 3600;
+export const MILLIONTHS_PER_SECOND = 1e6;
+export const COMPOUND_ANGLE_PARTS = 3;

package/lib/build/contexts.d.ts

@@ -0,0 +1,9 @@
+import type { IfcTransaction } from "../model/transaction";
+import type { ContextKey, ModelReader } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare const BODY_CONTEXT: ContextKey;
+export declare const AXIS_CONTEXT: ContextKey;
+export declare function findContext(reader: ModelReader, key: ContextKey): number | undefined;
+export declare function contextFor(tx: IfcTransaction, writer: EntityWriter, key: ContextKey): number;
+export declare function bodyContext(tx: IfcTransaction, writer: EntityWriter): number;
+export declare function axisContext(tx: IfcTransaction, writer: EntityWriter): number;

package/lib/build/contexts.js

@@ -0,0 +1,52 @@
+import { enumValue, isEnumeration, isReference, ref } from "../step/values";
+export const BODY_CONTEXT = { contextType: "Model", identifier: "Body", view: "MODEL_VIEW" };
+export const AXIS_CONTEXT = { contextType: "Plan", identifier: "Axis", view: "GRAPH_VIEW" };
+const SUB_CONTEXT = "IfcGeometricRepresentationSubContext";
+const known = new WeakMap();
+function parentType(reader, context) {
+    const parent = reader.attribute(context, "ParentContext");
+    return isReference(parent) ? reader.attribute(parent.ref, "ContextType") : undefined;
+}
+export function findContext(reader, key) {
+    var _a;
+    const candidates = reader.byType(SUB_CONTEXT).filter((context) => reader.attribute(context.id, "ContextIdentifier") === key.identifier);
+    const exact = candidates.find((context) => {
+        const view = reader.attribute(context.id, "TargetView");
+        return isEnumeration(view) && view.enum === key.view && parentType(reader, context.id) === key.contextType;
+    });
+    return (_a = (exact !== null && exact !== void 0 ? exact : candidates[0])) === null || _a === void 0 ? void 0 : _a.id;
+}
+function createContext(tx, writer, key) {
+    var _a;
+    const parents = tx.byType("IfcGeometricRepresentationContext").filter((context) => context.type === "IfcGeometricRepresentationContext");
+    const parent = (_a = parents.find((context) => tx.attribute(context.id, "ContextType") === key.contextType)) !== null && _a !== void 0 ? _a : parents.find((context) => tx.attribute(context.id, "ContextType") === BODY_CONTEXT.contextType);
+    if (!parent) {
+        throw new Error(`The model has no geometric representation context to hold its ${key.identifier} representations`);
+    }
+    return writer.create(SUB_CONTEXT, {
+        ContextIdentifier: key.identifier,
+        ContextType: tx.attribute(parent.id, "ContextType"),
+        ParentContext: ref(parent.id),
+        TargetView: enumValue(key.view),
+    });
+}
+export function contextFor(tx, writer, key) {
+    var _a;
+    let contexts = known.get(tx);
+    if (!contexts) {
+        contexts = new Map();
+        known.set(tx, contexts);
+    }
+    let context = contexts.get(key);
+    if (context === undefined) {
+        context = (_a = findContext(tx, key)) !== null && _a !== void 0 ? _a : createContext(tx, writer, key);
+        contexts.set(key, context);
+    }
+    return context;
+}
+export function bodyContext(tx, writer) {
+    return contextFor(tx, writer, BODY_CONTEXT);
+}
+export function axisContext(tx, writer) {
+    return contextFor(tx, writer, AXIS_CONTEXT);
+}

package/lib/build/curves.d.ts

@@ -0,0 +1,3 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { ModelReader } from "./build-types";
+export declare function polylinePoints(reader: ModelReader, curve: number): Base.Point2[] | undefined;

package/lib/build/curves.js

@@ -0,0 +1,23 @@
+import { isList } from "../step/values";
+import { requiredReference } from "./checks";
+import { numbersOf, pointOf } from "./placement";
+export function polylinePoints(reader, curve) {
+    const type = reader.entity(curve).type;
+    if (type === "IfcIndexedPolyCurve") {
+        const list = requiredReference(reader, curve, "Points");
+        const coordinates = reader.attribute(list, "CoordList");
+        return (isList(coordinates) ? coordinates : []).map((item, index) => {
+            var _a, _b;
+            const numbers = numbersOf(item, `#${list} point ${index}`);
+            return [(_a = numbers[0]) !== null && _a !== void 0 ? _a : 0, (_b = numbers[1]) !== null && _b !== void 0 ? _b : 0];
+        });
+    }
+    if (type === "IfcPolyline") {
+        const list = reader.attribute(curve, "Points");
+        return (isList(list) ? list : []).map((item) => {
+            const point = pointOf(reader, item);
+            return [point[0], point[1]];
+        });
+    }
+    return undefined;
+}