@pascal-app/core 0.5.1 → 0.7.0

package/dist/lib/door-operation.d.ts

@@ -0,0 +1,7 @@
+import type { DoorNode, DoorType } from '../schema/nodes/door';
+export declare const SECTIONAL_GARAGE_RENDER_OPEN_SCALE = 0.88;
+export declare function clampDoorOperationState(value: number | undefined): number;
+export declare function isOperationDoorType(doorType: DoorType | DoorNode['doorType'] | string | undefined): doorType is "folding" | "pocket" | "barn" | "sliding" | "garage-sectional" | "garage-rollup" | "garage-tiltup";
+export declare function getDoorRenderOpenAmount(doorType: DoorType | DoorNode['doorType'], operationState: number | undefined): number;
+export declare function getGarageVisibleOpeningRatio(doorType: DoorType | DoorNode['doorType'], operationState: number | undefined): number;
+//# sourceMappingURL=door-operation.d.ts.map

package/dist/lib/door-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-operation.d.ts","sourceRoot":"","sources":["../../src/lib/door-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE9D,eAAO,MAAM,kCAAkC,OAAO,CAAA;AAEtD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,UAEhE;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,MAAM,GAAG,SAAS,kHAW/D;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,EACzC,cAAc,EAAE,MAAM,GAAG,SAAS,UAMnC;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,EACzC,cAAc,EAAE,MAAM,GAAG,SAAS,UAOnC"}

package/dist/lib/door-operation.js

@@ -0,0 +1,25 @@
+export const SECTIONAL_GARAGE_RENDER_OPEN_SCALE = 0.88;
+export function clampDoorOperationState(value) {
+    return Math.max(0, Math.min(1, value ?? 0));
+}
+export function isOperationDoorType(doorType) {
+    return (doorType === 'folding' ||
+        doorType === 'pocket' ||
+        doorType === 'barn' ||
+        doorType === 'sliding' ||
+        doorType === 'garage-sectional' ||
+        doorType === 'garage-rollup' ||
+        doorType === 'garage-tiltup');
+}
+export function getDoorRenderOpenAmount(doorType, operationState) {
+    const openAmount = clampDoorOperationState(operationState);
+    return doorType === 'garage-sectional'
+        ? openAmount * SECTIONAL_GARAGE_RENDER_OPEN_SCALE
+        : openAmount;
+}
+export function getGarageVisibleOpeningRatio(doorType, operationState) {
+    if (doorType === 'garage-sectional') {
+        return Math.min(1, clampDoorOperationState(operationState) / SECTIONAL_GARAGE_RENDER_OPEN_SCALE);
+    }
+    return clampDoorOperationState(operationState);
+}

package/dist/lib/polygon-geometry.d.ts

@@ -0,0 +1,3 @@
+export declare function insetPolygonFromCentroid(polygon: Array<[number, number]>, inset: number): Array<[number, number]>;
+export declare function simplifyClosedPolygon(polygon: Array<[number, number]>, tolerance: number): Array<[number, number]>;
+//# sourceMappingURL=polygon-geometry.d.ts.map

package/dist/lib/polygon-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-geometry.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-geometry.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,KAAK,EAAE,MAAM,GACZ,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAuBzB;AAuED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,SAAS,EAAE,MAAM,GAChB,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiCzB"}

package/dist/lib/polygon-geometry.js

@@ -0,0 +1,90 @@
+export function insetPolygonFromCentroid(polygon, inset) {
+    if (inset <= 0) {
+        return polygon.map(([x, z]) => [x, z]);
+    }
+    const centroid = polygon.reduce((acc, [x, z]) => ({ x: acc.x + x, z: acc.z + z }), { x: 0, z: 0 });
+    centroid.x /= Math.max(polygon.length, 1);
+    centroid.z /= Math.max(polygon.length, 1);
+    return polygon.map(([x, z]) => {
+        const dx = x - centroid.x;
+        const dz = z - centroid.z;
+        const length = Math.hypot(dx, dz);
+        if (length <= inset + 1e-6) {
+            return [x, z];
+        }
+        const scale = (length - inset) / length;
+        return [centroid.x + dx * scale, centroid.z + dz * scale];
+    });
+}
+function pointLineDistance(point, start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared < 1e-9) {
+        return Math.hypot(point[0] - start[0], point[1] - start[1]);
+    }
+    const cross = (point[0] - start[0]) * dz - (point[1] - start[1]) * dx;
+    return Math.abs(cross) / Math.sqrt(lengthSquared);
+}
+function dedupePolygonPoints(polygon, tolerance = 1e-6) {
+    const deduped = [];
+    for (const point of polygon) {
+        const previous = deduped[deduped.length - 1];
+        if (previous && Math.hypot(point[0] - previous[0], point[1] - previous[1]) <= tolerance) {
+            continue;
+        }
+        deduped.push(point);
+    }
+    if (deduped.length > 2 &&
+        Math.hypot(deduped[0][0] - deduped[deduped.length - 1][0], deduped[0][1] - deduped[deduped.length - 1][1]) <= tolerance) {
+        deduped.pop();
+    }
+    return deduped;
+}
+function simplifyPolyline(points, tolerance) {
+    if (points.length <= 2) {
+        return points.map(([x, z]) => [x, z]);
+    }
+    let maxDistance = -1;
+    let splitIndex = -1;
+    for (let index = 1; index < points.length - 1; index += 1) {
+        const distance = pointLineDistance(points[index], points[0], points[points.length - 1]);
+        if (distance > maxDistance) {
+            maxDistance = distance;
+            splitIndex = index;
+        }
+    }
+    if (maxDistance <= tolerance || splitIndex === -1) {
+        return [points[0], points[points.length - 1]];
+    }
+    const left = simplifyPolyline(points.slice(0, splitIndex + 1), tolerance);
+    const right = simplifyPolyline(points.slice(splitIndex), tolerance);
+    return [...left.slice(0, -1), ...right];
+}
+export function simplifyClosedPolygon(polygon, tolerance) {
+    const cleanPolygon = dedupePolygonPoints(polygon);
+    if (cleanPolygon.length <= 3 || tolerance <= 0) {
+        return cleanPolygon;
+    }
+    let anchorA = 0;
+    let anchorB = Math.floor(cleanPolygon.length / 2);
+    let maxDistanceSquared = -1;
+    for (let i = 0; i < cleanPolygon.length; i += 1) {
+        for (let j = i + 1; j < cleanPolygon.length; j += 1) {
+            const dx = cleanPolygon[j][0] - cleanPolygon[i][0];
+            const dz = cleanPolygon[j][1] - cleanPolygon[i][1];
+            const distanceSquared = dx * dx + dz * dz;
+            if (distanceSquared > maxDistanceSquared) {
+                maxDistanceSquared = distanceSquared;
+                anchorA = i;
+                anchorB = j;
+            }
+        }
+    }
+    const forward = cleanPolygon.slice(anchorA, anchorB + 1);
+    const wrapped = [...cleanPolygon.slice(anchorB), ...cleanPolygon.slice(0, anchorA + 1)];
+    const simplifiedForward = simplifyPolyline(forward, tolerance);
+    const simplifiedWrapped = simplifyPolyline(wrapped, tolerance);
+    const simplified = dedupePolygonPoints([...simplifiedForward.slice(0, -1), ...simplifiedWrapped.slice(0, -1)], tolerance * 0.25);
+    return simplified.length >= 3 ? simplified : cleanPolygon;
+}

package/dist/lib/slab-polygon.d.ts

@@ -0,0 +1,3 @@
+import type { SlabNode } from '../schema';
+export declare function getRenderableSlabPolygon(slabNode: SlabNode): Array<[number, number]>;
+//# sourceMappingURL=slab-polygon.d.ts.map

package/dist/lib/slab-polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slab-polygon.d.ts","sourceRoot":"","sources":["../../src/lib/slab-polygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAQzC,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAOpF"}

package/dist/lib/slab-polygon.js

@@ -0,0 +1,58 @@
+import { insetPolygonFromCentroid, simplifyClosedPolygon } from './polygon-geometry';
+/** Half of default wall thickness — used to extend slab geometry under walls */
+const SLAB_OUTSET = 0.05;
+const AUTO_SLAB_INSET = 0.02;
+const AUTO_SLAB_SIMPLIFY_TOLERANCE = 0.08;
+export function getRenderableSlabPolygon(slabNode) {
+    return slabNode.autoFromWalls
+        ? simplifyClosedPolygon(insetPolygonFromCentroid(slabNode.polygon, AUTO_SLAB_INSET), AUTO_SLAB_SIMPLIFY_TOLERANCE)
+        : outsetPolygon(slabNode.polygon, SLAB_OUTSET);
+}
+/**
+ * Expand a polygon outward by a uniform distance.
+ * Offsets each edge outward then intersects consecutive offset edges.
+ */
+function outsetPolygon(polygon, amount) {
+    const n = polygon.length;
+    if (n < 3)
+        return polygon;
+    // Determine winding via signed area
+    let area2 = 0;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        area2 += polygon[i][0] * polygon[j][1] - polygon[j][0] * polygon[i][1];
+    }
+    const s = area2 >= 0 ? 1 : -1;
+    // Offset each edge outward by amount
+    const offEdges = [];
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const dx = polygon[j][0] - polygon[i][0];
+        const dz = polygon[j][1] - polygon[i][1];
+        const len = Math.sqrt(dx * dx + dz * dz);
+        if (len < 1e-9) {
+            offEdges.push([polygon[i][0], polygon[i][1], dx, dz]);
+            continue;
+        }
+        const nx = ((s * dz) / len) * amount;
+        const nz = ((s * -dx) / len) * amount;
+        offEdges.push([polygon[i][0] + nx, polygon[i][1] + nz, dx, dz]);
+    }
+    // Intersect consecutive offset edges to get new vertices
+    const result = [];
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const [ax, az, adx, adz] = offEdges[i];
+        const [bx, bz, bdx, bdz] = offEdges[j];
+        const denom = adx * bdz - adz * bdx;
+        if (Math.abs(denom) < 1e-9) {
+            // Parallel edges — use offset endpoint
+            result.push([ax + adx, az + adz]);
+        }
+        else {
+            const t = ((bx - ax) * bdz - (bz - az) * bdx) / denom;
+            result.push([ax + t * adx, az + t * adz]);
+        }
+    }
+    return result;
+}

package/dist/lib/space-detection.d.ts

@@ -1,4 +1,8 @@
-import type { WallNode } from '../schema';
+import { type WallNode } from '../schema';
+type Point2D = {
+    x: number;
+    y: number;
+};
 export type Space = {
     id: string;
     levelId: string;
@@ -6,29 +10,18 @@ export type Space = {
     wallIds: string[];
     isExterior: boolean;
 };
-/**
- * Initializes space detection sync with scene and editor stores
- * Call this once during app initialization
- */
-export declare function initSpaceDetectionSync(sceneStore: any, // useScene store
-editorStore: any): () => void;
 type WallSideUpdate = {
     wallId: string;
     frontSide: 'interior' | 'exterior' | 'unknown';
     backSide: 'interior' | 'exterior' | 'unknown';
 };
-/**
- * Detects spaces for a level by flood-filling a grid from the edges
- * Returns wall side updates and detected spaces
- */
-export declare function detectSpacesForLevel(levelId: string, walls: WallNode[], gridResolution?: number): {
-    wallUpdates: WallSideUpdate[];
+export declare function resolveWallSurfaceSides(wall: Pick<WallNode, 'start' | 'end' | 'thickness' | 'frontSide' | 'backSide'>, roomPolygons: Point2D[][]): Pick<WallSideUpdate, 'frontSide' | 'backSide'>;
+export declare function detectSpacesForLevel(levelId: string, walls: WallNode[]): {
+    roomPolygons: Point2D[][];
     spaces: Space[];
+    wallUpdates: WallSideUpdate[];
 };
-/**
- * Checks if a wall touches any other walls
- * Used to determine if space detection should run
- */
+export declare function initSpaceDetectionSync(sceneStore: any, editorStore: any): () => void;
 export declare function wallTouchesOthers(wall: WallNode, otherWalls: WallNode[]): boolean;
 export {};
 //# sourceMappingURL=space-detection.d.ts.map

package/dist/lib/space-detection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAMzC,MAAM,MAAM,KAAK,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAMD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,GAAG,EAAE,iBAAiB;AAClC,WAAW,EAAE,GAAG,GACf,MAAM,IAAI,CAkGZ;AA+DD,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;IAC9C,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;CAC9C,CAAA;AAMD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,QAAQ,EAAE,EACjB,cAAc,SAAM,GACnB;IACD,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB,CAqBA;AAsWD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,OAAO,CAkBjF"}
+{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"AAKA,OAAO,EAA6F,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAA;AAQpI,KAAK,OAAO,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC,MAAM,MAAM,KAAK,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;IAC9C,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;CAC9C,CAAA;AA4VD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC,EAC9E,YAAY,EAAE,OAAO,EAAE,EAAE,GACxB,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,UAAU,CAAC,CA4ChD;AA0WD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE;;;;EAEtE;AAsED,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,GAAG,MAAM,IAAI,CAuDpF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,OAAO,CAiBjF"}