@pascal-app/viewer 1.0.0-beta.4 → 1.0.0

package/dist/systems/wall/opening-cutout-geometry.test.js

@@ -1,172 +0,0 @@
-// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
-// depend on @types/bun so the import type is unresolved at compile time.
-import { describe, expect, test } from 'bun:test';
-import { DoorNode, WindowNode } from '@pascal-app/core';
-import { buildOpeningCutoutGeometry, buildOpeningCutoutShape, getOpeningCutoutBottomPadding, hasFlatOpeningCutoutBottom, } from './opening-cutout-geometry';
-function containsPoint(points, x, y) {
-    return points.some((point) => Math.abs(point.x - x) < 1e-6 && Math.abs(point.y - y) < 1e-6);
-}
-function getBounds(points) {
-    let minX = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let minY = Number.POSITIVE_INFINITY;
-    let maxY = Number.NEGATIVE_INFINITY;
-    for (const point of points) {
-        minX = Math.min(minX, point.x);
-        maxX = Math.max(maxX, point.x);
-        minY = Math.min(minY, point.y);
-        maxY = Math.max(maxY, point.y);
-    }
-    return { minX, maxX, minY, maxY };
-}
-describe('buildOpeningCutoutShape', () => {
-    test('rectangle profile passes the rect through unchanged', () => {
-        const door = DoorNode.parse({});
-        const rect = { left: 1.2, right: 2.1, bottom: 0, top: 2.1 };
-        const points = buildOpeningCutoutShape(door, rect).getPoints();
-        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.top)).toBe(true);
-        expect(containsPoint(points, rect.left, rect.top)).toBe(true);
-        const bounds = getBounds(points);
-        expect(bounds.minX).toBeCloseTo(rect.left, 9);
-        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
-        expect(bounds.minY).toBeCloseTo(rect.bottom, 9);
-        expect(bounds.maxY).toBeCloseTo(rect.top, 9);
-    });
-    test('door rounded profile rounds only the top corners', () => {
-        const door = DoorNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
-        const rect = { left: -0.45, right: 0.45, bottom: 0, top: 2.1 };
-        const points = buildOpeningCutoutShape(door, rect).getPoints();
-        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
-        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
-        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
-        expect(containsPoint(points, rect.left, rect.top - 0.2)).toBe(true);
-        expect(containsPoint(points, rect.left + 0.2, rect.top)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.top - 0.2)).toBe(true);
-        expect(containsPoint(points, rect.right - 0.2, rect.top)).toBe(true);
-    });
-    test('window rounded profile rounds all four corners', () => {
-        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
-        const rect = { left: -0.75, right: 0.75, bottom: 0.9, top: 2.4 };
-        const points = buildOpeningCutoutShape(window, rect).getPoints();
-        expect(containsPoint(points, rect.left, rect.bottom)).toBe(false);
-        expect(containsPoint(points, rect.right, rect.bottom)).toBe(false);
-        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
-        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
-        expect(containsPoint(points, rect.left + 0.2, rect.bottom)).toBe(true);
-        expect(containsPoint(points, rect.left, rect.bottom + 0.2)).toBe(true);
-        expect(containsPoint(points, rect.right - 0.2, rect.top)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.top - 0.2)).toBe(true);
-        const bounds = getBounds(points);
-        expect(bounds.minX).toBeCloseTo(rect.left, 9);
-        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
-        expect(bounds.minY).toBeCloseTo(rect.bottom, 9);
-        expect(bounds.maxY).toBeCloseTo(rect.top, 9);
-    });
-    test('shared corner radius is clamped to the opening half-extent', () => {
-        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 10 });
-        const rect = { left: -0.75, right: 0.75, bottom: 0.9, top: 2.4 };
-        const points = buildOpeningCutoutShape(window, rect).getPoints();
-        // 1.5 × 1.5 opening → radius clamps to 0.75; arcs meet at edge midpoints.
-        expect(containsPoint(points, rect.left, rect.bottom + 0.75)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.top - 0.75)).toBe(true);
-        const bounds = getBounds(points);
-        expect(bounds.minX).toBeCloseTo(rect.left, 9);
-        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
-    });
-    test('individual radii normalize when their sum exceeds the opening width', () => {
-        const window = WindowNode.parse({
-            openingShape: 'rounded',
-            openingRadiusMode: 'individual',
-            openingCornerRadii: [4, 4, 0, 0],
-        });
-        const rect = { left: -0.5, right: 0.5, bottom: 0, top: 2 };
-        const points = buildOpeningCutoutShape(window, rect).getPoints();
-        // Width 1 with top radii summing to 8 → scaled down to 0.5 each.
-        expect(containsPoint(points, rect.left, rect.top - 0.5)).toBe(true);
-        expect(containsPoint(points, rect.left + 0.5, rect.top)).toBe(true);
-        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
-    });
-    test('arch profile springs at top - archHeight and peaks at the rect top', () => {
-        const door = DoorNode.parse({ openingShape: 'arch', archHeight: 0.45 });
-        const rect = { left: -0.45, right: 0.45, bottom: 0, top: 2.1 };
-        const points = buildOpeningCutoutShape(door, rect).getPoints();
-        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
-        expect(containsPoint(points, rect.right, rect.top - 0.45)).toBe(true);
-        expect(containsPoint(points, 0, rect.top)).toBe(true);
-        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
-        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
-    });
-    test('profiles are origin-agnostic — offset rects yield translated points', () => {
-        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
-        const centered = buildOpeningCutoutShape(window, {
-            left: -0.75,
-            right: 0.75,
-            bottom: -0.75,
-            top: 0.75,
-        }).getPoints();
-        const offset = buildOpeningCutoutShape(window, {
-            left: 2.25,
-            right: 3.75,
-            bottom: 0.9,
-            top: 2.4,
-        }).getPoints();
-        for (const point of centered) {
-            expect(containsPoint(offset, point.x + 3, point.y + 1.65)).toBe(true);
-        }
-        for (const point of offset) {
-            expect(containsPoint(centered, point.x - 3, point.y - 1.65)).toBe(true);
-        }
-    });
-});
-describe('buildOpeningCutoutGeometry', () => {
-    test('extrudes the rect through the depth, centered on the mid-plane', () => {
-        const door = DoorNode.parse({});
-        const geometry = buildOpeningCutoutGeometry(door, { left: -0.45, right: 0.45, bottom: -1.05, top: 1.05 }, 0.24, 0.1);
-        geometry.computeBoundingBox();
-        // Float32 position buffer → ~1e-7 relative precision.
-        const box = geometry.boundingBox;
-        expect(box.min.x).toBeCloseTo(-0.45, 6);
-        expect(box.max.x).toBeCloseTo(0.45, 6);
-        expect(box.min.y).toBeCloseTo(-1.05, 6);
-        expect(box.max.y).toBeCloseTo(1.05, 6);
-        expect(box.min.z).toBeCloseTo(-0.12, 6);
-        expect(box.max.z).toBeCloseTo(0.12, 6);
-    });
-});
-describe('hasFlatOpeningCutoutBottom', () => {
-    test('flat for rectangles, arches, and door rounded (top-only radii)', () => {
-        expect(hasFlatOpeningCutoutBottom(DoorNode.parse({}))).toBe(true);
-        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'arch' }))).toBe(true);
-        expect(hasFlatOpeningCutoutBottom(DoorNode.parse({ openingShape: 'rounded' }))).toBe(true);
-    });
-    test('rounded windows depend on their bottom radii', () => {
-        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'rounded' }))).toBe(false);
-        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0 }))).toBe(true);
-        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({
-            openingShape: 'rounded',
-            openingRadiusMode: 'individual',
-            openingCornerRadii: [0.2, 0.2, 0, 0],
-        }))).toBe(true);
-        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({
-            openingShape: 'rounded',
-            openingRadiusMode: 'individual',
-            openingCornerRadii: [0.2, 0.2, 0.2, 0.2],
-        }))).toBe(false);
-    });
-});
-describe('getOpeningCutoutBottomPadding', () => {
-    test('pads floor-level openings with a flat bottom', () => {
-        expect(getOpeningCutoutBottomPadding(DoorNode.parse({}), 0)).toBe(0.02);
-        expect(getOpeningCutoutBottomPadding(DoorNode.parse({ openingShape: 'rounded' }), 0)).toBe(0.02);
-        expect(getOpeningCutoutBottomPadding(WindowNode.parse({ openingShape: 'arch' }), 0)).toBe(0.02);
-    });
-    test('does not pad openings above the floor or rounded window bottoms', () => {
-        expect(getOpeningCutoutBottomPadding(DoorNode.parse({}), 0.9)).toBe(0);
-        expect(getOpeningCutoutBottomPadding(WindowNode.parse({ openingShape: 'rounded' }), 0)).toBe(0);
-    });
-});

package/dist/systems/wall/wall-opening-cutout.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=wall-opening-cutout.test.d.ts.map

package/dist/systems/wall/wall-opening-cutout.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wall-opening-cutout.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-opening-cutout.test.ts"],"names":[],"mappings":""}

package/dist/systems/wall/wall-opening-cutout.test.js

@@ -1,59 +0,0 @@
-// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
-// depend on @types/bun so the import type is unresolved at compile time.
-import { describe, expect, test } from 'bun:test';
-import { calculateLevelMiters, DoorNode, sceneRegistry, WallNode } from '@pascal-app/core';
-import * as THREE from 'three';
-import { generateExtrudedWall } from './wall-system';
-describe('wall opening cutout', () => {
-    test('cuts a floor-level door directly from node geometry without a proxy mesh', () => {
-        const wall = WallNode.parse({
-            id: 'wall_floor-opening-cutout',
-            start: [0, 0],
-            end: [2, 0],
-            height: 2.5,
-            thickness: 0.1,
-        });
-        const door = DoorNode.parse({
-            id: 'door_floor-opening-cutout',
-            wallId: wall.id,
-            position: [1, 1.05, 0],
-            width: 0.9,
-            height: 2.1,
-        });
-        const wallMesh = new THREE.Mesh();
-        sceneRegistry.nodes.set(wall.id, wallMesh);
-        try {
-            const geometry = generateExtrudedWall(wall, [door], calculateLevelMiters([wall]));
-            const position = geometry.getAttribute('position');
-            const index = geometry.index;
-            const openingLeft = door.position[0] - door.width / 2;
-            const openingRight = door.position[0] + door.width / 2;
-            let wallFaceTrianglesInsideOpening = 0;
-            let baseTrianglesInsideOpening = 0;
-            for (let offset = 0; offset < (index?.count ?? position.count); offset += 3) {
-                const indices = [0, 1, 2].map((corner) => index ? index.getX(offset + corner) : offset + corner);
-                const vertices = indices.map((vertexIndex) => new THREE.Vector3(position.getX(vertexIndex), position.getY(vertexIndex), position.getZ(vertexIndex)));
-                const centroid = vertices
-                    .reduce((sum, vertex) => sum.add(vertex), new THREE.Vector3())
-                    .multiplyScalar(1 / 3);
-                const insideOpeningX = centroid.x > openingLeft + 1e-4 && centroid.x < openingRight - 1e-4;
-                if (!insideOpeningX)
-                    continue;
-                const onWallFace = vertices.every((vertex) => Math.abs(Math.abs(vertex.z) - (wall.thickness ?? 0.1) / 2) < 1e-5);
-                if (onWallFace && centroid.y > 1e-4 && centroid.y < door.height - 1e-4) {
-                    wallFaceTrianglesInsideOpening += 1;
-                }
-                if (vertices.every((vertex) => Math.abs(vertex.y) < 1e-5)) {
-                    baseTrianglesInsideOpening += 1;
-                }
-            }
-            expect(wallFaceTrianglesInsideOpening).toBe(0);
-            expect(baseTrianglesInsideOpening).toBe(0);
-            geometry.dispose();
-        }
-        finally {
-            sceneRegistry.nodes.delete(wall.id);
-            wallMesh.geometry.dispose();
-        }
-    });
-});

package/dist/systems/wall/wall-support-extension.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=wall-support-extension.test.d.ts.map

package/dist/systems/wall/wall-support-extension.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wall-support-extension.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-support-extension.test.ts"],"names":[],"mappings":""}

package/dist/systems/wall/wall-support-extension.test.js

@@ -1,116 +0,0 @@
-// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
-// depend on @types/bun so the import type is unresolved at compile time.
-import { describe, expect, test } from 'bun:test';
-import { calculateLevelMiters, getWallPlaneTop, WallNode, } from '@pascal-app/core';
-import { generateExtrudedWall } from './wall-system';
-describe('wall support extension', () => {
-    test('preserves the raised wall origin and top while filling down to the lower support', () => {
-        const wall = WallNode.parse({ start: [0, 0], end: [4, 0], height: 2.5, thickness: 0.1 });
-        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0.6, 0.05);
-        geometry.computeBoundingBox();
-        expect(geometry.boundingBox?.min.y).toBeCloseTo(-0.55);
-        expect(geometry.boundingBox?.max.y).toBeCloseTo(2.5);
-        // With mesh.position.y = 0.6, the wall spans world Y=0.05..3.1.
-        expect((geometry.boundingBox?.min.y ?? 0) + 0.6).toBeCloseTo(0.05);
-        expect((geometry.boundingBox?.max.y ?? 0) + 0.6).toBeCloseTo(3.1);
-        geometry.dispose();
-    });
-    test('retains the existing negative-slab top constraint', () => {
-        const wall = WallNode.parse({ start: [0, 0], end: [4, 0], height: 2.5, thickness: 0.1 });
-        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), -0.4, -0.4);
-        geometry.computeBoundingBox();
-        expect(geometry.boundingBox?.min.y).toBeCloseTo(0);
-        expect(geometry.boundingBox?.max.y).toBeCloseTo(2.9);
-        expect((geometry.boundingBox?.max.y ?? 0) - 0.4).toBeCloseTo(2.5);
-        geometry.dispose();
-    });
-    test('plane-bound wall tops out at the storey plane regardless of slab elevation', () => {
-        const wall = WallNode.parse({ start: [0, 0], end: [4, 0], thickness: 0.1 });
-        const flat = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0, 0, undefined, 3);
-        flat.computeBoundingBox();
-        expect(flat.boundingBox?.max.y).toBeCloseTo(3);
-        expect(flat.boundingBox?.min.y).toBeCloseTo(0);
-        flat.dispose();
-        const raised = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0.6, 0.6, undefined, 3);
-        raised.computeBoundingBox();
-        // Mesh sits at Y=0.6, so a 2.4 local top keeps the world top at the 3m
-        // plane — the raised slab shortens the wall instead of lifting its top.
-        expect(raised.boundingBox?.max.y).toBeCloseTo(2.4);
-        expect(raised.boundingBox?.min.y).toBeCloseTo(0);
-        raised.dispose();
-    });
-    test('plane-bound wall under a flush thick deck tops out at the deck underside', () => {
-        // level_1 carries a flush deck occupying [-0.3, 0] above the storey
-        // plane: the covering-clamped plane for level_0 is 2.5 − 0.3 = 2.2.
-        const wall = WallNode.parse({
-            start: [0.5, 2],
-            end: [3.5, 2],
-            thickness: 0.1,
-            parentId: 'level_0',
-        });
-        const base = { object: 'node', parentId: null, visible: true, metadata: {}, children: [] };
-        const nodes = {
-            level_0: {
-                ...base,
-                id: 'level_0',
-                type: 'level',
-                level: 0,
-                height: 2.5,
-                children: [wall.id],
-            },
-            level_1: {
-                ...base,
-                id: 'level_1',
-                type: 'level',
-                level: 1,
-                height: 2.5,
-                children: ['slab_deck'],
-            },
-            slab_deck: {
-                ...base,
-                id: 'slab_deck',
-                type: 'slab',
-                parentId: 'level_1',
-                polygon: [
-                    [0, 0],
-                    [4, 0],
-                    [4, 4],
-                    [0, 4],
-                ],
-                holes: [],
-                elevation: 0,
-                thickness: 0.3,
-            },
-        };
-        const planeTop = getWallPlaneTop(wall, 'level_0', nodes);
-        expect(planeTop).toBeCloseTo(2.2);
-        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0, 0, undefined, planeTop);
-        geometry.computeBoundingBox();
-        // Mesh sits at Y=0, so the world top lands at the deck underside instead
-        // of colliding with the slab solid above.
-        expect(geometry.boundingBox?.max.y).toBeCloseTo(2.2);
-        expect(geometry.boundingBox?.min.y).toBeCloseTo(0);
-        geometry.dispose();
-    });
-    test('raises only the high-supported part of a mixed wall run', () => {
-        const wall = WallNode.parse({ start: [0, 0], end: [4, 0], height: 2.5, thickness: 0.1 });
-        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 0.6, 0.05, [
-            { start: 0, end: 0.5, elevation: 0.6 },
-            { start: 0.5, end: 1, elevation: 0.05 },
-        ]);
-        const position = geometry.getAttribute('position');
-        let highSpanMinY = Number.POSITIVE_INFINITY;
-        let lowSpanMinY = Number.POSITIVE_INFINITY;
-        for (let index = 0; index < position.count; index++) {
-            const x = position.getX(index);
-            const y = position.getY(index);
-            if (x < 1.9)
-                highSpanMinY = Math.min(highSpanMinY, y);
-            if (x > 2.1)
-                lowSpanMinY = Math.min(lowSpanMinY, y);
-        }
-        expect(highSpanMinY).toBeCloseTo(0);
-        expect(lowSpanMinY).toBeCloseTo(-0.55);
-        geometry.dispose();
-    });
-});

package/dist/systems/wall/wall-terrain-bottom.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=wall-terrain-bottom.test.d.ts.map

package/dist/systems/wall/wall-terrain-bottom.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wall-terrain-bottom.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-terrain-bottom.test.ts"],"names":[],"mappings":""}

package/dist/systems/wall/wall-terrain-bottom.test.js

@@ -1,34 +0,0 @@
-// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
-// depend on @types/bun so the import type is unresolved at compile time.
-import { describe, expect, test } from 'bun:test';
-import { calculateLevelMiters, WallNode } from '@pascal-app/core';
-import { generateExtrudedWall } from './wall-system';
-describe('wall terrain bottom', () => {
-    test('samples both faces independently without changing the authored body height', () => {
-        const wall = WallNode.parse({
-            start: [0, 0],
-            end: [4, 0],
-            height: 2.5,
-            thickness: 1,
-            supportSlabId: 'ground',
-            fillToTerrain: true,
-        });
-        const geometry = generateExtrudedWall(wall, [], calculateLevelMiters([wall]), 1.5, 1.5, undefined, 4, (_x, z) => (z >= 0 ? 0.2 : 0.8));
-        geometry.computeBoundingBox();
-        const position = geometry.getAttribute('position');
-        let positiveFaceMinY = Number.POSITIVE_INFINITY;
-        let negativeFaceMinY = Number.POSITIVE_INFINITY;
-        for (let index = 0; index < position.count; index += 1) {
-            const z = position.getZ(index);
-            const y = position.getY(index);
-            if (z > 0.49)
-                positiveFaceMinY = Math.min(positiveFaceMinY, y);
-            if (z < -0.49)
-                negativeFaceMinY = Math.min(negativeFaceMinY, y);
-        }
-        expect(positiveFaceMinY).toBeCloseTo(-1.3);
-        expect(negativeFaceMinY).toBeCloseTo(-0.7);
-        expect(geometry.boundingBox?.max.y).toBeCloseTo(2.5);
-        geometry.dispose();
-    });
-});