@pascal-app/core 0.8.0 → 0.9.1

package/dist/systems/stair/stair-opening-sync.test.js

@@ -1,8 +1,8 @@
 import { describe, expect, test } from 'bun:test';
-import { BuildingNode, LevelNode, SlabNode, StairNode, StairSegmentNode } from '../../schema';
+import { BuildingNode, CeilingNode, LevelNode, SlabNode, StairNode, StairSegmentNode, } from '../../schema';
 import { syncAutoStairOpenings } from './stair-opening-sync';
 describe('syncAutoStairOpenings', () => {
-    test('only applies stair holes to destination slabs that contain the opening', () => {
+    test('only applies stair holes to destination slabs that overlap the opening', () => {
         const building = BuildingNode.parse({ name: 'Building' });
         const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
         const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
@@ -60,4 +60,387 @@ describe('syncAutoStairOpenings', () => {
         expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
         expect(bedroomUpdate).toBeUndefined();
     });
+    test('applies stair holes to a later destination slab when the configured offset overhangs the slab edge', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_edge',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_edge',
+            name: 'Edge Stair',
+            parentId: ground.id,
+            position: [2, 0, 0],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            openingOffset: 0.08,
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        const hole = landingUpdate?.data.holes?.[0];
+        expect(hole).toBeDefined();
+        expect(Math.min(...hole.map(([, z]) => z))).toBeCloseTo(-0.08);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
+    test('does not apply stair holes to slabs on another building with a matching level number', () => {
+        const buildingA = BuildingNode.parse({ name: 'Building A' });
+        const groundA = LevelNode.parse({ name: 'Ground A', level: 0, parentId: buildingA.id });
+        const upperA = LevelNode.parse({ name: 'Upper A', level: 1, parentId: buildingA.id });
+        const buildingB = BuildingNode.parse({ name: 'Building B' });
+        const upperB = LevelNode.parse({ name: 'Upper B', level: 1, parentId: buildingB.id });
+        const slabA = SlabNode.parse({
+            name: 'Upper A Slab',
+            parentId: upperA.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+        });
+        const slabB = SlabNode.parse({
+            name: 'Upper B Slab',
+            parentId: upperB.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_scoped',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_scoped',
+            name: 'Scoped Stair',
+            parentId: groundA.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: groundA.id,
+            toLevelId: upperA.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([
+            buildingA,
+            groundA,
+            upperA,
+            buildingB,
+            upperB,
+            slabA,
+            slabB,
+            stair,
+            { ...segment, parentId: stair.id },
+        ].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        expect(updates.find((update) => update.id === slabA.id)?.data.holes).toHaveLength(1);
+        expect(updates.find((update) => update.id === slabB.id)).toBeUndefined();
+    });
+    test('uses the parent level when a stair has stale from-level data', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 8],
+                [0, 8],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_stale_from',
+            width: 1,
+            length: 6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_stale_from',
+            name: 'Stale From Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: 'default',
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        const hole = landingUpdate?.data.holes?.[0];
+        expect(hole).toBeDefined();
+        expect(Math.min(...hole.map(([, z]) => z))).toBeGreaterThan(0.9);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
+    test('infers the destination level when a destination stair has blank level fields', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 8],
+                [0, 8],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_blank_levels',
+            width: 1,
+            length: 6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_blank_levels',
+            name: 'Blank Level Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: '',
+            toLevelId: '',
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        expect(landingUpdate?.data.holes).toHaveLength(1);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
+    test('infers the destination level when a destination stair targets its source level', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 8],
+                [0, 8],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_self_target',
+            width: 1,
+            length: 6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_self_target',
+            name: 'Self Target Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: ground.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        expect(landingUpdate?.data.holes).toHaveLength(1);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+    });
+    test('does not add stair holes when a manual surface hole already covers them', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const manualOpening = [
+            [1.0, 0.0],
+            [3.0, 0.0],
+            [3.0, 3.0],
+            [1.0, 3.0],
+        ];
+        const sourceCeiling = CeilingNode.parse({
+            name: 'Source Ceiling',
+            parentId: ground.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_main',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_main',
+            name: 'Main Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([
+            building,
+            ground,
+            upper,
+            sourceCeiling,
+            landingSlab,
+            stair,
+            { ...segment, parentId: stair.id },
+        ].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        expect(updates.find((update) => update.id === landingSlab.id)).toBeUndefined();
+        expect(updates.find((update) => update.id === sourceCeiling.id)).toBeUndefined();
+    });
+    test('adds stair holes when an existing manual hole is too small', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const smallManualOpening = [
+            [1.8, 1.6],
+            [2.2, 1.6],
+            [2.2, 2.1],
+            [1.8, 2.1],
+        ];
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [smallManualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_main',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_main',
+            name: 'Main Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        expect(landingUpdate?.data.holes).toHaveLength(2);
+        expect(landingUpdate?.data.holes?.[0]).toEqual(smallManualOpening);
+        expect(landingUpdate?.data.holeMetadata).toEqual([
+            { source: 'manual' },
+            { source: 'stair', stairId: stair.id },
+        ]);
+    });
+    test('removes stale auto stair holes when a manual hole overlaps the stair opening', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const manualOpening = [
+            [1.0, 0.0],
+            [3.0, 0.0],
+            [3.0, 3.0],
+            [1.0, 3.0],
+        ];
+        const staleAutoOpening = [
+            [1.5, 1],
+            [2.5, 1],
+            [2.5, 2.8],
+            [1.5, 2.8],
+        ];
+        const landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening, staleAutoOpening],
+            holeMetadata: [{ source: 'manual' }, { source: 'stair', stairId: 'stair_main' }],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_main',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_main',
+            name: 'Main Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, landingSlab, stair, { ...segment, parentId: stair.id }].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        expect(landingUpdate?.data.holes).toEqual([manualOpening]);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'manual' }]);
+    });
 });

package/dist/systems/stair/stair-opening-system.d.ts

@@ -0,0 +1,2 @@
+export declare const StairOpeningSystem: () => null;
+//# sourceMappingURL=stair-opening-system.d.ts.map

package/dist/systems/stair/stair-opening-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-system.tsx"],"names":[],"mappings":"AA2CA,eAAO,MAAM,kBAAkB,YAyF9B,CAAA"}

package/dist/systems/stair/stair-opening-system.js

@@ -0,0 +1,104 @@
+'use client';
+import { useEffect, useRef } from 'react';
+import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control';
+import useLiveNodeOverrides from '../../store/use-live-node-overrides';
+import useLiveTransforms from '../../store/use-live-transforms';
+import useScene from '../../store/use-scene';
+import { createSurfaceOpeningPreviewController, getNodesWithLiveStairOpeningInputs, hasLiveStairOpeningInputs, } from './stair-opening-preview';
+import { syncAutoStairOpenings } from './stair-opening-sync';
+function isOpeningRelevantNode(node) {
+    return (node?.type === 'building' ||
+        node?.type === 'ceiling' ||
+        node?.type === 'level' ||
+        node?.type === 'slab' ||
+        node?.type === 'stair' ||
+        node?.type === 'stair-segment');
+}
+function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
+    if (nextNodes === prevNodes)
+        return false;
+    const ids = new Set([...Object.keys(nextNodes), ...Object.keys(prevNodes)]);
+    for (const id of ids) {
+        const nextNode = nextNodes[id];
+        const prevNode = prevNodes[id];
+        if (nextNode === prevNode)
+            continue;
+        if (isOpeningRelevantNode(nextNode) || isOpeningRelevantNode(prevNode))
+            return true;
+    }
+    return false;
+}
+export const StairOpeningSystem = () => {
+    const syncingAutoOpeningsRef = useRef(false);
+    const syncingPreviewOpeningsRef = useRef(false);
+    const previewControllerRef = useRef(createSurfaceOpeningPreviewController());
+    useEffect(() => {
+        const applyUpdates = (updates) => {
+            if (updates.length === 0)
+                return;
+            syncingAutoOpeningsRef.current = true;
+            pauseSceneHistory(useScene);
+            try {
+                useScene.getState().updateNodes(updates);
+            }
+            finally {
+                resumeSceneHistory(useScene);
+            }
+            queueMicrotask(() => {
+                syncingAutoOpeningsRef.current = false;
+            });
+        };
+        const applyPreviewUpdates = (updates) => {
+            syncingPreviewOpeningsRef.current = true;
+            previewControllerRef.current.apply(updates);
+            queueMicrotask(() => {
+                syncingPreviewOpeningsRef.current = false;
+            });
+        };
+        const clearPreviewUpdates = () => {
+            if (previewControllerRef.current.previewSurfaceIds.size === 0)
+                return;
+            syncingPreviewOpeningsRef.current = true;
+            previewControllerRef.current.clear();
+            queueMicrotask(() => {
+                syncingPreviewOpeningsRef.current = false;
+            });
+        };
+        const refreshLivePreview = () => {
+            if (syncingPreviewOpeningsRef.current)
+                return;
+            const nodes = useScene.getState().nodes;
+            const liveTransforms = useLiveTransforms.getState().transforms;
+            const liveOverrides = useLiveNodeOverrides.getState().overrides;
+            const previewSurfaceIds = previewControllerRef.current.previewSurfaceIds;
+            if (!hasLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)) {
+                clearPreviewUpdates();
+                return;
+            }
+            applyPreviewUpdates(syncAutoStairOpenings(getNodesWithLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)));
+        };
+        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
+        refreshLivePreview();
+        const unsubscribeScene = useScene.subscribe((state, prevState) => {
+            if (syncingAutoOpeningsRef.current)
+                return;
+            if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
+                return;
+            applyUpdates(syncAutoStairOpenings(state.nodes));
+            refreshLivePreview();
+        });
+        const unsubscribeLiveTransforms = useLiveTransforms.subscribe(() => {
+            refreshLivePreview();
+        });
+        const unsubscribeLiveOverrides = useLiveNodeOverrides.subscribe(() => {
+            refreshLivePreview();
+        });
+        return () => {
+            unsubscribeScene();
+            unsubscribeLiveTransforms();
+            unsubscribeLiveOverrides();
+            previewControllerRef.current.clear();
+        };
+    }, []);
+    return null;
+};

package/dist/systems/wall/wall-move.d.ts

@@ -0,0 +1,48 @@
+import type { WallNode } from '../../schema';
+export type WallPlanPoint = [number, number];
+export type WallMoveAxis = [number, number];
+export type WallMoveEndpoint = 'start' | 'end';
+export type WallMoveBridgePlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+    wall: TWall;
+    originalPoint: WallPlanPoint;
+    movedEndpoint: WallMoveEndpoint;
+};
+export type WallMoveLinkedWallTargetPlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+    wall: TWall;
+    originalPoint: WallPlanPoint;
+    targetPoint: WallPlanPoint;
+};
+export type WallMoveJunctionPlan<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>> = {
+    linkedWallsToMove: TWall[];
+    linkedWallTargetPlans: Array<WallMoveLinkedWallTargetPlan<TWall>>;
+    bridgePlans: Array<WallMoveBridgePlan<TWall>>;
+    wallsToDelete: TWall[];
+};
+export declare function getPerpendicularWallMoveAxis(start: WallPlanPoint, end: WallPlanPoint): WallMoveAxis | null;
+export declare function constrainWallMoveDeltaToAxis(deltaX: number, deltaZ: number, axis: WallMoveAxis | null): WallPlanPoint;
+/**
+ * Apply a junction plan to a list of linked walls, producing the per-wall
+ * endpoint updates. Mirrors the 3D `MoveWallTool`'s drag-preview behavior
+ * so the 2D move handler can drive the same scene topology.
+ *
+ * `linkedWallTargetPlans` take precedence over `linkedWallsToMove` — when
+ * the planner emits a target plan for a same-direction-consumed wall the
+ * matchPoint/targetPoint pair encodes the pivot, not the original ↔ next
+ * endpoint mapping.
+ */
+export declare function getLinkedWallUpdates<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(linkedWalls: Array<{
+    wall: TWall;
+    matchPoint?: WallPlanPoint;
+    targetPoint?: WallPlanPoint;
+}>, originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): Array<{
+    id: TWall['id'];
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+}>;
+export declare function getPlannedLinkedWallUpdates<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(plan: WallMoveJunctionPlan<TWall>, originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): Array<{
+    id: TWall['id'];
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+}>;
+export declare function planWallMoveJunctions<TWall extends Pick<WallNode, 'id' | 'start' | 'end'>>(linkedWalls: TWall[], originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): WallMoveJunctionPlan<TWall>;
+//# sourceMappingURL=wall-move.d.ts.map

package/dist/systems/wall/wall-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-move.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-move.ts"],"names":[],"mappings":"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"}