@pascal-app/core 1.0.0-beta.5 → 1.0.0

package/dist/systems/roof/roof-elevation-system.js

@@ -0,0 +1,94 @@
+'use client';
+import { useEffect } from 'react';
+import { getSceneHistoryPauseDepth, notifySceneCommit, pauseSceneHistory, resumeSceneHistory, } from '../../store/history-control';
+import useScene from '../../store/use-scene';
+import { resolveRoofElevation } from './roof-elevation';
+const ROOF_ELEVATION_EPSILON = 1e-4;
+function sceneSnapshot() {
+    const { nodes, rootNodeIds, collections, materials, installedPlugins } = useScene.getState();
+    return { nodes, rootNodeIds, collections, materials, installedPlugins };
+}
+function isElevationRelevant(node) {
+    return (node?.type === 'roof' ||
+        node?.type === 'wall' ||
+        node?.type === 'slab' ||
+        node?.type === 'level' ||
+        node?.type === 'building' ||
+        node?.type === 'site');
+}
+export function initializeRoofElevationSync() {
+    let disposed = false;
+    let queued = false;
+    let syncing = false;
+    const schedule = () => {
+        if (queued)
+            return;
+        queued = true;
+        // Wall bases use the spatial grid, whose listener must finish before this pass.
+        queueMicrotask(() => {
+            queued = false;
+            if (disposed)
+                return;
+            const { nodes, updateNodes, readOnly } = useScene.getState();
+            if (readOnly)
+                return;
+            const updates = [];
+            for (const node of Object.values(nodes)) {
+                if (node.type !== 'roof' || node.support?.kind !== 'walls')
+                    continue;
+                const elevation = resolveRoofElevation(node, nodes);
+                if (Math.abs(node.position[1] - elevation) <= ROOF_ELEVATION_EPSILON)
+                    continue;
+                updates.push({
+                    id: node.id,
+                    data: { position: [node.position[0], elevation, node.position[2]] },
+                });
+            }
+            if (updates.length === 0)
+                return;
+            const before = sceneSnapshot();
+            const publishCommit = useScene.temporal.getState().isTracking && getSceneHistoryPauseDepth() === 0;
+            syncing = true;
+            pauseSceneHistory(useScene);
+            try {
+                updateNodes(updates);
+            }
+            finally {
+                resumeSceneHistory(useScene);
+                syncing = false;
+            }
+            // Deferred writes miss the originating commit; publish the settled roof without
+            // another undo step. An outer pause belongs to a gesture that owns its commit.
+            if (publishCommit) {
+                notifySceneCommit({
+                    origin: 'local',
+                    before,
+                    current: sceneSnapshot(),
+                    changedNodeIds: new Set(updates.map(({ id }) => id)),
+                });
+            }
+        });
+    };
+    const unsubscribe = useScene.subscribe((state, previous) => {
+        if (syncing || state.nodes === previous.nodes)
+            return;
+        const ids = new Set([...Object.keys(state.nodes), ...Object.keys(previous.nodes)]);
+        for (const id of ids) {
+            const next = state.nodes[id];
+            const prev = previous.nodes[id];
+            if (next !== prev && (isElevationRelevant(next) || isElevationRelevant(prev))) {
+                schedule();
+                return;
+            }
+        }
+    });
+    schedule();
+    return () => {
+        disposed = true;
+        unsubscribe();
+    };
+}
+export function RoofElevationSystem() {
+    useEffect(initializeRoofElevationSync, []);
+    return null;
+}

package/dist/systems/roof/roof-elevation.d.ts

@@ -0,0 +1,4 @@
+import type { AnyNode, LevelNode, RoofNode, WallNode } from '../../schema';
+export declare function resolveRoofWallTopElevation(targetLevelId: LevelNode['id'], wall: WallNode, nodes: Readonly<Record<string, AnyNode>>, elevations?: Map<string, import("../..").LevelElevation>): number;
+export declare function resolveRoofElevation(roof: RoofNode, nodes: Readonly<Record<string, AnyNode>>): number;
+//# sourceMappingURL=roof-elevation.d.ts.map

package/dist/systems/roof/roof-elevation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-elevation.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAmB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAM3F,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,8CAA4B,GACrC,MAAM,CASR;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAwFR"}

package/dist/systems/roof/roof-elevation.js

@@ -0,0 +1,95 @@
+import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '../../hooks/spatial-grid/spatial-grid-manager';
+import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
+import { findLevelBelowId, getLevelElevations } from '../../services/storey';
+import { wallOverlapsSlabFootprint } from '../slab/slab-support';
+import { getWallArcData } from '../wall/wall-curve';
+import { resolveRoomRoofFootprintOnLevel } from './roof-footprint';
+export function resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations = getLevelElevations(nodes)) {
+    const sourceLevelY = elevations.get(resolveLevelId(wall, nodes))?.baseY ?? 0;
+    const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0;
+    return (sourceLevelY +
+        getWallBaseElevationForNodes(wall, nodes) +
+        getWallEffectiveHeightForNodes(wall, nodes) -
+        targetLevelY);
+}
+export function resolveRoofElevation(roof, nodes) {
+    if (roof.support?.kind !== 'walls')
+        return roof.position[1];
+    const levelId = resolveLevelId(roof, nodes);
+    if (nodes[levelId]?.type !== 'level')
+        return roof.position[1];
+    const elevations = getLevelElevations(nodes);
+    // A roof usually sits on the storey above its walls, but the top floor (or a
+    // roof armed from the walls' own level) keeps roof and walls on one level.
+    const belowId = findLevelBelowId(levelId, elevations);
+    const candidateWallIds = [levelId, belowId]
+        .map((id) => (id ? nodes[id] : undefined))
+        .filter((node) => node?.type === 'level')
+        .flatMap((level) => level.children);
+    const conicalSegments = roof.children
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'roof-segment' && node.roofType === 'conical');
+    const cos = Math.cos(roof.rotation);
+    const sin = Math.sin(roof.rotation);
+    const toLevel = (x, z) => [
+        roof.position[0] + x * cos + z * sin,
+        roof.position[2] - x * sin + z * cos,
+    ];
+    // Walls under the footprint, closed room or not: a room missing a wall, an
+    // L-shaped room whose centre falls outside, or a redrawn enclosure all still
+    // hold the roof up. The band test is curve- and thickness-aware and
+    // boundary-inclusive, so perimeter walls on the footprint edge count.
+    const footprints = roof.children
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'roof-segment')
+        .map((segment) => {
+        const c = Math.cos(segment.rotation);
+        const s = Math.sin(segment.rotation);
+        const halfW = segment.width / 2;
+        const halfD = segment.depth / 2;
+        const corners = [
+            [-halfW, -halfD],
+            [halfW, -halfD],
+            [halfW, halfD],
+            [-halfW, halfD],
+        ];
+        return corners.map(([x, z]) => toLevel(segment.position[0] + x * c + z * s, segment.position[2] - x * s + z * c));
+    });
+    const wallIds = conicalSegments.length
+        ? candidateWallIds.filter((id) => {
+            const wall = nodes[id];
+            if (wall?.type !== 'wall')
+                return false;
+            const arc = getWallArcData(wall);
+            if (!arc)
+                return false;
+            return conicalSegments.some((segment) => {
+                const [centerX, centerZ] = toLevel(segment.position[0], segment.position[2]);
+                return (Math.hypot(arc.center.x - centerX, arc.center.y - centerZ) <= 1e-4 &&
+                    Math.abs(arc.radius - segment.width / 2) <= 1e-4);
+            });
+        })
+        : footprints.length
+            ? candidateWallIds.filter((id) => {
+                const wall = nodes[id];
+                return (wall?.type === 'wall' &&
+                    footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon)));
+            })
+            : ([levelId, belowId]
+                .map((id) => id
+                ? resolveRoomRoofFootprintOnLevel(id, nodes, [
+                    roof.position[0],
+                    roof.position[2],
+                ])
+                : null)
+                .find((target) => target !== null)?.wallIds ?? []);
+    let highest;
+    for (const id of wallIds) {
+        const wall = nodes[id];
+        if (wall?.type !== 'wall')
+            continue;
+        const top = resolveRoofWallTopElevation(levelId, wall, nodes, elevations);
+        highest = highest === undefined ? top : Math.max(highest, top);
+    }
+    return highest ?? roof.position[1];
+}

package/dist/systems/roof/roof-footprint.d.ts

@@ -0,0 +1,17 @@
+import type { AnyNode, LevelNode, WallNode } from '../../schema';
+export type RoofFootprintTarget = {
+    id: string;
+    polygon: Array<[number, number]>;
+    wallIds: WallNode['id'][];
+    center: [number, number];
+    width: number;
+    depth: number;
+    rotation: number;
+    rectangular: boolean;
+};
+export declare function fitRoofFootprint(id: string, polygon: Array<[number, number]>, wallIds: WallNode['id'][]): RoofFootprintTarget | null;
+export declare function resolveRoomRoofFootprint(levelId: LevelNode['id'], nodes: Readonly<Record<string, AnyNode>>, point: [number, number], options?: {
+    rectangularOnly?: boolean;
+}): RoofFootprintTarget | null;
+export declare function resolveRoomRoofFootprintOnLevel(levelId: LevelNode['id'], nodes: Readonly<Record<string, AnyNode>>, point: [number, number]): RoofFootprintTarget | null;
+//# sourceMappingURL=roof-footprint.d.ts.map

package/dist/systems/roof/roof-footprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-footprint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGhE,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAA;IACzB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAWD,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,GACxB,mBAAmB,GAAG,IAAI,CAqD5B;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,mBAAmB,GAAG,IAAI,CAW5B;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,mBAAmB,GAAG,IAAI,CAW5B"}

package/dist/systems/roof/roof-footprint.js

@@ -0,0 +1,83 @@
+import { pointInPolygon as pointInPolygon2D } from '../../lib/polygon-relations';
+import { detectSpacesForLevel } from '../../lib/space-detection';
+import { getLevelBelow } from '../../services/storey';
+function polygonArea(polygon) {
+    return Math.abs(polygon.reduce((area, point, index) => {
+        const next = polygon[(index + 1) % polygon.length];
+        return next ? area + point[0] * next[1] - next[0] * point[1] : area;
+    }, 0) / 2);
+}
+export function fitRoofFootprint(id, polygon, wallIds) {
+    if (polygon.length < 3)
+        return null;
+    let best;
+    for (let index = 0; index < polygon.length; index++) {
+        const point = polygon[index];
+        const next = polygon[(index + 1) % polygon.length];
+        if (!(point && next))
+            continue;
+        const rotation = Math.atan2(next[1] - point[1], next[0] - point[0]);
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        const rotated = polygon.map(([x, z]) => [x * cos + z * sin, -x * sin + z * cos]);
+        const xs = rotated.map(([x]) => x);
+        const zs = rotated.map(([, z]) => z);
+        const minX = Math.min(...xs);
+        const maxX = Math.max(...xs);
+        const minZ = Math.min(...zs);
+        const maxZ = Math.max(...zs);
+        const width = maxX - minX;
+        const depth = maxZ - minZ;
+        const area = width * depth;
+        if (area <= 0 || (best && best.area <= area))
+            continue;
+        const localCenterX = (minX + maxX) / 2;
+        const localCenterZ = (minZ + maxZ) / 2;
+        best = {
+            center: [localCenterX * cos - localCenterZ * sin, localCenterX * sin + localCenterZ * cos],
+            width,
+            depth,
+            rotation: -rotation,
+            area,
+        };
+    }
+    if (!best)
+        return null;
+    return {
+        id,
+        polygon,
+        wallIds,
+        center: best.center,
+        width: best.width,
+        depth: best.depth,
+        rotation: best.rotation,
+        rectangular: polygonArea(polygon) / best.area >= 0.96,
+    };
+}
+export function resolveRoomRoofFootprint(levelId, nodes, point, options = {}) {
+    const activeTarget = resolveRoomRoofFootprintOnLevel(levelId, nodes, point);
+    if (activeTarget && (!options.rectangularOnly || activeTarget.rectangular))
+        return activeTarget;
+    if (activeTarget)
+        return null;
+    const levelBelow = getLevelBelow(levelId, nodes);
+    const levelBelowTarget = levelBelow
+        ? resolveRoomRoofFootprintOnLevel(levelBelow.id, nodes, point)
+        : null;
+    return levelBelowTarget && (!options.rectangularOnly || levelBelowTarget.rectangular)
+        ? levelBelowTarget
+        : null;
+}
+export function resolveRoomRoofFootprintOnLevel(levelId, nodes, point) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const walls = level.children
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'wall');
+    const spaces = detectSpacesForLevel(levelId, walls)
+        .spaces.filter((space) => !space.isExterior && pointInPolygon2D(point, space.polygon))
+        .sort((left, right) => polygonArea(left.polygon) - polygonArea(right.polygon));
+    const space = spaces[0];
+    return space ? fitRoofFootprint(space.id, space.polygon, space.wallIds) : null;
+}

package/dist/systems/stair/stair-flight.d.ts

@@ -0,0 +1,17 @@
+import type { AnyNode, StairNode } from '../../schema';
+import { StairSegmentNode } from '../../schema';
+export type StairFlightOverrides = Partial<Pick<StairSegmentNode, 'width' | 'length' | 'height' | 'stepCount' | 'attachmentSide' | 'fillToFloor' | 'thickness'>>;
+/**
+ * The single definition of a default straight flight. Anything left out falls
+ * through to the `StairSegmentNode` schema defaults (length 3 m, 10 steps,
+ * filled to floor) rather than being spelled again per call site, so the stair
+ * tool's seed segment, the flight the panel materializes when a curved stair
+ * becomes straight, and the viewer's fallback body all describe one stair.
+ */
+export declare function createDefaultStairSegment(overrides?: StairFlightOverrides): StairSegmentNode;
+/**
+ * The flight a straight stair implies from its own fields — used wherever a
+ * straight stair has to stand in for missing `stair-segment` children.
+ */
+export declare function createStairFlightFromStair(stair: StairNode, nodes: Record<string, AnyNode>): StairSegmentNode;
+//# sourceMappingURL=stair-flight.d.ts.map

package/dist/systems/stair/stair-flight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-flight.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-flight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAM/C,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,IAAI,CACF,gBAAgB,EAChB,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,GAAG,gBAAgB,GAAG,aAAa,GAAG,WAAW,CAC7F,CACF,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,GAAE,oBAAyB,GAAG,gBAAgB,CAEhG;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,gBAAgB,CAQlB"}

package/dist/systems/stair/stair-flight.js

@@ -0,0 +1,27 @@
+import { StairSegmentNode } from '../../schema';
+import { resolveStairTotalRise } from './stair-rise';
+const MIN_STAIR_FLIGHT_RISE = 0.1;
+const MIN_STAIR_FLIGHT_STEP_COUNT = 2;
+/**
+ * The single definition of a default straight flight. Anything left out falls
+ * through to the `StairSegmentNode` schema defaults (length 3 m, 10 steps,
+ * filled to floor) rather than being spelled again per call site, so the stair
+ * tool's seed segment, the flight the panel materializes when a curved stair
+ * becomes straight, and the viewer's fallback body all describe one stair.
+ */
+export function createDefaultStairSegment(overrides = {}) {
+    return StairSegmentNode.parse({ segmentType: 'stair', position: [0, 0, 0], ...overrides });
+}
+/**
+ * The flight a straight stair implies from its own fields — used wherever a
+ * straight stair has to stand in for missing `stair-segment` children.
+ */
+export function createStairFlightFromStair(stair, nodes) {
+    return createDefaultStairSegment({
+        width: stair.width,
+        height: Math.max(resolveStairTotalRise(stair, nodes), MIN_STAIR_FLIGHT_RISE),
+        stepCount: Math.max(MIN_STAIR_FLIGHT_STEP_COUNT, Math.round(stair.stepCount ?? 10)),
+        thickness: stair.thickness,
+        fillToFloor: stair.fillToFloor,
+    });
+}