@pascal-app/nodes 0.1.1

package/dist/shelf/floorplan.js

@@ -0,0 +1,124 @@
+import { sanitizeShelfDimensions } from './dimensions';
+// Offsets for the floor-plan selection chrome. Resize chevrons sit a
+// hair off the footprint rim; the rotate-arrow corner sits a bit further
+// out so it doesn't crowd the resize arrows.
+const RESIZE_ARROW_OFFSET = 0.12;
+const ROTATE_ARROW_CORNER_OFFSET = 0.22;
+/**
+ * 2D floor-plan representation of a shelf. The unit's outer footprint
+ * projects to a rectangle of `width × depth` centered on the shelf's
+ * position, rotated by its Y angle. For `bookshelf` / `cubby` with
+ * columns > 1, vertical column dividers project as thin lines so the
+ * grid is legible from above.
+ *
+ * Brackets / posts / individual boards are intentionally omitted — they
+ * stack vertically under the topmost board from a top-down view and
+ * adding them clutters the plan without conveying useful information.
+ *
+ * When selected, emits resize chevrons matching the 3D handle set
+ * (width on +X, depth on +Z) plus a rotate-arrow at the front-right
+ * corner. Body move continues to flow through `shelfFloorplanMoveTarget`
+ * (engaged from the action-menu Move button, not from these arrows).
+ */
+export function buildShelfFloorplan(node, ctx) {
+    const shelf = sanitizeShelfDimensions(node);
+    const [px, , pz] = shelf.position;
+    const ry = shelf.rotation[1] ?? 0;
+    // Floor-plan plots at `-ry` so SVG's CW-with-y-down `rotate` direction
+    // ends up visually matching Three.js Y-rotation (CCW from a top-down
+    // view) — same `rotation` value rotates the same way in both views.
+    // Stair already does this; column / shelf / roof-segment now do too.
+    const planRy = -ry;
+    const halfW = shelf.width / 2;
+    const halfD = shelf.depth / 2;
+    const isSelected = ctx?.viewState?.selected ?? false;
+    // Floor-plan fill: a single neutral fill regardless of `material`.
+    // 2D doesn't render the actual paint material — surfaces in plan view
+    // read as outline + tone, not photoreal texture.
+    const footprintChildren = [
+        {
+            kind: 'rect',
+            x: -halfW,
+            y: -halfD,
+            width: shelf.width,
+            height: shelf.depth,
+            fill: '#d6d3d1',
+            stroke: '#1f2937',
+            strokeWidth: 0.015,
+            opacity: 0.9,
+        },
+    ];
+    // Show column dividers for grid-style shelves so the cubby / bookshelf
+    // grid is visible from above.
+    if ((shelf.style === 'bookshelf' || shelf.style === 'cubby') && shelf.columns > 1) {
+        const innerWidth = shelf.width - 2 * shelf.thickness;
+        const colStep = innerWidth / shelf.columns;
+        for (let c = 1; c < shelf.columns; c++) {
+            const x = -innerWidth / 2 + c * colStep;
+            footprintChildren.push({
+                kind: 'line',
+                x1: x,
+                y1: -halfD + shelf.thickness,
+                x2: x,
+                y2: halfD - shelf.thickness,
+                stroke: '#1f2937',
+                strokeWidth: 0.012,
+                opacity: 0.7,
+            });
+        }
+    }
+    const footprintGroup = {
+        kind: 'group',
+        transform: { translate: [px, pz], rotate: planRy },
+        children: footprintChildren,
+    };
+    if (!isSelected) {
+        return footprintGroup;
+    }
+    // Selection chrome lives in world coords (not under the rotated
+    // transform group) so the cursor projection in the affordance can use
+    // the same coord system the dispatcher's `planPoint` arrives in.
+    // `planRy` (= -ry) is the rotation the SVG group uses; arrows and
+    // their plan-coord projections must use the same.
+    const cosR = Math.cos(planRy);
+    const sinR = Math.sin(planRy);
+    // Plan vectors for the shelf-local axes — SVG `rotate(planRy)` maps
+    // local (1, 0) → (cos planRy, sin planRy) and local (0, 1) → (-sin planRy, cos planRy).
+    const localXInPlan = [cosR, sinR];
+    const localZInPlan = [-sinR, cosR];
+    const children = [footprintGroup];
+    const emitResizeArrow = (dim, localAxis, localOffset) => {
+        const planAxis = [
+            localAxis[0] * cosR - localAxis[1] * sinR,
+            localAxis[0] * sinR + localAxis[1] * cosR,
+        ];
+        children.push({
+            kind: 'move-arrow',
+            point: [px + planAxis[0] * localOffset, pz + planAxis[1] * localOffset],
+            angle: Math.atan2(planAxis[1], planAxis[0]),
+            affordance: 'shelf-resize',
+            payload: { dim, planAxis },
+        });
+    };
+    emitResizeArrow('width', [1, 0], halfW + RESIZE_ARROW_OFFSET);
+    emitResizeArrow('depth', [0, 1], halfD + RESIZE_ARROW_OFFSET);
+    // Rotate-arrow at the +X / +Z corner — matches the 3D
+    // `shelfRotateHandle` corner placement so users see the rotation
+    // affordance in the same quadrant across views.
+    const cornerLocalX = halfW + ROTATE_ARROW_CORNER_OFFSET;
+    const cornerLocalZ = halfD + ROTATE_ARROW_CORNER_OFFSET;
+    const cornerPlanX = cornerLocalX * cosR - cornerLocalZ * sinR;
+    const cornerPlanY = cornerLocalX * sinR + cornerLocalZ * cosR;
+    // The arc-arrow's local +X reads as the radial-outward direction; the
+    // diagonal corner is the (+X +Z) sum direction in shelf-local.
+    const radialPlanX = localXInPlan[0] + localZInPlan[0];
+    const radialPlanY = localXInPlan[1] + localZInPlan[1];
+    children.push({
+        kind: 'rotate-arrow',
+        point: [px + cornerPlanX, pz + cornerPlanY],
+        angle: Math.atan2(radialPlanY, radialPlanX),
+        affordance: 'shelf-rotate',
+        pivot: [px, pz],
+    });
+    return { kind: 'group', children };
+}

package/dist/shelf/geometry.d.ts

@@ -0,0 +1,15 @@
+import { type GeometryContext } from '@pascal-app/core';
+import { type RenderShading } from '@pascal-app/viewer';
+import { Group } from 'three';
+import type { ShelfNode } from './schema';
+export declare function buildShelfGeometry(rawNode: ShelfNode, ctx?: GeometryContext, shading?: RenderShading): Group;
+/**
+ * Y of the top surface of each shelf row (top of the board). Used by
+ * `capabilities.surfaces.custom` so items host at the right Y on
+ * whichever row the cursor targets. When `withBottom` is on (cubby /
+ * bookshelf only — wall-shelf and open-rack ignore the toggle), the
+ * top of the bottom board is exposed as an additional surface so items
+ * can host in the lowest cell.
+ */
+export declare function shelfRowSurfaceYs(node: ShelfNode): number[];
+//# sourceMappingURL=geometry.d.ts.map

package/dist/shelf/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/shelf/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA0B,MAAM,kBAAkB,CAAA;AAC/E,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAe,KAAK,EAAuB,MAAM,OAAO,CAAA;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAuFzC,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,EAClB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,GAClC,KAAK,CAkCP;AAySD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAM3D"}

package/dist/shelf/geometry.js

@@ -0,0 +1,304 @@
+import { getMaterialPresetByRef } from '@pascal-app/core';
+import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, resolveMaterialRef, } from '@pascal-app/viewer';
+import { BoxGeometry, Group, Mesh } from 'three';
+import { sanitizeShelfDimensions } from './dimensions';
+import { SHELF_SLOT_DEFAULT_COLOR } from './slots';
+function getShelfSlotMaterial(node, slotId, materials, shading) {
+    const ref = node.slots?.[slotId];
+    if (ref) {
+        const resolved = resolveMaterialRef(ref, materials, shading);
+        if (resolved)
+            return resolved;
+    }
+    // Legacy whole-shelf paint applies to every slot when set (no per-slot override).
+    if (node.materialPreset) {
+        const preset = getMaterialPresetByRef(node.materialPreset);
+        if (preset) {
+            const base = createDefaultMaterial('#ffffff', 0.5, shading);
+            applyMaterialPresetToMaterials(base, preset);
+            return base;
+        }
+    }
+    if (node.material)
+        return createMaterial(node.material, shading);
+    return createDefaultMaterial(SHELF_SLOT_DEFAULT_COLOR, 0.9, shading);
+}
+function stampShelfSlot(mesh, slotId) {
+    mesh.userData.slotId = slotId;
+    return mesh;
+}
+// A board's front/back faces land on the frame's outer faces (posts / back panel)
+// — coplanar surfaces the depth buffer can't separate, which flickers as z-fighting.
+// Recess 1mm so the board sits just inside: the meshes still overlap (no gap), but
+// no faces are coplanar. Depth is always recessed (boards reach into the back panel
+// / posts). Width is recessed only at call sites where boards span OVER posts
+// (open-rack / no-sides bookshelf); boards that ABUT side panels keep full width so
+// they meet the sides flush — abutting faces are back-to-back and never fight.
+const BOARD_INSET = 0.001;
+// Frame members that pass under the top board (dividers / back / corner posts) reach
+// y=unitHeight, coplanar with the top board's top face → z-fighting. Drop their top 1mm so
+// the board cleanly caps them; their bottom stays on the floor.
+const FRAME_TOP_INSET = 0.001;
+function cappedFrameY(unitHeight) {
+    const height = Math.max(unitHeight - FRAME_TOP_INSET, 0.001);
+    return { height, centerY: height / 2 };
+}
+function boardGeometry(width, thickness, depth, insetWidth = false) {
+    return new BoxGeometry(insetWidth ? Math.max(width - 2 * BOARD_INSET, 0.001) : width, thickness, Math.max(depth - 2 * BOARD_INSET, 0.001));
+}
+export function buildShelfGeometry(rawNode, ctx, shading = 'rendered') {
+    const node = sanitizeShelfDimensions(rawNode);
+    const group = new Group();
+    group.name = 'shelf-geometry';
+    const materials = {
+        shelves: getShelfSlotMaterial(node, 'shelves', ctx?.materials, shading),
+        frame: getShelfSlotMaterial(node, 'frame', ctx?.materials, shading),
+        back: getShelfSlotMaterial(node, 'back', ctx?.materials, shading),
+    };
+    switch (node.style) {
+        case 'wall-shelf':
+            buildWallShelf(group, node, materials);
+            break;
+        case 'bookshelf':
+            buildBookshelf(group, node, materials);
+            break;
+        case 'open-rack':
+            buildOpenRack(group, node, materials);
+            break;
+        case 'cubby':
+            buildCubby(group, node, materials);
+            break;
+    }
+    // Boards/brackets cast + receive shadows like the other geometry-driven
+    // kinds (fence, slab). Set once here rather than on every `new Mesh` above.
+    for (const child of group.children) {
+        child.castShadow = true;
+        child.receiveShadow = true;
+    }
+    return group;
+}
+// ─── Style helpers ───────────────────────────────────────────────────
+/**
+ * Wall-shelf: open boards held by end brackets. `rows > 1` stacks
+ * evenly-spaced boards from `height/rows` up to `height`. Brackets
+ * span from floor to the topmost board.
+ */
+function buildWallShelf(group, node, materials) {
+    for (const y of boardCenterYs(node)) {
+        const board = stampShelfSlot(new Mesh(boardGeometry(node.width, node.thickness, node.depth), materials.shelves), 'shelves');
+        board.name = `shelf-board-${boardRowIndex(node, y)}`;
+        board.position.set(0, y, 0);
+        group.add(board);
+    }
+    if (node.bracketStyle === 'hidden')
+        return;
+    const inset = Math.min(0.12, node.width / 6);
+    const bracketHeight = Math.max(0.01, node.height);
+    const bracketWidth = node.bracketStyle === 'industrial'
+        ? Math.max(0.04, node.depth * 0.2)
+        : Math.max(0.02, node.depth * 0.12);
+    const bracketDepth = node.bracketStyle === 'industrial' ? node.depth * 0.95 : node.depth * 0.7;
+    for (const sign of [-1, 1]) {
+        const bracket = stampShelfSlot(new Mesh(new BoxGeometry(bracketWidth, bracketHeight, bracketDepth), materials.frame), 'frame');
+        bracket.name = `shelf-bracket-${sign === -1 ? 'left' : 'right'}`;
+        bracket.position.set(sign * (node.width / 2 - inset), bracketHeight / 2, 0);
+        group.add(bracket);
+    }
+}
+/**
+ * Bookshelf: full-height cabinet with side panels, multiple shelf boards,
+ * optional back, and inner vertical dividers if `columns > 1`. When
+ * `withSides === false`, side panels become slim corner posts (a rack
+ * silhouette).
+ */
+function buildBookshelf(group, node, materials) {
+    const unitHeight = node.height + node.thickness;
+    const innerWidth = node.withSides ? node.width - 2 * node.thickness : node.width;
+    // Top + bottom + intermediate boards. No sides => boards span over corner
+    // posts, so inset their width too; with sides they abut the panels (flush).
+    for (const y of boardCenterYs(node)) {
+        const board = stampShelfSlot(new Mesh(boardGeometry(innerWidth, node.thickness, node.depth, !node.withSides), materials.shelves), 'shelves');
+        board.name = `shelf-board-${boardRowIndex(node, y)}`;
+        board.position.set(0, y, 0);
+        group.add(board);
+    }
+    if (node.withBottom) {
+        const bottom = stampShelfSlot(new Mesh(boardGeometry(innerWidth, node.thickness, node.depth), materials.shelves), 'shelves');
+        bottom.name = 'shelf-board-bottom';
+        bottom.position.set(0, node.thickness / 2, 0);
+        group.add(bottom);
+    }
+    // Side panels (or corner posts) — span the full unit height.
+    if (node.withSides) {
+        for (const sign of [-1, 1]) {
+            const side = stampShelfSlot(new Mesh(new BoxGeometry(node.thickness, unitHeight, node.depth), materials.frame), 'frame');
+            side.name = `shelf-side-${sign === -1 ? 'left' : 'right'}`;
+            side.position.set(sign * (node.width / 2 - node.thickness / 2), unitHeight / 2, 0);
+            group.add(side);
+        }
+    }
+    else {
+        addCornerPosts(group, node, materials.frame, unitHeight, 'rack');
+    }
+    if (node.withBack) {
+        const fy = cappedFrameY(unitHeight);
+        const back = stampShelfSlot(new Mesh(new BoxGeometry(innerWidth, fy.height, node.thickness), materials.back), 'back');
+        back.name = 'shelf-back';
+        back.position.set(0, fy.centerY, -(node.depth / 2 - node.thickness / 2));
+        group.add(back);
+    }
+    // Vertical dividers between columns
+    if (node.columns > 1) {
+        const fy = cappedFrameY(unitHeight);
+        const colStep = innerWidth / node.columns;
+        for (let c = 1; c < node.columns; c++) {
+            const x = -innerWidth / 2 + c * colStep;
+            const divider = stampShelfSlot(
+            // A full-height divider crosses the shelves, so its depth must sit
+            // INSIDE the boards' (already recessed) depth: embedded at each crossing
+            // (the board occludes it — no coplanar fight) and tucked inside the back
+            // panel, rather than proud at the front / coplanar with the back.
+            new Mesh(new BoxGeometry(node.thickness, fy.height, node.depth - 4 * BOARD_INSET), materials.frame), 'frame');
+            divider.name = `shelf-divider-col-${c}`;
+            divider.position.set(x, fy.centerY, 0);
+            group.add(divider);
+        }
+    }
+}
+/**
+ * Open-rack: four corner posts + horizontal boards. `withBack` adds an
+ * X-brace on the back face for stability. `withSides` / `bracketStyle`
+ * are ignored (the rack defines its own posts).
+ */
+function buildOpenRack(group, node, materials) {
+    const unitHeight = node.height + node.thickness;
+    const innerWidth = node.width;
+    const boardThickness = Math.max(0.02, node.thickness * 0.8);
+    for (const y of boardCenterYs(node)) {
+        const board = stampShelfSlot(new Mesh(boardGeometry(innerWidth, boardThickness, node.depth, true), materials.shelves), 'shelves');
+        board.name = `shelf-board-${boardRowIndex(node, y)}`;
+        board.position.set(0, y, 0);
+        group.add(board);
+    }
+    addCornerPosts(group, node, materials.frame, unitHeight, 'rack');
+    if (node.withBack) {
+        const braceThickness = Math.max(0.015, node.thickness * 0.6);
+        for (const y of [boardThickness, unitHeight - boardThickness]) {
+            const brace = stampShelfSlot(new Mesh(new BoxGeometry(node.width - braceThickness * 2, braceThickness, braceThickness), materials.frame), 'frame');
+            brace.name = `shelf-brace-h-${y < unitHeight / 2 ? 'bottom' : 'top'}`;
+            brace.position.set(0, y, -(node.depth / 2 - braceThickness / 2));
+            group.add(brace);
+        }
+    }
+}
+/**
+ * Cubby: closed grid of pigeonholes. Always has sides + back + horizontal
+ * boards + vertical dividers. `withBack` / `withSides` are forced on
+ * because the cubby shape requires them.
+ */
+function buildCubby(group, node, materials) {
+    const unitHeight = node.height + node.thickness;
+    const innerWidth = node.width - 2 * node.thickness;
+    for (const y of boardCenterYs(node)) {
+        const board = stampShelfSlot(new Mesh(boardGeometry(innerWidth, node.thickness, node.depth), materials.shelves), 'shelves');
+        board.name = `shelf-board-${boardRowIndex(node, y)}`;
+        board.position.set(0, y, 0);
+        group.add(board);
+    }
+    if (node.withBottom) {
+        const bottom = stampShelfSlot(new Mesh(boardGeometry(innerWidth, node.thickness, node.depth), materials.shelves), 'shelves');
+        bottom.name = 'shelf-board-bottom';
+        bottom.position.set(0, node.thickness / 2, 0);
+        group.add(bottom);
+    }
+    for (const sign of [-1, 1]) {
+        const side = stampShelfSlot(new Mesh(new BoxGeometry(node.thickness, unitHeight, node.depth), materials.frame), 'frame');
+        side.name = `shelf-side-${sign === -1 ? 'left' : 'right'}`;
+        side.position.set(sign * (node.width / 2 - node.thickness / 2), unitHeight / 2, 0);
+        group.add(side);
+    }
+    const fy = cappedFrameY(unitHeight);
+    const back = stampShelfSlot(new Mesh(new BoxGeometry(innerWidth, fy.height, node.thickness), materials.back), 'back');
+    back.name = 'shelf-back';
+    back.position.set(0, fy.centerY, -(node.depth / 2 - node.thickness / 2));
+    group.add(back);
+    if (node.columns > 1) {
+        const colStep = innerWidth / node.columns;
+        const rowStep = node.height / node.rows;
+        for (let r = 0; r < node.rows; r++) {
+            // Without a bottom board the lowest cell opens onto the floor, so its
+            // divider must reach y=0 rather than rest on a (missing) board top.
+            const cellBottomY = r === 0 && !node.withBottom ? 0 : node.thickness + r * rowStep;
+            const cellTopY = node.thickness + (r + 1) * rowStep;
+            const dividerHeight = cellTopY - cellBottomY - node.thickness;
+            if (dividerHeight <= 0)
+                continue;
+            for (let c = 1; c < node.columns; c++) {
+                const x = -innerWidth / 2 + c * colStep;
+                const divider = stampShelfSlot(
+                // Same depth recess as the boards: the divider sits flush with the
+                // shelf fronts (not proud) and its back tucks inside the back panel,
+                // so it neither overflows the boards at the front nor z-fights the
+                // back panel down the centre. Height is flush (the board faces it
+                // meets top/bottom are back-to-back, so they don't fight).
+                new Mesh(boardGeometry(node.thickness, dividerHeight, node.depth), materials.frame), 'frame');
+                divider.name = `shelf-divider-${r}-${c}`;
+                divider.position.set(x, cellBottomY + dividerHeight / 2, 0);
+                group.add(divider);
+            }
+        }
+    }
+}
+// ─── Shared helpers ──────────────────────────────────────────────────
+/**
+ * Y positions of every shelf board's vertical center, in floor-to-top
+ * order. The topmost board's center is at `height + thickness/2`; lower
+ * boards are evenly spaced from `height/rows` to `height` (matching the
+ * legacy v1 wall-shelf where the only board is at `height + thickness/2`).
+ */
+function boardCenterYs(node) {
+    const ys = [];
+    const step = node.height / node.rows;
+    for (let r = 1; r <= node.rows; r++) {
+        ys.push(r * step + node.thickness / 2);
+    }
+    return ys;
+}
+/** Convert a Y position back to its row index (0 = bottom row). */
+function boardRowIndex(node, y) {
+    const step = node.height / node.rows;
+    return Math.round((y - node.thickness / 2) / step) - 1;
+}
+/**
+ * Place four corner posts at `(±width/2 ∓ inset, height/2, ±depth/2 ∓ inset)`.
+ * Used by `open-rack` and the no-sides variant of `bookshelf`.
+ */
+function addCornerPosts(group, node, material, unitHeight, postStyle) {
+    const fy = cappedFrameY(unitHeight);
+    const postThickness = postStyle === 'rack' ? Math.max(0.025, node.thickness * 1.5) : Math.max(0.02, node.thickness);
+    const inset = postThickness / 2;
+    for (const xSign of [-1, 1]) {
+        for (const zSign of [-1, 1]) {
+            const post = stampShelfSlot(new Mesh(new BoxGeometry(postThickness, fy.height, postThickness), material), 'frame');
+            post.name = `shelf-post-${xSign === -1 ? 'l' : 'r'}${zSign === -1 ? 'b' : 'f'}`;
+            post.position.set(xSign * (node.width / 2 - inset), fy.centerY, zSign * (node.depth / 2 - inset));
+            group.add(post);
+        }
+    }
+}
+/**
+ * Y of the top surface of each shelf row (top of the board). Used by
+ * `capabilities.surfaces.custom` so items host at the right Y on
+ * whichever row the cursor targets. When `withBottom` is on (cubby /
+ * bookshelf only — wall-shelf and open-rack ignore the toggle), the
+ * top of the bottom board is exposed as an additional surface so items
+ * can host in the lowest cell.
+ */
+export function shelfRowSurfaceYs(node) {
+    const safe = sanitizeShelfDimensions(node);
+    const ys = boardCenterYs(safe).map((y) => y + safe.thickness / 2);
+    const bottomApplies = safe.style === 'cubby' || safe.style === 'bookshelf';
+    if (safe.withBottom && bottomApplies)
+        ys.unshift(safe.thickness);
+    return ys;
+}

package/dist/shelf/index.d.ts

@@ -0,0 +1,4 @@
+export { shelfDefinition } from './definition';
+export { buildShelfGeometry } from './geometry';
+export { ShelfNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/shelf/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shelf/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA"}

package/dist/shelf/index.js

@@ -0,0 +1,3 @@
+export { shelfDefinition } from './definition';
+export { buildShelfGeometry } from './geometry';
+export { ShelfNode } from './schema';

package/dist/shelf/paint.d.ts

@@ -0,0 +1,3 @@
+import { type PaintCapability } from '@pascal-app/core';
+export declare const shelfPaint: PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

package/dist/shelf/paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/shelf/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AAmLzB,eAAO,MAAM,UAAU,EAAE,eA0BxB,CAAA"}

package/dist/shelf/paint.js

@@ -0,0 +1,181 @@
+import { generateSceneMaterialId, parseMaterialRef, toSceneMaterialRef, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, useViewer } from '@pascal-app/viewer';
+function deepEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null)
+        return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        for (let index = 0; index < a.length; index += 1) {
+            if (!deepEqual(a[index], b[index]))
+                return false;
+        }
+        return true;
+    }
+    if (typeof a === 'object') {
+        const aRecord = a;
+        const bRecord = b;
+        const aKeys = Object.keys(aRecord);
+        const bKeys = Object.keys(bRecord);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (const key of aKeys) {
+            if (!Object.hasOwn(bRecord, key))
+                return false;
+            if (!deepEqual(aRecord[key], bRecord[key]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+function resolveShelfSlotId(args) {
+    const slotId = args.hitObject?.userData?.slotId;
+    return typeof slotId === 'string' ? slotId : null;
+}
+function buildShelfSlotsPatch(node, role, material, materialPreset) {
+    const slots = { ...(node.slots ?? {}) };
+    if (material === undefined && materialPreset === undefined) {
+        delete slots[role];
+        return { slots };
+    }
+    if (materialPreset) {
+        slots[role] = materialPreset;
+        return { slots };
+    }
+    return { slots };
+}
+function findMatchingSceneMaterial(materials, material) {
+    for (const sceneMaterial of Object.values(materials)) {
+        if (deepEqual(sceneMaterial.material, material))
+            return sceneMaterial;
+    }
+    return null;
+}
+function commitNewSceneMaterialAndSlots(nodeId, nextSlots, sceneMaterial) {
+    // Creating the scene material and setting the slot ref are one logical
+    // edit, so apply both in a single `set` — zundo records one history entry,
+    // and one undo removes both the ref and its (now orphaned) material.
+    useScene.setState((state) => {
+        if (state.readOnly)
+            return state;
+        const currentNode = state.nodes[nodeId];
+        if (currentNode?.type !== 'shelf')
+            return state;
+        return {
+            materials: { ...state.materials, [sceneMaterial.id]: sceneMaterial },
+            nodes: {
+                ...state.nodes,
+                [nodeId]: { ...currentNode, slots: nextSlots },
+            },
+        };
+    });
+    useScene.getState().markDirty(nodeId);
+}
+function commitShelfPaint(node, role, material, materialPreset) {
+    const nodeId = node.id;
+    const state = useScene.getState();
+    const currentNode = state.nodes[nodeId] ?? node;
+    let ref;
+    let newSceneMaterial = null;
+    if (material === undefined && materialPreset === undefined) {
+        ref = undefined;
+    }
+    else if (materialPreset) {
+        ref = materialPreset;
+    }
+    else if (material) {
+        const existing = findMatchingSceneMaterial(state.materials, material);
+        if (existing) {
+            ref = toSceneMaterialRef(existing.id);
+        }
+        else {
+            const id = generateSceneMaterialId();
+            newSceneMaterial = {
+                id,
+                name: `Material ${Object.keys(state.materials).length + 1}`,
+                material,
+            };
+            ref = toSceneMaterialRef(id);
+        }
+    }
+    else {
+        return;
+    }
+    const nextSlots = { ...(currentNode.slots ?? {}) };
+    if (ref)
+        nextSlots[role] = ref;
+    else
+        delete nextSlots[role];
+    if (newSceneMaterial) {
+        commitNewSceneMaterialAndSlots(nodeId, nextSlots, newSceneMaterial);
+        return;
+    }
+    state.updateNode(nodeId, { slots: nextSlots });
+}
+function buildPreviewMaterial(material, materialPreset) {
+    const shading = useViewer.getState().shading;
+    if (materialPreset)
+        return createMaterialFromPresetRef(materialPreset, shading);
+    if (material)
+        return createMaterial(material, shading);
+    return null;
+}
+function applyShelfPreview(role, root, material, materialPreset) {
+    const previewMaterial = buildPreviewMaterial(material, materialPreset);
+    if (!previewMaterial)
+        return () => { };
+    const restores = [];
+    root.traverse((object) => {
+        const mesh = object;
+        if (!mesh.isMesh)
+            return;
+        const userData = mesh.userData;
+        // Only the shelf's own builder meshes — never hosted item children, whose
+        // GLB meshes can carry a colliding `userData.slotId` (slot_frame, etc.).
+        if (userData.__fromGeometry !== true)
+            return;
+        if (userData.slotId !== role)
+            return;
+        const previous = mesh.material;
+        mesh.material = previewMaterial;
+        restores.push(() => {
+            mesh.material = previous;
+        });
+    });
+    if (restores.length === 0)
+        return null;
+    return () => {
+        for (let index = restores.length - 1; index >= 0; index -= 1) {
+            restores[index]?.();
+        }
+    };
+}
+export const shelfPaint = {
+    resolveRole: ({ hitObject }) => resolveShelfSlotId({ hitObject: hitObject }),
+    buildPatch: ({ node, role, material, materialPreset }) => buildShelfSlotsPatch(node, role, material, materialPreset),
+    commit: ({ node, role, material, materialPreset }) => commitShelfPaint(node, role, material, materialPreset),
+    applyPreview: ({ role, root, material, materialPreset }) => applyShelfPreview(role, root, material, materialPreset),
+    getEffectiveMaterial: ({ node, role }) => {
+        const shelf = node;
+        const parsed = parseMaterialRef(shelf.slots?.[role]);
+        if (parsed) {
+            if (parsed.kind === 'library') {
+                return { material: undefined, materialPreset: shelf.slots?.[role] };
+            }
+            const sceneMaterial = useScene.getState().materials[parsed.id];
+            if (sceneMaterial)
+                return { material: sceneMaterial.material, materialPreset: undefined };
+        }
+        // No (or dangling) slot ref — surface the legacy whole-shelf paint the
+        // geometry builder still falls back to, so the picker matches what renders.
+        if (shelf.materialPreset || shelf.material) {
+            return { material: shelf.material, materialPreset: shelf.materialPreset };
+        }
+        return null;
+    },
+};

package/dist/shelf/parametrics.d.ts

@@ -0,0 +1,14 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { ShelfNode } from './schema';
+/**
+ * Inspector descriptor for the parametric shelf. Drives both the
+ * auto-derived inspector UI and the AI/MCP `create_shelf` /
+ * `update_shelf` tools with bounded JSON-schema parameters.
+ *
+ * Fields are grouped by intent: Style first (what kind of shelf), then
+ * Topology (rows / columns / back / sides / bottom + wall-shelf bracket
+ * style), then Dimensions. Surface material is paint-tray driven (same
+ * flow as walls / slabs / stairs) and intentionally not surfaced here.
+ */
+export declare const shelfParametrics: ParametricDescriptor<ShelfNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/shelf/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CAsE5D,CAAA"}