@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/roof/conical-roof-placement.js

@@ -0,0 +1,134 @@
+import { getRoofSegmentSurfaceY, } from '@pascal-app/core';
+const CUTTER_SEAT_DEPTH = 0.1;
+const FOOTPRINT_EPSILON = 1e-6;
+const CIRCLE_SEGMENTS = 32;
+const HEIGHT_GRID_STEPS = 8;
+function inverseRotatePlan(x, z, rotation) {
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return [x * cos - z * sin, x * sin + z * cos];
+}
+function worldToSegmentPlan(roof, segment, point) {
+    const [roofX, roofZ] = inverseRotatePlan(point[0] - roof.position[0], point[1] - roof.position[2], roof.rotation ?? 0);
+    return inverseRotatePlan(roofX - segment.position[0], roofZ - segment.position[2], segment.rotation ?? 0);
+}
+function pointIsInsideSegment(segment, point) {
+    if (segment.roofType === 'conical') {
+        if (Math.hypot(point[0], point[1]) > segment.width / 2 + FOOTPRINT_EPSILON)
+            return false;
+        if (segment.conicalFullCircle)
+            return true;
+        const start = segment.conicalStartAngle ?? 0;
+        const sweep = segment.conicalSweepAngle ?? Math.PI * 2;
+        if (Math.abs(sweep) >= Math.PI * 2 - FOOTPRINT_EPSILON)
+            return true;
+        const angle = Math.atan2(point[1], point[0]);
+        const directedDelta = (from, to) => {
+            const delta = (to - from) % (Math.PI * 2);
+            return delta < 0 ? delta + Math.PI * 2 : delta;
+        };
+        return sweep >= 0
+            ? directedDelta(start, angle) <= sweep + FOOTPRINT_EPSILON
+            : directedDelta(angle, start) <= -sweep + FOOTPRINT_EPSILON;
+    }
+    return (Math.abs(point[0]) <= segment.width / 2 + FOOTPRINT_EPSILON &&
+        Math.abs(point[1]) <= segment.depth / 2 + FOOTPRINT_EPSILON);
+}
+function circleBoundary(center, radius) {
+    if (radius <= FOOTPRINT_EPSILON)
+        return [[center[0], center[1]]];
+    return Array.from({ length: CIRCLE_SEGMENTS }, (_, index) => {
+        const angle = (index / CIRCLE_SEGMENTS) * Math.PI * 2;
+        return [center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius];
+    });
+}
+function circleHeightSamples(center, radius) {
+    const samples = circleBoundary(center, radius);
+    if (radius <= FOOTPRINT_EPSILON)
+        return samples;
+    for (let zIndex = 0; zIndex <= HEIGHT_GRID_STEPS; zIndex += 1) {
+        const z = -radius + (zIndex / HEIGHT_GRID_STEPS) * radius * 2;
+        for (let xIndex = 0; xIndex <= HEIGHT_GRID_STEPS; xIndex += 1) {
+            const x = -radius + (xIndex / HEIGHT_GRID_STEPS) * radius * 2;
+            if (x * x + z * z > radius * radius + FOOTPRINT_EPSILON)
+                continue;
+            samples.push([center[0] + x, center[1] + z]);
+        }
+    }
+    return samples;
+}
+function findRoofCandidate(nodes, levelId, center, radius) {
+    const boundary = circleBoundary(center, radius);
+    const heightSamples = circleHeightSamples(center, radius);
+    let best = null;
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'roof' || node.parentId !== levelId)
+            continue;
+        const roof = node;
+        for (const segmentId of roof.children ?? []) {
+            const child = nodes[segmentId];
+            if (child?.type !== 'roof-segment')
+                continue;
+            const segment = child;
+            if (!boundary.every((point) => pointIsInsideSegment(segment, worldToSegmentPlan(roof, segment, point)))) {
+                continue;
+            }
+            let minSurfaceY = Number.POSITIVE_INFINITY;
+            let maxSurfaceY = Number.NEGATIVE_INFINITY;
+            for (const point of heightSamples) {
+                const local = worldToSegmentPlan(roof, segment, point);
+                const surfaceY = roof.position[1] +
+                    segment.position[1] +
+                    getRoofSegmentSurfaceY(segment, local[0], local[1]);
+                minSurfaceY = Math.min(minSurfaceY, surfaceY);
+                maxSurfaceY = Math.max(maxSurfaceY, surfaceY);
+            }
+            if (!(Number.isFinite(minSurfaceY) && Number.isFinite(maxSurfaceY)))
+                continue;
+            if (best && best.maxSurfaceY >= maxSurfaceY)
+                continue;
+            best = {
+                roof,
+                segment,
+                localCenter: worldToSegmentPlan(roof, segment, center),
+                minSurfaceY,
+                maxSurfaceY,
+            };
+        }
+    }
+    return best;
+}
+function levelPlacement(center, curbHeight) {
+    return {
+        valid: true,
+        kind: 'level',
+        position: [center[0], 0, center[1]],
+        wallHeight: Math.max(0, curbHeight),
+        support: { kind: 'level' },
+    };
+}
+export function resolveConicalRoofPlacement({ nodes, levelId, center, radius, curbHeight, allowRoofSupport, requireRoofSupport, }) {
+    if (!allowRoofSupport)
+        return levelPlacement(center, curbHeight);
+    const candidate = findRoofCandidate(nodes, levelId, center, Math.max(0, radius));
+    if (!candidate) {
+        return requireRoofSupport
+            ? { valid: false, reason: 'no-roof-support' }
+            : levelPlacement(center, curbHeight);
+    }
+    const safeCurbHeight = Math.max(0, curbHeight);
+    const baseY = candidate.minSurfaceY - CUTTER_SEAT_DEPTH;
+    return {
+        valid: true,
+        kind: 'roof',
+        position: [center[0], baseY, center[1]],
+        wallHeight: candidate.maxSurfaceY - baseY + safeCurbHeight,
+        hostRoofId: candidate.roof.id,
+        support: {
+            kind: 'roof',
+            roofSegmentId: candidate.segment.id,
+            localPosition: candidate.localCenter,
+            curbHeight: safeCurbHeight,
+        },
+    };
+}

package/dist/roof/conical-roof.d.ts

@@ -0,0 +1,3 @@
+import { type AnyNode, type AnyNodeId, type LevelNode, RoofSegmentNode, type SceneApi, type WallNode } from '@pascal-app/core';
+export declare function createConicalRoofSectorAboveWall(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>, sceneApi: SceneApi, targetLevelId: LevelNode['id']): RoofSegmentNode['id'] | null;
+//# sourceMappingURL=conical-roof.d.ts.map

package/dist/roof/conical-roof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conical-roof.d.ts","sourceRoot":"","sources":["../../src/roof/conical-roof.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,SAAS,EAEd,eAAe,EAGf,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,GAC7B,eAAe,CAAC,IAAI,CAAC,GAAG,IAAI,CAkD9B"}

package/dist/roof/conical-roof.js

@@ -0,0 +1,53 @@
+import { getLevelBelow, getWallArcData, RoofNode, RoofSegmentNode, resolveLevelId, resolveRoofWallTopElevation, } from '@pascal-app/core';
+const DEFAULT_CONICAL_ROOF_PITCH = 40;
+export function createConicalRoofSectorAboveWall(wall, nodes, sceneApi, targetLevelId) {
+    const arc = getWallArcData(wall);
+    if (!(arc && nodes[targetLevelId]?.type === 'level'))
+        return null;
+    const completeNodes = nodes;
+    const sourceLevelId = resolveLevelId(wall, completeNodes);
+    const levelBelowId = getLevelBelow(targetLevelId, completeNodes)?.id;
+    if (sourceLevelId !== targetLevelId && sourceLevelId !== levelBelowId)
+        return null;
+    const existingRoof = Object.values(nodes).find((node) => node.type === 'roof' &&
+        node.parentId === targetLevelId &&
+        typeof node.metadata === 'object' &&
+        node.metadata !== null &&
+        !Array.isArray(node.metadata) &&
+        node.metadata.conicalSourceWallId === wall.id);
+    if (existingRoof) {
+        const existingSegment = existingRoof.children
+            .map((childId) => nodes[childId])
+            .find((node) => node?.type === 'roof-segment');
+        if (existingSegment)
+            return existingSegment.id;
+    }
+    const roofCount = Object.values(nodes).filter((node) => node?.type === 'roof').length;
+    const segment = RoofSegmentNode.parse({
+        roofType: 'conical',
+        width: arc.radius * 2,
+        depth: arc.radius * 2,
+        wallHeight: 0,
+        pitch: DEFAULT_CONICAL_ROOF_PITCH,
+        conicalStartAngle: arc.startAngle,
+        conicalSweepAngle: arc.delta,
+        conicalFullCircle: true,
+    });
+    const roof = RoofNode.parse({
+        name: `Roof ${roofCount + 1}`,
+        metadata: { conicalSourceWallId: wall.id },
+        support: { kind: 'walls' },
+        position: [arc.center.x, resolveRoofWallTopElevation(targetLevelId, wall, nodes), arc.center.y],
+        children: [segment.id],
+    });
+    const ops = [
+        { node: roof, parentId: targetLevelId },
+        { node: segment, parentId: roof.id },
+    ];
+    if (sceneApi.createMany)
+        sceneApi.createMany(ops);
+    else
+        for (const op of ops)
+            sceneApi.upsert(op.node, op.parentId);
+    return segment.id;
+}

package/dist/roof/definition.d.ts

@@ -1,16 +1,9 @@
 import { type NodeDefinition } from '@pascal-app/core';
 import { RoofNode } from './schema';
 /**
- * Roof — Stage A registration. Wrap-exports the legacy `RoofRenderer`
- * + `RoofSystem` (geometry generation via `getRoofSegmentBrushes` +
- * CSG). Inspector / move stay legacy until Stage B-E. `floorplan` draws
- * the merged silhouette (union of the child segments' footprints), so a
- * multi-segment roof reads as one combined shape rather than stacked
- * rectangles.
- *
- * Roof is a "composite" node — it has `roof-segment` children that
- * own per-segment geometry. The parent roof handles overall framing;
- * each segment is its own registered kind (see `roof-segment`).
+ * Roof is a composite node with `roof-segment` children that own the
+ * per-segment geometry. Its floor-plan contribution merges those child
+ * footprints so a multi-segment roof reads as one shape.
  */
 export declare const roofDefinition: NodeDefinition<typeof RoofNode>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/roof/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsEnC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAoG1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAgK1D,CAAA"}

package/dist/roof/definition.js

@@ -1,6 +1,9 @@
 import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
+import { DRAFTING_SURFACE_EXTENSION_KEY } from '@pascal-app/editor';
 import { buildRoofFloorplan } from './floorplan';
 import { roofParametrics } from './parametrics';
+import useRoofFootprintSource from './roof-footprint-source';
+import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode';
 import { RoofNode } from './schema';
 const MOVE_FRONT_OFFSET = 0.35;
 const MIN_ROOF_FOOTPRINT = 1;
@@ -45,7 +48,12 @@ function roofMoveHandle() {
                 return [(bounds.minX + bounds.maxX) / 2, 0.02, bounds.maxZ + MOVE_FRONT_OFFSET];
             },
         },
-        apply: (_node, position) => ({ position: [position[0], position[1], position[2]] }),
+        apply: (node, position) => ({
+            position: [position[0], position[1], position[2]],
+            ...(node.support?.kind === 'walls' && Math.abs(position[1] - node.position[1]) > 1e-4
+                ? { support: { kind: 'level' } }
+                : {}),
+        }),
         snapExtents: (node, sceneApi) => {
             const bounds = getRoofFootprintBounds(node, sceneApi);
             const width = Math.max(bounds.maxX - bounds.minX, MIN_ROOF_FOOTPRINT);
@@ -56,17 +64,20 @@ function roofMoveHandle() {
     };
 }
 const roofHandles = [roofMoveHandle()];
+function isManagedLeanToRoof(node) {
+    const metadata = node.metadata;
+    if (!(metadata && typeof metadata === 'object' && !Array.isArray(metadata)))
+        return false;
+    const record = metadata;
+    return record.managedByLeanTo !== undefined && record.leanToRole === 'roof';
+}
+function resolveRoofHandles(node) {
+    return isManagedLeanToRoof(node) ? [] : roofHandles;
+}
 /**
- * Roof — Stage A registration. Wrap-exports the legacy `RoofRenderer`
- * + `RoofSystem` (geometry generation via `getRoofSegmentBrushes` +
- * CSG). Inspector / move stay legacy until Stage B-E. `floorplan` draws
- * the merged silhouette (union of the child segments' footprints), so a
- * multi-segment roof reads as one combined shape rather than stacked
- * rectangles.
- *
- * Roof is a "composite" node — it has `roof-segment` children that
- * own per-segment geometry. The parent roof handles overall framing;
- * each segment is its own registered kind (see `roof-segment`).
+ * Roof is a composite node with `roof-segment` children that own the
+ * per-segment geometry. Its floor-plan contribution merges those child
+ * footprints so a multi-segment roof reads as one shape.
  */
 export const roofDefinition = {
     kind: 'roof',
@@ -74,10 +85,15 @@ export const roofDefinition = {
     // Drafted as a 2-corner footprint (axis-aligned bbox), not a directional
     // edge → no angle-lock mode (grid / lines / off only).
     snapDraftDirectional: false,
-    schemaVersion: 1,
+    schemaVersion: 3,
     schema: RoofNode,
     category: 'structure',
     surfaceRole: 'roof',
+    extensions: {
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'roof',
+        },
+    },
     defaults: () => {
         const stub = RoofNodeSchema.parse({ id: 'roof_default', type: 'roof' });
         const { id: _id, type: _type, ...rest } = stub;
@@ -146,8 +162,62 @@ export const roofDefinition = {
     affordanceTools: {
         move: () => import('../shared/move-roof-tool'),
     },
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Left click', label: 'Set roof footprint' },
+        {
+            key: 'P',
+            label: 'Placement',
+            visible: conicalRoofToolHintVisibility,
+            chip: {
+                subscribe: (onChange) => useRoofPlacementMode.subscribe(onChange),
+                value: () => useRoofPlacementMode.getState().mode,
+                cycle: () => useRoofPlacementMode.getState().cycleMode(),
+                labels: {
+                    auto: 'Placement: Auto',
+                    ground: 'Placement: Ground',
+                    roof: 'Placement: Roof',
+                },
+                icons: {
+                    auto: 'lucide:scan-search',
+                    ground: 'lucide:land-plot',
+                    roof: 'lucide:house',
+                },
+                tooltip: 'Placement surface - click or press P to cycle',
+            },
+        },
+        {
+            key: 'R',
+            label: 'Rotate roof direction 90°',
+            visible: standardRoofToolHintVisibility,
+        },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    toolOptions: [
+        {
+            id: 'footprintSource',
+            label: 'Create from',
+            choices: [
+                {
+                    value: 'draw',
+                    label: 'Draw',
+                    description: 'Draw the roof footprint with two corner clicks.',
+                },
+                {
+                    value: 'room',
+                    label: 'Room',
+                    description: 'Hover a room to preview its boundary, then click to place.',
+                },
+            ],
+            subscribe: (onChange) => useRoofFootprintSource.subscribe(onChange),
+            value: () => useRoofFootprintSource.getState().source,
+            set: (value) => useRoofFootprintSource.getState().setSource(value === 'room' ? 'room' : 'draw'),
+            // Conical roofs always build from a curved wall pick; the row would lie.
+            visible: standardRoofToolHintVisibility,
+        },
+    ],
     parametrics: roofParametrics,
-    handles: roofHandles,
+    handles: resolveRoofHandles,
     floorplan: buildRoofFloorplan,
     renderer: {
         kind: 'parametric',

package/dist/roof/floorplan.d.ts

@@ -1,15 +1,8 @@
-import type { FloorplanGeometry, GeometryContext, RoofNode } from '@pascal-app/core';
+import { type FloorplanGeometry, type GeometryContext, type RoofNode } from '@pascal-app/core';
 /**
  * Roof-level floor-plan builder. Draws the whole merged-roof plan: the
- * unioned silhouette, the valley diagonals at concave junctions, and every
- * segment's ridge/hip/break linework — clipped so a line stops at the valley
- * where its segment overlaps a neighbour, instead of running on at the
- * segment's full length into the cut-away part.
- *
- * Drawing all the linework here (rather than per-segment) is what lets the
- * clip work: the valleys and the neighbouring footprints are all in hand, so
- * each line can be trimmed to the actual merged geometry. The segment
- * builder keeps only its hit-target / selection chrome.
+ * unioned silhouette and every segment's ridge/hip/break linework. The
+ * segment builder keeps only its hit-target / selection chrome.
  *
  * Composition uses the floor plan's negated-rotation convention
  * (segment-local → roof-local → plan). `unionPolygons` returns one ring per

package/dist/roof/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,QAAQ,EAET,MAAM,kBAAkB,CAAA;AAqHzB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAuJjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAuIzB;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAwHjG"}