@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/slab/definition.js

@@ -1,329 +1,4 @@
-import { liftedManualSlab, MIN_SLAB_THICKNESS, markSlabChangeDependents, pointInPolygon2D, slabSlots, syncStairRises, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
-import { surfaceBatchable } from '../shared/node-batch/batchable.js';
-import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
-import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts.js';
-import { applySlabBaseElevationChange, applySlabThicknessChange, applySlabTopChange, getSlabBaseElevation, slabElevationUpperBound, } from './elevation-limit.js';
-import { buildSlabFloorplan } from './floorplan.js';
-import { slabAddVertexAffordance, slabDeleteVertexAffordance, slabMoveEdgeAffordance, slabMoveVertexAffordance, } from './floorplan-affordances.js';
-import { slabFloorplanMoveTarget } from './floorplan-move.js';
-import { buildSlabGeometry } from './geometry.js';
-import { slabPaint } from './paint.js';
-import { slabParametrics } from './parametrics.js';
-import { slabQuickMeasurement } from './quick-measurement.js';
-import { SlabNode } from './schema.js';
-const HEIGHT_HANDLE_OFFSET = 0.22;
-const MIN_SLAB_ELEVATION = -1;
-function polygonVertexAverage(polygon) {
-    if (polygon.length === 0)
-        return [0, 0];
-    let cx = 0;
-    let cz = 0;
-    for (const [x, z] of polygon) {
-        cx += x;
-        cz += z;
-    }
-    return [cx / polygon.length, cz / polygon.length];
-}
-function pointIsOnSolidSlab(point, slab) {
-    if (!pointInPolygon2D(point, slab.polygon, { includeBoundary: false }))
-        return false;
-    return !(slab.holes ?? []).some((hole) => hole.length >= 3 && pointInPolygon2D(point, hole, { includeBoundary: true }));
-}
-function slabHandleAnchor(slab) {
-    const polygon = slab.polygon ?? [];
-    const fallback = polygonVertexAverage(polygon);
-    if (polygon.length < 3)
-        return fallback;
-    if (pointIsOnSolidSlab(fallback, slab))
-        return fallback;
-    let minX = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let minZ = Number.POSITIVE_INFINITY;
-    let maxZ = Number.NEGATIVE_INFINITY;
-    for (const [x, z] of polygon) {
-        minX = Math.min(minX, x);
-        maxX = Math.max(maxX, x);
-        minZ = Math.min(minZ, z);
-        maxZ = Math.max(maxZ, z);
-    }
-    const candidates = [];
-    for (const point of polygon) {
-        candidates.push([
-            fallback[0] + (point[0] - fallback[0]) * 0.35,
-            fallback[1] + (point[1] - fallback[1]) * 0.35,
-        ]);
-    }
-    const steps = 12;
-    for (let xi = 1; xi < steps; xi += 1) {
-        const x = minX + ((maxX - minX) * xi) / steps;
-        for (let zi = 1; zi < steps; zi += 1) {
-            const z = minZ + ((maxZ - minZ) * zi) / steps;
-            candidates.push([x, z]);
-        }
-    }
-    let best = null;
-    let bestDistance = Number.POSITIVE_INFINITY;
-    for (const candidate of candidates) {
-        if (!pointIsOnSolidSlab(candidate, slab))
-            continue;
-        const dx = candidate[0] - fallback[0];
-        const dz = candidate[1] - fallback[1];
-        const distance = dx * dx + dz * dz;
-        if (distance < bestDistance) {
-            best = candidate;
-            bestDistance = distance;
-        }
-    }
-    return best ?? fallback;
-}
-function slabElevationGuideSource(slab) {
-    return {
-        nodeId: slab.id,
-        levelId: slab.parentId,
-        anchor: slabHandleAnchor(slab),
-    };
-}
-function slabChangePreviewOverrides(slab, patch, sceneApi) {
-    const next = { ...slab, ...patch };
-    const nodes = { ...sceneApi.nodes(), [slab.id]: next };
-    const previews = new Map();
-    markSlabChangeDependents(slab, next, nodes, (id) => previews.set(id, {}));
-    for (const update of syncStairRises(nodes)) {
-        const segment = nodes[update.id];
-        if (segment?.type !== 'stair-segment' ||
-            !segment.parentId ||
-            !previews.has(segment.parentId)) {
-            continue;
-        }
-        previews.set(update.id, update.data);
-    }
-    return [...previews];
-}
-function slabRecessedDepthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_SLAB_ELEVATION,
-        max: (n, sceneApi) => slabElevationUpperBound(sceneApi.nodes(), n),
-        currentValue: (n) => n.elevation ?? 0.05,
-        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(slabElevationGuideSource(n), newValue, sceneApi.nodes()),
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), n.elevation ?? 0.05, sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (n, newValue) => applySlabTopChange(n, newValue),
-        previewOverrides: (n, newValue, sceneApi) => slabChangePreviewOverrides(n, applySlabTopChange(n, newValue), sceneApi),
-        placement: {
-            position: (n) => {
-                const [cx, cz] = slabHandleAnchor(n);
-                const elevation = n.elevation ?? 0.05;
-                return [cx, elevation + HEIGHT_HANDLE_OFFSET, cz];
-            },
-        },
-    };
-}
-function slabThicknessHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_SLAB_THICKNESS,
-        max: (n, sceneApi) => Math.max(MIN_SLAB_THICKNESS, slabElevationUpperBound(sceneApi.nodes(), n) - getSlabBaseElevation(n)),
-        currentValue: (n) => n.thickness ?? 0.05,
-        magneticSnap: (n, newThickness, sceneApi) => {
-            const base = getSlabBaseElevation(n);
-            const snappedTop = resolveStructuralElevationSnap(slabElevationGuideSource(n), base + newThickness, sceneApi.nodes());
-            return Math.max(MIN_SLAB_THICKNESS, snappedTop - base);
-        },
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), n.elevation ?? 0.05, sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (n, newThickness) => applySlabThicknessChange(n, newThickness),
-        previewOverrides: (n, newThickness, sceneApi) => slabChangePreviewOverrides(n, applySlabThicknessChange(n, newThickness), sceneApi),
-        placement: {
-            position: (n) => {
-                const [cx, cz] = slabHandleAnchor(n);
-                return [cx, (n.elevation ?? 0.05) + HEIGHT_HANDLE_OFFSET, cz];
-            },
-        },
-    };
-}
-function slabBaseElevationHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        shape: 'tracker',
-        gridSnap: true,
-        min: (n) => MIN_SLAB_ELEVATION - (n.thickness ?? 0.05),
-        max: (n, sceneApi) => slabElevationUpperBound(sceneApi.nodes(), n) - (n.thickness ?? 0.05),
-        currentValue: (n) => getSlabBaseElevation(n),
-        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(slabElevationGuideSource(n), newValue, sceneApi.nodes()),
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), getSlabBaseElevation(n), sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (n, newBase) => applySlabBaseElevationChange(n, newBase),
-        previewOverrides: (n, newBase, sceneApi) => slabChangePreviewOverrides(n, applySlabBaseElevationChange(n, newBase), sceneApi),
-        placement: {
-            position: (n) => {
-                const [cx, cz] = slabHandleAnchor(n);
-                return [cx, getSlabBaseElevation(n), cz];
-            },
-        },
-    };
-}
-function slabHandles(node) {
-    // A footprint's floor (base plate) has one control, its height above the
-    // ground, drawn by the editor's footprint height handle; room plates are
-    // reached through their room. Only user-drawn slabs keep these handles.
-    if (node.plateRole)
-        return [];
-    return node.recessed
-        ? [slabRecessedDepthHandle()]
-        : [slabThicknessHandle(), slabBaseElevationHandle()];
-}
-/**
- * Slab — Phase 5 batch kind, polygon-based. Stage B: `def.geometry`
- * drives the rebuild via generic <GeometrySystem>; <ParametricNodeRenderer>
- * mounts the empty group. No per-kind renderer or system file.
- *
- * Capabilities:
- *  - **No `movable`**: slab's "move" today is whole-slab translation via
- *    legacy `MoveSlabTool`, which integrates with the floor-plan boundary /
- *    hole editors. Capability-driven dispatch keeps the legacy mover.
- *  - **`surfaces.top`**: items host on the slab top at `elevation`.
- *  - `selectable`, `duplicable`, `deletable` standard.
- *
- * Relations:
- *  - `hosts: ['item']` — items mount on the slab top.
- *  - `cascadeDelete: 'descendants'` — deleting a slab removes hosted items.
- */
-export const slabDefinition = {
-    kind: 'slab',
-    snapProfile: 'structural',
-    schemaVersion: 1,
-    schema: SlabNode,
-    category: 'structure',
-    surfaceRole: 'floor',
-    extensions: {
-        [DRAFTING_SURFACE_EXTENSION_KEY]: {
-            kind: 'slab',
-        },
-        'pascal:editor/floorplan': {
-            selectionCounterparts: sameOutlineSurfaceCounterparts,
-        },
-    },
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        polygon: [],
-        holes: [],
-        holeMetadata: [],
-        elevation: 0.05,
-        thickness: 0.05,
-        recessed: false,
-        autoFromWalls: false,
-    }),
-    capabilities: {
-        reveal: { phase: 'foundation', style: 'settle', height: 0.08 },
-        revealOnEdit: [
-            'polygon',
-            'holes',
-            'elevation',
-            'thickness',
-            'recessed',
-            'recessedRimElevation',
-        ],
-        batchable: surfaceBatchable,
-        selectable: { hitVolume: 'bbox' },
-        surfaces: {
-            top: {
-                height: (n) => n.elevation,
-                supportHeight: (node, x, z, context) => {
-                    const slab = node;
-                    if (slab.polygon.length < 3 ||
-                        !pointInPolygon2D([x, z], slab.polygon, { includeBoundary: true }) ||
-                        slab.holes.some((hole) => hole.length >= 3 && pointInPolygon2D([x, z], hole, { includeBoundary: false })))
-                        return null;
-                    return liftedManualSlab(context.nodes, slab).elevation;
-                },
-            },
-        },
-        duplicable: true,
-        deletable: true,
-        // Unified slot model: one paintable floor surface with a declared default,
-        // painted through the registry `capabilities.paint` dispatch like the shelf.
-        slots: () => slabSlots(),
-        paint: slabPaint,
-    },
-    relations: {
-        hosts: ['item'],
-        cascadeDelete: 'descendants',
-    },
-    parametrics: slabParametrics,
-    handles: slabHandles,
-    measurement: {
-        features: (node) => polygonMeasurementFeatures({
-            featurePrefix: 'slab',
-            height: node.elevation,
-            label: 'Slab',
-            polygon: node.polygon,
-        }),
-        quickMeasure: (node) => slabQuickMeasurement(node),
-    },
-    // Stage D: kind-owned placement tool. Multi-click polygon drawing
-    // with 15° angle snap (Shift to defeat).
-    tool: () => import('./tool.js'),
-    // Stage D — all four slab drag-affordances live in this folder.
-    // boundary-edit / hole-edit are thin <PolygonEditor> wrappers; move
-    // is a 1:1 port of the legacy MoveSlabTool (scene.update per tick
-    // with the same history dance, no live-drag exception).
-    affordanceTools: {
-        'boundary-edit': () => import('./boundary-editor.js'),
-        'hole-edit': () => import('./hole-editor.js'),
-        move: () => import('./move-tool.js'),
-    },
-    // Stage B: pure geometry function.
-    geometry: buildSlabGeometry,
-    // Dependency tracker only — dirties level slabs when walls / sibling
-    // slabs change, since the renderable polygon derives from level context.
-    system: {
-        module: () => import('./system.js'),
-        priority: 4,
-    },
-    // The fill reads walls + sibling slabs via ctx (per-edge render offsets),
-    // so committed sibling edits must invalidate the cached floor-plan entry.
-    floorplanDependsOnSiblings: true,
-    // Stage C: floor-plan rendering. Legacy `slabPolygons` short-circuits
-    // to [] when slab is registered (see floorplan-panel.tsx).
-    floorplan: buildSlabFloorplan,
-    // 2D move handler — translates polygon by cursor delta from first
-    // pointer position. The 3D `MoveSlabTool` in `affordanceTools.move`
-    // skips events sourced from the 2D scene so the two paths don't
-    // double-write on commit.
-    floorplanMoveTarget: slabFloorplanMoveTarget,
-    // Sister to `affordanceTools['boundary-edit']` (the 3D `PolygonEditor`
-    // wrapper). The 2D version edits the same `polygon` field via SVG
-    // pointer events on the vertex handles emitted by `def.floorplan`.
-    floorplanAffordances: {
-        'move-vertex': slabMoveVertexAffordance,
-        'add-vertex': slabAddVertexAffordance,
-        'move-edge': slabMoveEdgeAffordance,
-        'delete-vertex': slabDeleteVertexAffordance,
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Trace slab outline' },
-        { key: 'Enter', label: 'Finish slab', minDraftVertices: 3 },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Slab',
-        description: 'A polygon-bounded floor surface that hosts items on top.',
-        icon: { kind: 'url', src: '/icons/floor.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 30,
-    },
-    mcp: {
-        description: 'A polygon-bounded slab (floor) with optional cutout holes.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { slabEditContribution } from './definition.edit.js';
+import { slabRenderDefinition } from './definition.render.js';
+export const slabDefinition = composeNodeDefinition(slabRenderDefinition, slabEditContribution);

package/dist/slab/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { SlabNode } from './schema.js';
+export declare const slabRenderDefinition: NodeRenderDefinition<typeof SlabNode> & {
+    kind: 'slab';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/slab/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/slab/definition.render.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAKvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CA2FxF,CAAA"}

package/dist/slab/definition.render.js

@@ -0,0 +1,92 @@
+import { liftedManualSlab, pointInPolygon2D, slabSlots, } from '@pascal-app/core';
+import { surfaceBatchable } from '../shared/node-batch/batchable.js';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
+import { buildSlabGeometry } from './geometry.js';
+import { slabQuickMeasurement } from './quick-measurement.js';
+import { SlabNode } from './schema.js';
+export const slabRenderDefinition = {
+    kind: 'slab',
+    schemaVersion: 1,
+    schema: SlabNode,
+    category: 'structure',
+    surfaceRole: 'floor',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        polygon: [],
+        holes: [],
+        holeMetadata: [],
+        elevation: 0.05,
+        thickness: 0.05,
+        recessed: false,
+        autoFromWalls: false,
+    }),
+    capabilities: {
+        reveal: { phase: 'foundation', style: 'settle', height: 0.08 },
+        revealOnEdit: [
+            'polygon',
+            'holes',
+            'elevation',
+            'thickness',
+            'recessed',
+            'recessedRimElevation',
+        ],
+        batchable: surfaceBatchable,
+        selectable: { hitVolume: 'bbox' },
+        surfaces: {
+            top: {
+                height: (n) => n.elevation,
+                supportHeight: (node, x, z, context) => {
+                    const slab = node;
+                    if (slab.polygon.length < 3 ||
+                        !pointInPolygon2D([x, z], slab.polygon, { includeBoundary: true }) ||
+                        slab.holes.some((hole) => hole.length >= 3 && pointInPolygon2D([x, z], hole, { includeBoundary: false })))
+                        return null;
+                    return liftedManualSlab(context.nodes, slab).elevation;
+                },
+            },
+        },
+        duplicable: true,
+        deletable: true,
+        // Unified slot model: one paintable floor surface with a declared default,
+        // painted through the registry `capabilities.paint` dispatch like the shelf.
+        slots: () => slabSlots(),
+    },
+    relations: {
+        hosts: ['item'],
+        cascadeDelete: 'descendants',
+    },
+    measurement: {
+        features: (node) => polygonMeasurementFeatures({
+            featurePrefix: 'slab',
+            height: node.elevation,
+            label: 'Slab',
+            polygon: node.polygon,
+        }),
+        quickMeasure: (node) => slabQuickMeasurement(node),
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    // Stage B: pure geometry function.
+    geometry: buildSlabGeometry,
+    // Dependency tracker only — dirties level slabs when walls / sibling
+    // slabs change, since the renderable polygon derives from level context.
+    system: {
+        module: () => import('./system.js'),
+        priority: 4,
+    },
+    presentation: {
+        label: 'Slab',
+        description: 'A polygon-bounded floor surface that hosts items on top.',
+        icon: { kind: 'url', src: '/icons/floor.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 30,
+    },
+    mcp: {
+        description: 'A polygon-bounded slab (floor) with optional cutout holes.',
+    },
+};

package/dist/slab/dependency-tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dependency-tracker.d.ts","sourceRoot":"","sources":["../../src/slab/dependency-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAYf,MAAM,kBAAkB,CAAA;AAsBzB,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAwDxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,SAAS,EAAE,CAoH7D"}
+{"version":3,"file":"dependency-tracker.d.ts","sourceRoot":"","sources":["../../src/slab/dependency-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAYf,MAAM,kBAAkB,CAAA;AAsBzB,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WA2DxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,SAAS,EAAE,CAoH7D"}

package/dist/slab/dependency-tracker.js

@@ -51,6 +51,9 @@ export function createSlabDependencyTracker(initialNodes) {
                             node.floorStepFinish,
                             node.floorStepOverrides,
                             node.floorEdgeFinish,
+                            // a deck's plate is its boards and frame (`buildDeckGeometry`)
+                            node.roomType,
+                            node.decking,
                         ]
                         : null);
         nodeInputs.set(node, value);