@ahrowe/ui 0.26.0 → 0.27.0

package/dist/types/package/common/floorPlan/floorPlan.graph.d.ts

@@ -94,6 +94,51 @@ export interface DissolveNodeOptions {
 export declare function dissolveNode(floor: PlanFloor, nodeId: string, options?: DissolveNodeOptions): PlanEdit<{
     wallId: string;
 } | null>;
+export interface DetachWallResult {
+    /** The wall's end nodes after the detach, in `[a, b]` order. */
+    nodeIds: [string, string];
+    /** Connecting walls minted where an end was shared with a neighbour. */
+    connectorIds: string[];
+    /** Ends that became a straight seam once the wall left, and were dissolved away. */
+    dissolvedNodeIds: string[];
+}
+/**
+ * Pulls a wall off the nodes it shares with its neighbours and moves it by `delta`,
+ * leaving a connecting wall behind at each end that was shared.
+ *
+ * This is the extrude half of dragging a wall. A plain drag moves the shared end nodes,
+ * so everything meeting the wall follows it; here the neighbours keep their ends and
+ * only the new connectors grow, which is what you want when a partition joins the wall
+ * halfway along and should stay put.
+ *
+ * A free end is only moved: there is nothing there to detach from, and a connector would
+ * be zero length. For the same reason `delta` must be at least `MIN_WALL_LENGTH` long —
+ * below that the caller should `moveNode` both ends instead.
+ *
+ * The connector continues whatever was already at the corner (its thickness, type and
+ * heights) when exactly one wall was, so pulling a wall off a plain corner redraws
+ * exactly as a plain drag would: the seam that leaves behind is straight and is
+ * dissolved before returning. At a junction there is no single wall to continue, so the
+ * connector takes the dragged wall's own construction.
+ */
+export declare function detachWall(floor: PlanFloor, wallId: string, delta: PlanPoint): PlanEdit<DetachWallResult | null>;
+/**
+ * Collapses every wall shorter than `minLength` by merging its two ends together.
+ *
+ * Squashing a wall to nothing is the one thing a drag can do that the model forbids, and
+ * it is easy to do by accident: pushing a wall back onto the line it was detached from,
+ * or dragging a corner past the one next to it. Deleting the short wall is the wrong
+ * repair — it leaves two nodes sitting on the same point with the plan split between
+ * them, which reads as two corners stacked on top of each other and derives as two
+ * rooms. Merging is lossless, since the two ends are within `minLength` of each other by
+ * definition.
+ *
+ * The end with more walls on it survives, so the corner that was already there keeps its
+ * position and the one that arrived is the one that gives way.
+ */
+export declare function weldShortWalls(floor: PlanFloor, minLength?: number): PlanEdit<{
+    weldedWallIds: string[];
+}>;
 export declare function removeWall(floor: PlanFloor, wallId: string, opts?: {
     pruneOrphanNodes?: boolean;
     dissolveCollinear?: boolean;

package/dist/types/package/common/floorPlan/floorPlan.mesh.d.ts

@@ -0,0 +1,36 @@
+import { PlanFloor } from './floorPlan.types';
+export type PlanMeshPart = 'wall' | 'floor';
+export interface PlanMeshGroup {
+    part: PlanMeshPart;
+    /** Offset into `indices`, and how many of them. Draw ranges, or assign materials. */
+    start: number;
+    count: number;
+}
+export interface PlanMesh {
+    /** World-space xyz triples, in millimetres. */
+    positions: Float32Array;
+    /** Unit face normals, one per vertex. */
+    normals: Float32Array;
+    indices: Uint32Array;
+    groups: PlanMeshGroup[];
+}
+export interface BuildPlanMeshOptions {
+    /** Storey height for walls that do not carry their own. Defaults to the floor's. */
+    wallHeight?: number;
+    /** Lay a slab under each room. Default true. */
+    includeFloorSlab?: boolean;
+    /** Millimetres. The slab hangs below the floor level. Default 200. */
+    slabThickness?: number;
+    /**
+     * Lift everything by the floor's own elevation, so several storeys stack into one
+     * scene. Default true.
+     */
+    applyElevation?: boolean;
+}
+/**
+ * Triangles for one floor: every wall, with its openings cut out, and a slab per room.
+ *
+ * Call it per storey and concatenate to build a whole building; each floor already knows
+ * its own elevation.
+ */
+export declare function buildPlanMesh(floor: PlanFloor, options?: BuildPlanMeshOptions): PlanMesh;

package/dist/types/package/common/floorPlan/floorPlan.triangulate.d.ts

@@ -0,0 +1,11 @@
+import { PlanPoint } from './floorPlan.types';
+/**
+ * Triangulates a ring and its holes into index triples over the returned vertex list.
+ *
+ * The vertices come back as well as the indices because bridging a hole duplicates the
+ * two vertices it joins, so the caller cannot simply index into what it passed in.
+ */
+export declare function triangulate(outer: readonly PlanPoint[], holes?: readonly (readonly PlanPoint[])[]): {
+    vertices: PlanPoint[];
+    indices: number[];
+};

package/dist/types/package/common/floorPlan/index.d.ts

@@ -16,13 +16,15 @@ export { commitDerivation, derivePlan, pruneUnmatchedRooms, roomAtPoint } from '
 export type { CommitDerivationOptions } from './floorPlan.rooms';
 export { HIT_PX, HIT_PX_COARSE, hitTest, selectionsEqual, worldTolerances } from './floorPlan.hit';
 export type { HitTestOptions, HitTolerances } from './floorPlan.hit';
-export { DEFAULT_WALL_ATTRS, addOpening, addRect, addWall, cleanupPlan, dissolveNode, mergeNodes, moveNode, removeOpening, removeWall, scalePlan, splitWall, transformPlan, updateOpening, validatePlan, wallLength, } from './floorPlan.graph';
-export type { DissolveNodeOptions, ResolveNodeResult, SplitWallResult, WallAttrs, } from './floorPlan.graph';
+export { DEFAULT_WALL_ATTRS, addOpening, addRect, addWall, cleanupPlan, detachWall, dissolveNode, mergeNodes, moveNode, removeOpening, removeWall, scalePlan, splitWall, transformPlan, updateOpening, validatePlan, wallLength, weldShortWalls, } from './floorPlan.graph';
+export type { DetachWallResult, DissolveNodeOptions, ResolveNodeResult, SplitWallResult, WallAttrs, } from './floorPlan.graph';
 export { DEFAULT_SNAP_OPTIONS, SnapKind, clientToWorld, resolveSnap, screenScale } from './floorPlan.snap';
 export type { SnapContext, SnapGuide, SnapOptions, SnapResult } from './floorPlan.snap';
 export { buildWallPaths, openingGeometry, wallCentrelineSpans } from './floorPlan.path';
 export type { BuildWallPathsOptions, WallCapLine, WallCapReason, WallPathGroup, WallPathResult, } from './floorPlan.path';
 export { PLAN_FORMAT_VERSION, planFromJson, planToJson } from './floorPlan.json';
 export type { PlanParseResult } from './floorPlan.json';
+export { buildPlanMesh } from './floorPlan.mesh';
+export type { BuildPlanMeshOptions, PlanMesh, PlanMeshGroup, PlanMeshPart } from './floorPlan.mesh';
 export { planFromLegacySvg } from './legacySvg';
 export type { LegacyImportOptions } from './legacySvg';

package/docs/FloorPlan.md

@@ -52,6 +52,8 @@ Every operation is pure and returns `PlanEdit<T>` = `{ floor, result, issues }`,
 | `splitWall(floor, wallId, at)` | Cuts a wall at a point or 0..1 parameter; redistributes its openings |
 | `mergeNodes(floor, keepId, removeId)` | Welds two nodes, deduplicating the walls that collapse together |
 | `dissolveNode(floor, nodeId)` | Rejoins two collinear same-construction walls; the inverse of `splitWall` |
+| `detachWall(floor, wallId, delta)` | Pulls a wall off its shared corners and moves it by `delta`, bridging each old corner to the new one |
+| `weldShortWalls(floor)` | Collapses every wall shorter than `MIN_WALL_LENGTH` by merging its two ends, so a squashed wall never leaves two corners stacked on one point |
 | `removeWall(floor, wallId, opts?)` | Removes a wall, its openings, and any node left orphaned |
 | `moveNode` / `transformPlan` / `scalePlan` | Move one node, translate everything, or rescale everything |
 | `addOpening` / `updateOpening` / `removeOpening` | Openings, clamped to fit their wall |
@@ -207,7 +209,43 @@ Feeding every legacy polygon edge through `addWall` is what collapses the old du
 
 ## Ready for 3D
 
-The model carries everything an extrusion needs and nothing it would have to invent: `PlanWall.thickness` / `height` / `baseHeight`, `PlanOpening.sill` / `head`, `PlanFloor.elevation` / `height`, and derived floor polygons. No 3D renderer ships today.
+`buildPlanMesh(floor, options?)` turns a storey into triangles: wall solids with their openings cut out, and a slab under each room.
+
+```ts
+import { buildPlanMesh } from '@ahrowe/ui';
+
+const mesh = buildPlanMesh(plan.floors[0]);
+// { positions: Float32Array, normals: Float32Array, indices: Uint32Array, groups }
+
+// three.js, for example — no adapter needed
+const g = new THREE.BufferGeometry();
+g.setAttribute('position', new THREE.BufferAttribute(mesh.positions, 3));
+g.setAttribute('normal', new THREE.BufferAttribute(mesh.normals, 3));
+g.setIndex(new THREE.BufferAttribute(mesh.indices, 1));
+```
+
+There is no renderer and no dependency: plain arrays are what every engine takes, so this feeds three.js, Babylon, a glTF writer or your own rasteriser without the package having an opinion. Call it per storey and concatenate for a whole building; each floor already knows its own `elevation`.
+
+**Axes.** Plan x becomes world x, plan y becomes world **z**, and world y is up. A plan is drawn in SVG's y-down space, so that mapping is a handedness flip — faces are wound here to suit, rather than inheriting the 2D rings' winding.
+
+**Openings are cut by splitting the wall, not by subtracting solids.** Every opening is an axis-aligned rectangle in its wall's own plane, so the wall falls into at most three prisms: under the sill, over the head, and the full-height stretches between openings. Exact, and no CSG library. A window leaves its upstand and lintel behind, which is what `sill` and `head` are carried for.
+
+**Storeys stack wall to wall.** `elevation` is the *finished floor level*, so a slab hangs below it and the walls start at the slab's underside — they clothe the floor plate the way a facade does, rather than stopping at it. A wall stays exactly `floor.height` tall, one storey's walls end precisely where the next storey's begin, and the slab sits inside them instead of showing as a band between the storeys. Build the walls from the level itself and their top face ends up coplanar with the slab above, which z-fights.
+
+A wall also drops a millimetre past the slab rather than landing flush on its underside. That is not arbitrary: a wall overlaps the slab it stands over, because the slab reaches the wall centrelines and the wall straddles them, so sharing a plane would leave two downward faces fighting for the same pixels and speckle the whole underside of the building. Wall heights and floor-to-floor spacing are unaffected.
+
+`groups` marks which triangles are wall and which are floor, so the two can take different materials in one draw.
+
+| Option | Default | |
+|---|---|---|
+| `wallHeight` | the floor's `height` | For walls with no `height` of their own |
+| `includeFloorSlab` | `true` | Lay a slab under each room |
+| `slabThickness` | `200` | Millimetres, hanging below floor level |
+| `applyElevation` | `true` | Lift by the floor's own elevation, so storeys stack |
+
+**Corners are mitred.** Two walls meeting at a corner both stop at the shared node, so left square they leave a gap of half a thickness on the outside of the turn — a notch cut through the full height of the wall. Their footprints are extended to where their edges actually cross instead, which is the same join the 2D renderer makes.
+
+An end stays square where there is no single corner to mitre to: a junction of three or more walls, a change of thickness across the node, an angle acute enough to send the mitre running away, and the reveals of an opening, which are square faces in their own right. Walls overlap slightly at those joints, which is invisible on an opaque solid but would show in a cutaway or through glass, and would double-count in a volume taken straight off the triangles.
 
 These are the fields that do nothing in 2D, and that is expected rather than a gap: a plan is a horizontal cut, so a window 900mm up the wall and a door at floor level are the same hole seen from above. `sill` is the height of an opening's bottom above the floor and `head` the height of its top; the drawer edits `sill` in its selection bar so the value is captured while the plan is being drawn, rather than having to be filled in for every opening afterwards.
 

package/docs/RoomDrawer.md

@@ -47,6 +47,19 @@ const [plan, setPlan] = useState<FloorPlan>(() => emptyFloorPlan());
 - an opening slides along its wall
 - a room moves every corner it owns
 
+**Hold Ctrl/Cmd while dragging a wall to detach it instead.** The wall comes off the
+corners it shares, the neighbours keep their ends, and a connecting wall grows between
+each old corner and the new one. Use it when a partition joins the wall being moved: a
+plain drag takes the partition's end along with it, a detach drag leaves it where it is.
+
+Pulling a wall off a plain corner is deliberately a no-op on the drawing: the connector
+continues the wall that was already there, so the seam it leaves is straight and is
+dissolved on the spot. Nothing is detached until the wall has moved at least one grid
+step, so a Ctrl-click on a wall is still just a selection toggle. Push the wall back onto
+the line it came off and the corners weld back together, whether that happens in the same
+drag or a later one — the corner that survives is the one that was already there.
+Grabbing a selected wall's midpoint handle always adds a corner, Ctrl or not.
+
 ## Measuring without drawing
 
 The `measure` tool is a ruler. Drag it across the plan and it reports length and angle, snapping to corners, walls and the grid like everything else, with `Shift` for a fixed angle.
@@ -127,6 +140,7 @@ The `snap`, `angleLock` and `showGrid` props seed the toggles; changing one rese
 | `S` / `L` / `G` | Toggle snapping / angle lock / grid |
 | `Ctrl/Cmd+A` | Select everything |
 | `Ctrl/Cmd`-click | Add or remove one thing from the selection |
+| `Ctrl/Cmd`-drag a wall | Detach it from its corners instead of dragging them along |
 | `Shift` (hold) | Momentarily invert angle lock |
 | `Alt` (hold) | Momentarily invert snapping |
 | `Esc` | Cancel the wall chain, or clear the selection |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahrowe/ui",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "publishConfig": {
     "access": "public"
   },
@@ -101,6 +101,7 @@
     "@types/react": "^19.2.15",
     "@types/react-dom": "^19.2.3",
     "@types/react-syntax-highlighter": "^15.5.13",
+    "@types/three": "^0.186.0",
     "@vitejs/plugin-react": "^6.0.2",
     "@vitest/ui": "^4.1.7",
     "eslint": "^9.39.4",
@@ -118,6 +119,7 @@
     "react-dom": "^19.2.6",
     "react-element-to-jsx-string": "^17.0.1",
     "react-syntax-highlighter": "^16.1.1",
+    "three": "^0.186.0",
     "tsx": "^4.22.3",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.60.0",