@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/wall/parametrics.d.ts

@@ -1,4 +1,4 @@
-import type { ParametricDescriptor } from '@pascal-app/core';
+import { type ParametricDescriptor } from '@pascal-app/core';
 import type { WallNode } from './schema.js';
 /**
  * Inspector descriptor for wall.

package/dist/wall/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/wall/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAsB1D,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/wall/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACpF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAmC1D,CAAA"}

package/dist/wall/parametrics.js

@@ -1,3 +1,4 @@
+import { DEFAULT_WALL_THICKNESS } from '@pascal-app/core';
 /**
  * Inspector descriptor for wall.
  *
@@ -18,7 +19,19 @@ export const wallParametrics = {
                 // Reference is not a raw field: its labels depend on each wall's rooms
                 // (`wallReferenceModel` in panel-model), so generic inspectors never
                 // show the stored a / b value.
-                { key: 'thickness', kind: 'number', unit: 'm', min: 0.05, max: 1000, step: 0.01 },
+                // An assembly owns the thickness (the sum of its layers), so the field
+                // edits only walls without one; those read it from the panel model's
+                // readout instead of typing over it. A railing's posts set its thickness.
+                {
+                    key: 'thickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.05,
+                    max: 1000,
+                    step: 0.01,
+                    default: DEFAULT_WALL_THICKNESS,
+                    appliesTo: (wall) => wall.wallType !== 'railing' && (!wall.assembly || wall.wallType === 'curtain'),
+                },
                 // `height` may be absent (plane-bound top); the custom panel owns the
                 // Follows storey / Custom height mode switch, so this is metadata only.
                 { key: 'height', kind: 'number', unit: 'm', min: 0.1, max: 1000, step: 0.05 },

package/dist/wall/quick-measurement.js

@@ -2,7 +2,7 @@ import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, useScene, }
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
 export function wallQuickMeasurement(node) {
     const length = getWallCurveLength(node);
-    const height = resolveWallOpeningCeiling(node, useScene.getState().nodes);
+    const height = resolveWallOpeningCeiling(node, useScene.getState().nodes, 0.5);
     const frame = getWallCurveFrameAt(node, 0.5);
     return {
         title: node.name ?? 'Wall',

package/dist/wall/railing-wall-adapter.d.ts

@@ -0,0 +1,7 @@
+import type { WallGeometryAdapter } from '@pascal-app/viewer';
+/**
+ * `adapter` with railing walls built as their guard (`railing-wall-geometry.ts`) instead of a
+ * solid body. A railing is never cut: its doors are the gaps its guard leaves.
+ */
+export declare function withRailingWalls(adapter: WallGeometryAdapter): WallGeometryAdapter;
+//# sourceMappingURL=railing-wall-adapter.d.ts.map

package/dist/wall/railing-wall-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"railing-wall-adapter.d.ts","sourceRoot":"","sources":["../../src/wall/railing-wall-adapter.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAc7D;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,mBAAmB,CAmBlF"}

package/dist/wall/railing-wall-adapter.js

@@ -0,0 +1,38 @@
+import { getEffectiveNode, isRailingWall, useScene, } from '@pascal-app/core';
+import { buildRailingWallGeometry } from './railing-wall-geometry.js';
+/** The walls of a railing's level as they stand live: the walls its ends may die into. */
+function levelWalls(wall) {
+    const nodes = useScene.getState().nodes;
+    const level = wall.parentId ? nodes[wall.parentId] : undefined;
+    if (level?.type !== 'level')
+        return [];
+    return level.children.flatMap((id) => {
+        const node = nodes[id];
+        return node?.type === 'wall' ? [getEffectiveNode(node)] : [];
+    });
+}
+/**
+ * `adapter` with railing walls built as their guard (`railing-wall-geometry.ts`) instead of a
+ * solid body. A railing is never cut: its doors are the gaps its guard leaves.
+ */
+export function withRailingWalls(adapter) {
+    return {
+        prepareChildren(wall, children, context) {
+            if (isRailingWall(wall))
+                return { envelopeChildren: [], renderChildren: [...children] };
+            return (adapter.prepareChildren?.(wall, children, context) ?? {
+                envelopeChildren: [...children],
+                renderChildren: [...children],
+            });
+        },
+        buildGeometry(wall, envelope, children) {
+            if (isRailingWall(wall))
+                return buildRailingWallGeometry(wall, children, levelWalls(wall));
+            return adapter.buildGeometry?.(wall, envelope, children) ?? envelope;
+        },
+        syncAuxiliaryGeometry(wall, mesh, geometry) {
+            if (!isRailingWall(wall))
+                adapter.syncAuxiliaryGeometry?.(wall, mesh, geometry);
+        },
+    };
+}

package/dist/wall/railing-wall-floorplan.d.ts

@@ -0,0 +1,8 @@
+import { type AnyNode, type FloorplanGeometry, type WallNode } from '@pascal-app/core';
+/**
+ * A railing's posts in plan: a small square at each post the guard stands
+ * (`railing-wall-guard.ts`), inside the thin, unfilled outline the wall builder draws. `walls`
+ * are the level's, read for the ends that die into a wall.
+ */
+export declare function buildRailingWallFloorplan(wall: WallNode, children: readonly AnyNode[], walls: readonly WallNode[], stroke: string): FloorplanGeometry[];
+//# sourceMappingURL=railing-wall-floorplan.d.ts.map

package/dist/wall/railing-wall-floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"railing-wall-floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/railing-wall-floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,iBAAiB,EAEtB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,MAAM,EAAE,MAAM,GACb,iBAAiB,EAAE,CAqBrB"}

package/dist/wall/railing-wall-floorplan.js

@@ -0,0 +1,27 @@
+import { getRailingWallConfig, } from '@pascal-app/core';
+import { buildRailingWallGuard } from './railing-wall-guard.js';
+/**
+ * A railing's posts in plan: a small square at each post the guard stands
+ * (`railing-wall-guard.ts`), inside the thin, unfilled outline the wall builder draws. `walls`
+ * are the level's, read for the ends that die into a wall.
+ */
+export function buildRailingWallFloorplan(wall, children, walls, stroke) {
+    const half = getRailingWallConfig(wall).postSize / 2;
+    const angle = Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
+    // The posts stand square to the wall's chord, as in 3D.
+    const along = [Math.cos(angle) * half, Math.sin(angle) * half];
+    const across = [-along[1], along[0]];
+    return buildRailingWallGuard(wall, children, walls, 'plan').posts.map(([x, , z]) => ({
+        kind: 'polygon',
+        points: [
+            [x - along[0] - across[0], z - along[1] - across[1]],
+            [x + along[0] - across[0], z + along[1] - across[1]],
+            [x + along[0] + across[0], z + along[1] + across[1]],
+            [x - along[0] + across[0], z - along[1] + across[1]],
+        ],
+        fill: stroke,
+        stroke,
+        strokeWidth: 0.004,
+        pointerEvents: 'none',
+    }));
+}

package/dist/wall/railing-wall-geometry.d.ts

@@ -0,0 +1,12 @@
+import type { AnyNode, WallNode } from '@pascal-app/core';
+import { BufferGeometry } from 'three';
+/** The railing mesh's palette: its posts, rails and caps, then its infill (`wallSlots`). */
+export declare const RAILING_FRAME_MATERIAL_INDEX = 0;
+export declare const RAILING_INFILL_MATERIAL_INDEX = 1;
+/**
+ * A railing wall's mesh in the wall's frame (`railing-wall-guard.ts`), from its floor at y 0: the
+ * posts, rails and caps in group 0 and the infill (balusters, boards, cables, glass) in group 1,
+ * so each takes its own slot. `walls` are the level's, read for the ends that die into a wall.
+ */
+export declare function buildRailingWallGeometry(wall: WallNode, children: readonly AnyNode[], walls: readonly WallNode[]): BufferGeometry;
+//# sourceMappingURL=railing-wall-geometry.d.ts.map

package/dist/wall/railing-wall-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"railing-wall-geometry.d.ts","sourceRoot":"","sources":["../../src/wall/railing-wall-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACzD,OAAO,EAAE,cAAc,EAA0B,MAAM,OAAO,CAAA;AAM9D,4FAA4F;AAC5F,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAC7C,eAAO,MAAM,6BAA6B,IAAI,CAAA;AAsB9C;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,KAAK,EAAE,SAAS,QAAQ,EAAE,GACzB,cAAc,CAkBhB"}

package/dist/wall/railing-wall-geometry.js

@@ -0,0 +1,51 @@
+import { BufferGeometry, Float32BufferAttribute } from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { guardBoxGeometry } from '../stair/baluster-geometry.js';
+import { buildRailingWallGuard } from './railing-wall-guard.js';
+/** The railing mesh's palette: its posts, rails and caps, then its infill (`wallSlots`). */
+export const RAILING_FRAME_MATERIAL_INDEX = 0;
+export const RAILING_INFILL_MATERIAL_INDEX = 1;
+function boxesGeometry(boxes) {
+    if (boxes.length === 0)
+        return null;
+    const parts = boxes.map(guardBoxGeometry);
+    const merged = mergeGeometries(parts, false);
+    for (const part of parts)
+        part.dispose();
+    return merged;
+}
+function emptyGeometry() {
+    const geometry = new BufferGeometry();
+    for (const [name, size] of [
+        ['position', 3],
+        ['normal', 3],
+        ['uv', 2],
+        ['uv2', 2],
+    ])
+        geometry.setAttribute(name, new Float32BufferAttribute([], size));
+    return geometry;
+}
+/**
+ * A railing wall's mesh in the wall's frame (`railing-wall-guard.ts`), from its floor at y 0: the
+ * posts, rails and caps in group 0 and the infill (balusters, boards, cables, glass) in group 1,
+ * so each takes its own slot. `walls` are the level's, read for the ends that die into a wall.
+ */
+export function buildRailingWallGeometry(wall, children, walls) {
+    const guard = buildRailingWallGuard(wall, children, walls, 'local');
+    const parts = [
+        { geometry: boxesGeometry(guard.frame), materialIndex: RAILING_FRAME_MATERIAL_INDEX },
+        { geometry: boxesGeometry(guard.infill), materialIndex: RAILING_INFILL_MATERIAL_INDEX },
+    ].filter((part) => !!part.geometry);
+    if (parts.length === 0)
+        return emptyGeometry();
+    const merged = mergeGeometries(parts.map((part) => part.geometry), true);
+    for (const part of parts)
+        part.geometry.dispose();
+    if (!merged)
+        return emptyGeometry();
+    // `mergeGeometries` numbers its groups by input; give each its slot's palette entry.
+    merged.groups.forEach((group, index) => {
+        group.materialIndex = parts[index].materialIndex;
+    });
+    return merged;
+}

package/dist/wall/railing-wall-guard.d.ts

@@ -0,0 +1,81 @@
+/**
+ * A railing wall's guard (`wallType: 'railing'`) as pure data: where it runs, where its posts
+ * stand, and its members as oriented boxes. It is laid out on the stair guards' chassis
+ * (`stair/guard-path.ts`): the same path sampling, equally spaced posts and rail joinery, with the
+ * stair styles' members (`stair/*-guard.ts`) stood on a level floor and sized by the railing's
+ * config. The 3D builder (`railing-wall-geometry.ts`) turns the boxes into the wall's mesh and the
+ * plan (`railing-wall-floorplan.ts`) draws the posts, so both show the same guard.
+ *
+ * The guard runs along the wall's body centreline from the floor up to the wall's height. A door
+ * on the railing is a gap in it: the guard stops either side with a post whose face is on the
+ * gap's edge, so the gap is the door's width clear. An end that dies into a solid wall has no post:
+ * the rails run on into the wall. Every other end, and every
+ * corner where two railings meet, has its post centred on the wall's end. Between the ends the
+ * posts are equally spaced at most `postSpacing` apart, and the balusters of each bay equally
+ * spaced at most `infillGap` clear.
+ */
+import { type AnyNode, type RailingWallConfig, type WallNode } from '@pascal-app/core';
+import { type GuardBox, type Vec3 } from '../stair/guard-path.js';
+/**
+ * A stretch of a railing's guard, `from` to `to` metres along the wall: whether a post stands at
+ * each end, and whether that end faces a gap (a door), where the cap stops flush with the post.
+ */
+export type RailingRun = {
+    from: number;
+    to: number;
+    startPost: boolean;
+    endPost: boolean;
+    startGap: boolean;
+    endGap: boolean;
+};
+/** How a run ends (`RailingRun` without its stretch). */
+export type RailingRunEnds = Omit<RailingRun, 'from' | 'to'>;
+/** A railing's guard: its frame (posts, rails, caps), its infill, and where its posts stand. */
+export type RailingGuard = {
+    frame: GuardBox[];
+    infill: GuardBox[];
+    posts: Vec3[];
+};
+/** The frame the guard's points are given in: the wall's mesh frame, or the level's plan. */
+export type RailingFrame = 'local' | 'plan';
+/**
+ * The doors (and any window) a railing hosts as gaps along it, `[from, to]` metres from its
+ * start, clipped to the wall, merged where they touch, in order.
+ */
+export declare function railingWallGaps(wall: WallNode, children: readonly AnyNode[]): Array<[number, number]>;
+/**
+ * Which ends of a railing die into a solid wall among `walls` (its level's): a railing run up to
+ * the house stops in its wall with no post, its rails carried into it.
+ */
+export declare function railingWallEndsAtWalls(wall: WallNode, walls: readonly WallNode[]): {
+    start: boolean;
+    end: boolean;
+};
+/**
+ * The runs of a railing's guard over its `length`: the wall less its `gaps`, a post either side
+ * of each gap with its face on the gap's edge, and none at an end that dies into a wall
+ * (`atWall`). A stretch shorter than a post holds no guard.
+ */
+export declare function railingWallRuns(length: number, gaps: ReadonlyArray<readonly [number, number]>, postSize: number, atWall: {
+    start: boolean;
+    end: boolean;
+}): RailingRun[];
+/**
+ * Points along a railing's body centreline from `from` to `to` metres along it, on its floor: in
+ * the wall's mesh frame (x along its chord from its start, z toward face `a`) or in plan (level x
+ * and z). A curve is sampled finely enough for its rails to read as one.
+ */
+export declare function railingRunPoints(wall: WallNode, from: number, to: number, frame: RailingFrame): Vec3[];
+/**
+ * One run of a railing's guard along `points` (on the floor, bottom first), `height` tall, built
+ * as `config` says, with or without a post at either end (`ends`).
+ */
+export declare function buildRailingRunGuard(points: Vec3[], config: RailingWallConfig, height: number, ends?: RailingRunEnds): RailingGuard;
+/**
+ * A railing wall's runs: its length less the doors it hosts, with no post at an end that dies
+ * into one of `walls` (its level's).
+ */
+export declare function railingWallLayout(wall: WallNode, children: readonly AnyNode[], walls: readonly WallNode[]): RailingRun[];
+/** A railing wall's whole guard, in its mesh frame or in plan (`railingWallLayout`). */
+export declare function buildRailingWallGuard(wall: WallNode, children: readonly AnyNode[], walls: readonly WallNode[], frame?: RailingFrame): RailingGuard;
+//# sourceMappingURL=railing-wall-guard.d.ts.map

package/dist/wall/railing-wall-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"railing-wall-guard.d.ts","sourceRoot":"","sources":["../../src/wall/railing-wall-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,OAAO,EAUZ,KAAK,iBAAiB,EAEtB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,QAAQ,EAQb,KAAK,IAAI,EACV,MAAM,qBAAqB,CAAA;AAuC5B;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,yDAAyD;AACzD,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;AAE5D,gGAAgG;AAChG,MAAM,MAAM,YAAY,GAAG;IAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAAC,MAAM,EAAE,QAAQ,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAA;AAEnF,6FAA6F;AAC7F,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,CAAA;AAE3C;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAmBzB;AAgCD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,QAAQ,EAAE,GACzB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,CAQlC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GACvC,UAAU,EAAE,CAwBd;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,YAAY,GAClB,IAAI,EAAE,CAuBR;AAmID;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,IAAI,EAAE,EACd,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,cAA0B,GAC/B,YAAY,CA+Hd;AAeD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,KAAK,EAAE,SAAS,QAAQ,EAAE,GACzB,UAAU,EAAE,CAQd;AAED,wFAAwF;AACxF,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,KAAK,GAAE,YAAsB,GAC5B,YAAY,CAgBd"}