@pascal-app/core 1.0.3 → 1.0.5

package/dist/building/door-types.js

@@ -0,0 +1,167 @@
+import { defaultDoorSegments } from '../schema/nodes/opening-types.js';
+import { doorStyleLook, doorStylesOf } from './opening-style-presets.js';
+/** A door type's own size: the door panel's Type row sets it, and add_door takes it when none is given. */
+export const DOOR_TYPE_SIZES = {
+    hinged: { width: 0.9, height: 2.1 },
+    double: { width: 1.5, height: 2.1 },
+    french: { width: 1.5, height: 2.1 },
+    folding: { width: 1.8, height: 2.1 },
+    pocket: { width: 0.9, height: 2.1 },
+    barn: { width: 1, height: 2.1 },
+    sliding: { width: 1.5, height: 2.1 },
+    'garage-sectional': { width: 2.7, height: 2.4 },
+    'garage-rollup': { width: 2.7, height: 2.4 },
+    'garage-tiltup': { width: 2.7, height: 2.4 },
+};
+const frenchSegments = () => [
+    {
+        type: 'glass',
+        heightRatio: 0.76,
+        columnRatios: [1, 1],
+        dividerThickness: 0.025,
+        panelDepth: 0.01,
+        panelInset: 0.04,
+    },
+    {
+        type: 'panel',
+        heightRatio: 0.24,
+        columnRatios: [1],
+        dividerThickness: 0.03,
+        panelDepth: 0.012,
+        panelInset: 0.035,
+    },
+];
+const foldingSegments = () => [
+    {
+        type: 'panel',
+        heightRatio: 1,
+        columnRatios: [1],
+        dividerThickness: 0.02,
+        panelDepth: 0.008,
+        panelInset: 0.025,
+    },
+];
+const segmentsOf = (type) => type === 'hinged' || type === 'double'
+    ? defaultDoorSegments()
+    : type === 'french' || type === 'sliding'
+        ? frenchSegments()
+        : foldingSegments();
+/**
+ * What a door type writes besides its size, for the door panel's Type row and add_door alike: its
+ * leaves, its track and the leaf it comes with (an agent's sliding door had no track, as the agent
+ * set doorType alone).
+ */
+export function doorTypeFields(type, door = {}) {
+    const segments = segmentsOf(type);
+    const sliding = {
+        leafCount: 1,
+        openingShape: 'rectangle',
+        handle: true,
+        handleSide: 'right',
+        slideDirection: door.slideDirection ?? 'left',
+        operationState: door.operationState ?? 0,
+        threshold: false,
+        contentPadding: [0.035, 0.045],
+    };
+    const garage = {
+        doorCategory: 'garage',
+        leafCount: 1,
+        handle: false,
+        threshold: false,
+        openingShape: 'rectangle',
+        trackStyle: 'overhead',
+        operationState: 0,
+        garagePanelCount: 4,
+        contentPadding: [0.04, 0.04],
+    };
+    switch (type) {
+        case 'double':
+        case 'french':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                leafCount: 2,
+                handleSide: 'right',
+                segments,
+                ...(type === 'french' ? { contentPadding: [0.045, 0.055] } : {}),
+            };
+        case 'folding':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                leafCount: 4,
+                openingShape: 'rectangle',
+                handle: true,
+                handleSide: 'right',
+                trackStyle: 'visible',
+                operationState: Math.max(door.operationState ?? 0, 0.65),
+                threshold: false,
+                contentPadding: [0.03, 0.04],
+                segments,
+            };
+        case 'pocket':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                ...sliding,
+                trackStyle: 'pocket',
+                segments,
+            };
+        case 'barn':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                ...sliding,
+                trackStyle: 'visible',
+                segments,
+            };
+        case 'sliding':
+            return {
+                doorCategory: 'interior',
+                doorType: type,
+                ...sliding,
+                leafCount: 2,
+                trackStyle: 'visible',
+                contentPadding: [0.03, 0.04],
+                segments,
+            };
+        case 'garage-sectional':
+            return {
+                ...garage,
+                doorType: type,
+                garagePanelCount: Math.max(3, Math.min(8, door.garagePanelCount ?? 4)),
+                segments,
+            };
+        case 'garage-rollup':
+        case 'garage-tiltup':
+            return { ...garage, doorType: type, segments };
+        case 'hinged':
+            return { doorCategory: 'interior', doorType: type, leafCount: 1, segments, threshold: true };
+    }
+}
+/** The style a door keeps through a type change: one chosen over the leaf its type came with. */
+function chosenStyle(door) {
+    const [style] = doorStylesOf(door);
+    if (!style)
+        return undefined;
+    const own = doorTypeFields(door.doorType, door);
+    const ownPadding = own.contentPadding ?? door.contentPadding;
+    const isOwn = doorStylesOf({ segments: own.segments ?? [], contentPadding: ownPadding }).includes(style);
+    return isOwn ? undefined : style;
+}
+/**
+ * The door panel's Type row: the type's fields and size, the door kept on the floor, and a style
+ * the person chose kept (a modern door made sliding stays modern; a plain one made French takes
+ * the French glazing).
+ */
+export function doorTypeChange(door, type) {
+    const { width, height } = DOOR_TYPE_SIZES[type];
+    const kept = chosenStyle(door);
+    return {
+        ...doorTypeFields(type, door),
+        width,
+        height,
+        position: [door.position[0], height / 2, door.position[2]],
+        ...(kept ? doorStyleLook(kept) : {}),
+    };
+}

package/dist/building/floor-item-fit.d.ts

@@ -0,0 +1,38 @@
+import { type DoorKeepout } from '../agent-operations/door-clearance.js';
+import type { SceneNodes } from '../agent-operations/types.js';
+export type FloorItemRoom = {
+    id: string;
+    name: string;
+    width: number;
+    depth: number;
+};
+export type FloorItemMisfit = {
+    code: 'too_large_for_room';
+    room: FloorItemRoom;
+} | {
+    code: 'blocks_door';
+    room?: FloorItemRoom;
+    doorId: string;
+    /** A spot in the room that clears every door, when there is one. */
+    candidate?: {
+        x: number;
+        z: number;
+        rotationDeg: number;
+    };
+};
+/**
+ * Whether a floor item fits where it stands. An item its room cannot hold in any turn, or one
+ * standing in the space a door needs (as verify_scene's blocked-door check sees it), does not fit.
+ * place_items refuses it, the editor warns. Items overlapping is not a misfit: a chair under its
+ * table and a bed on its rug overlap by design.
+ */
+export declare function floorItemFit(nodes: SceneNodes, item: {
+    levelId: string;
+    x: number;
+    z: number;
+    rotationDeg: number;
+    dimensions: readonly number[] | undefined;
+    /** The level's door keepouts, when the caller already has them. */
+    doors?: DoorKeepout[];
+}): FloorItemMisfit | null;
+//# sourceMappingURL=floor-item-fit.d.ts.map

package/dist/building/floor-item-fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-item-fit.d.ts","sourceRoot":"","sources":["../../src/building/floor-item-fit.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAGjB,MAAM,oCAAoC,CAAA;AAG3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAG3D,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtF,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,IAAI,EAAE,aAAa,CAAA;CAAE,GACnD;IACE,IAAI,EAAE,aAAa,CAAA;IACnB,IAAI,CAAC,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,oEAAoE;IACpE,SAAS,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;CAC1D,CAAA;AAEL;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE;IACJ,OAAO,EAAE,MAAM,CAAA;IACf,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAA;IACzC,mEAAmE;IACnE,KAAK,CAAC,EAAE,WAAW,EAAE,CAAA;CACtB,GACA,eAAe,GAAG,IAAI,CA0CxB"}

package/dist/building/floor-item-fit.js

@@ -0,0 +1,47 @@
+import { collectDoorKeepouts, itemBlocksDoorKeepout, itemPlanAabb, } from '../agent-operations/door-clearance.js';
+import { findValidPlacement } from '../agent-operations/layout-clearance.js';
+import { pointInPolygon, polygonBounds } from '../agent-operations/plan-geometry.js';
+/**
+ * Whether a floor item fits where it stands. An item its room cannot hold in any turn, or one
+ * standing in the space a door needs (as verify_scene's blocked-door check sees it), does not fit.
+ * place_items refuses it, the editor warns. Items overlapping is not a misfit: a chair under its
+ * table and a bed on its rug overlap by design.
+ */
+export function floorItemFit(nodes, item) {
+    const zone = Object.values(nodes).find((node) => node.type === 'zone' &&
+        node.parentId === item.levelId &&
+        node.polygon.length >= 3 &&
+        pointInPolygon([item.x, item.z], node.polygon));
+    const bounds = zone ? polygonBounds(zone.polygon) : undefined;
+    const room = zone &&
+        bounds && {
+        id: zone.id,
+        name: zone.name,
+        width: bounds.maxX - bounds.minX,
+        depth: bounds.maxZ - bounds.minZ,
+    };
+    const [width = 1, , depth = 1] = item.dimensions ?? [1, 1, 1];
+    if (room) {
+        const fits = (a, b) => a <= room.width && b <= room.depth;
+        if (!fits(width, depth) && !fits(depth, width))
+            return { code: 'too_large_for_room', room };
+    }
+    const doors = item.doors ?? collectDoorKeepouts(Object.values(nodes), { levelId: item.levelId });
+    const footprint = itemPlanAabb([item.x, 0, item.z], item.dimensions, (item.rotationDeg * Math.PI) / 180);
+    const door = doors.find((keepout) => itemBlocksDoorKeepout(footprint, keepout));
+    if (!door)
+        return null;
+    const { candidate } = findValidPlacement({
+        primary: { x: item.x, z: item.z, rotationDeg: item.rotationDeg },
+        dimensions: item.dimensions,
+        doorKeepouts: doors.map((keepout) => keepout.aabb),
+        occupied: [],
+        roomBounds: bounds,
+    });
+    return {
+        code: 'blocks_door',
+        ...(room ? { room } : {}),
+        doorId: door.doorId,
+        ...(candidate ? { candidate } : {}),
+    };
+}

package/dist/building/ground-level.d.ts

@@ -0,0 +1,26 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+/**
+ * Making `levelId` the building's ground floor, as the level panel's "Set as ground floor" and the
+ * agent's `set_ground_level` do: the building names it (`groundLevelId`), is seated so that level's
+ * floor datum, the top of the foundation, stands over grade as the building's foundation
+ * construction seats it (`GroundSeat.aboveGrade`: 0.203 m on block, by region and style); its
+ * position moves in height, the plan stays where it is, and the
+ * floor indices are renumbered so it is index 0 and the ones under it are the basements. Every
+ * floor keeps its place relative to the others. One change set, one undo step. `null` for an id
+ * that is no level of a building.
+ */
+export declare function buildGroundLevelChanges({ nodes, levelId, }: {
+    nodes: Record<AnyNodeId, AnyNode>;
+    levelId: string;
+}): {
+    buildingId: `building_${string}`;
+    seat: import("../index.js").GroundSeat;
+    moveBy: number;
+    renumbered: boolean;
+    unchanged: boolean;
+    update: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[];
+} | null;
+//# sourceMappingURL=ground-level.d.ts.map

package/dist/building/ground-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-level.d.ts","sourceRoot":"","sources":["../../src/building/ground-level.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAA2B,MAAM,WAAW,CAAA;AAG5E;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,OAAO,GACR,EAAE;IACD,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,OAAO,EAAE,MAAM,CAAA;CAChB;;;;;;;YAoC0B,SAAS;cAIvB,OAAO,CAAC,OAAO,CAAC;;SAQ5B"}

package/dist/building/ground-level.js

@@ -0,0 +1,58 @@
+import { groundSeat } from '../lib/ground-seat.js';
+import { getLevelElevations } from '../services/storey.js';
+/**
+ * Making `levelId` the building's ground floor, as the level panel's "Set as ground floor" and the
+ * agent's `set_ground_level` do: the building names it (`groundLevelId`), is seated so that level's
+ * floor datum, the top of the foundation, stands over grade as the building's foundation
+ * construction seats it (`GroundSeat.aboveGrade`: 0.203 m on block, by region and style); its
+ * position moves in height, the plan stays where it is, and the
+ * floor indices are renumbered so it is index 0 and the ones under it are the basements. Every
+ * floor keeps its place relative to the others. One change set, one undo step. `null` for an id
+ * that is no level of a building.
+ */
+export function buildGroundLevelChanges({ nodes, levelId, }) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const buildingId = getLevelElevations(nodes).get(levelId)?.buildingId;
+    const building = buildingId ? nodes[buildingId] : undefined;
+    if (building?.type !== 'building')
+        return null;
+    // Seat against the level asked for, not the one the building names today.
+    const asNamed = {
+        ...nodes,
+        [building.id]: { ...building, groundLevelId: level.id },
+    };
+    const before = groundSeat(nodes, building.id);
+    const seat = groundSeat(asNamed, building.id);
+    if (!seat)
+        return null;
+    const [x, y, z] = building.position;
+    // Micrometres: the seat is measured through sums of storey heights, and a stored height keeps no noise.
+    const moveBy = seat.atFoundationTop ? 0 : Math.round((seat.aboveGrade - seat.offset) * 1e6) / 1e6;
+    const shift = level.level;
+    const renumbered = Object.values(nodes).filter((node) => node.type === 'level' &&
+        shift !== 0 &&
+        getLevelElevations(nodes).get(node.id)?.buildingId === building.id);
+    const unchanged = before?.explicit === true && before.levelId === level.id && seat.atFoundationTop && shift === 0;
+    return {
+        buildingId: building.id,
+        seat,
+        moveBy,
+        renumbered: renumbered.length > 0,
+        unchanged,
+        update: [
+            {
+                id: building.id,
+                data: {
+                    groundLevelId: level.id,
+                    position: [x, Math.round((y + moveBy) * 1e6) / 1e6, z],
+                },
+            },
+            ...renumbered.map((other) => ({
+                id: other.id,
+                data: { level: other.level - shift },
+            })),
+        ],
+    };
+}

package/dist/building/index.d.ts

@@ -0,0 +1,12 @@
+export * from './corner-window.js';
+export * from './door-types.js';
+export * from './floor-item-fit.js';
+export { buildGroundLevelChanges } from './ground-level.js';
+export * from './level-duplication.js';
+export { buildLevelBelowChanges } from './level-insertion.js';
+export * from './merge-windows.js';
+export * from './opening-style-presets.js';
+export { type RgbaImage, warpImage } from './photo-elevation.js';
+export * from './wall-openings.js';
+export * from './window-types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/building/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/building/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AACxD,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,OAAO,EAAE,KAAK,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7D,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA"}

package/dist/building/index.js

@@ -0,0 +1,11 @@
+export * from './corner-window.js';
+export * from './door-types.js';
+export * from './floor-item-fit.js';
+export { buildGroundLevelChanges } from './ground-level.js';
+export * from './level-duplication.js';
+export { buildLevelBelowChanges } from './level-insertion.js';
+export * from './merge-windows.js';
+export * from './opening-style-presets.js';
+export { warpImage } from './photo-elevation.js';
+export * from './wall-openings.js';
+export * from './window-types.js';