@pascal-app/viewer 1.1.0 → 1.1.1

package/dist/ui/lib/room-assembly-overlay.js

@@ -0,0 +1,222 @@
+import { area, getWallArcData, getWallBaseElevationForNodes, getWallCurveFrameAt, getWallFaceOffsets, getWallTop, resolveCeilingHeight, roomDrawnFloor, } from '@pascal-app/core';
+import { ShapeUtils, Vector2 } from 'three';
+const ON_FACE = 1e-3;
+const FLOOR_LIFT = 0.005;
+const CEILING_DROP = 0.02;
+const CURVE_SAMPLES = 24;
+const MIN_PIECE_AREA = 0.01;
+/**
+ * Curved boundaries leave hairline slivers between the sampled room face and
+ * the sampled wall footprint; they would add stray face runs.
+ */
+function clearPieces(geometry) {
+    return geometry.clearPolygon.filter((piece) => area([piece]) >= MIN_PIECE_AREA);
+}
+export function resolveRoomAssemblyHeights(room, nodes) {
+    const sceneNodes = nodes;
+    const { levelId } = room.key;
+    const zone = nodes[room.zoneId];
+    let floorY = 0;
+    // A drawn slab floors the room even with its floor switched off.
+    if (zone?.type === 'zone' && (zone.hasFloor !== false || roomDrawnFloor(nodes, zone.id))) {
+        const level = nodes[levelId];
+        const plate = level?.type === 'level'
+            ? level.children
+                .map((id) => nodes[id])
+                .find((node) => node?.type === 'slab' && node.zoneIds?.includes(room.zoneId))
+            : undefined;
+        const drawn = plate ? null : roomDrawnFloor(nodes, room.zoneId);
+        const linked = plate ?? (drawn ? nodes[drawn.slabId] : room.slabId ? nodes[room.slabId] : undefined);
+        floorY = (linked?.type === 'slab' ? linked.elevation : zone.floor?.elevation) ?? 0;
+    }
+    const wallTops = new Map();
+    for (const id of room.boundaryWallIds) {
+        const wall = nodes[id];
+        if (wall?.type !== 'wall')
+            continue;
+        const base = getWallBaseElevationForNodes(wall, sceneNodes);
+        wallTops.set(id, getWallTop(wall, levelId, sceneNodes, base, 0.5));
+    }
+    const ceilingNode = room.ceilingId ? nodes[room.ceilingId] : undefined;
+    const ceiling = ceilingNode?.type === 'ceiling'
+        ? {
+            polygon: ceilingNode.polygon,
+            holes: ceilingNode.holes,
+            y: resolveCeilingHeight(ceilingNode, sceneNodes),
+        }
+        : null;
+    return { floorY, wallTops, ceiling };
+}
+function heightsKey({ floorY, wallTops, ceiling }) {
+    const rings = ceiling ? [ceiling.polygon, ...ceiling.holes].map((ring) => ring.join(' ')) : [];
+    return [floorY, ...wallTops, ceiling?.y, ...rings].join('|');
+}
+const cache = new WeakMap();
+/**
+ * The room geometry object is reused for as long as the level topology
+ * revision stands, so it keys the cache; heights and the ceiling outline are
+ * compared by value. Hover changes and pointer moves only ever hit.
+ */
+export function getRoomAssembly(geometry, heights) {
+    const key = heightsKey(heights);
+    const cached = cache.get(geometry);
+    if (cached?.key === key)
+        return cached.assembly;
+    const assembly = buildRoomAssembly(geometry, heights);
+    cache.set(geometry, { key, assembly });
+    return assembly;
+}
+function faceTest(wall, face) {
+    const offset = getWallFaceOffsets(wall)[face];
+    const arc = getWallArcData(wall);
+    if (arc) {
+        const radius = arc.radius - arc.direction * offset;
+        return ([x, z]) => Math.abs(Math.hypot(x - arc.center.x, z - arc.center.y) - radius) < ON_FACE;
+    }
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-9)
+        return () => false;
+    return ([x, z]) => Math.abs(((x - wall.start[0]) * -dz + (z - wall.start[1]) * dx) / length - offset) < ON_FACE;
+}
+function* ringEdges(ring) {
+    for (let i = 0; i < ring.length; i++)
+        yield [ring[i], ring[(i + 1) % ring.length]];
+}
+function overlap(p, q, a, b) {
+    const ex = b[0] - a[0];
+    const ez = b[1] - a[1];
+    const lengthSq = ex * ex + ez * ez;
+    if (lengthSq < 1e-12)
+        return null;
+    const length = Math.sqrt(lengthSq);
+    const offLine = ([x, z]) => Math.abs((x - a[0]) * ez - (z - a[1]) * ex) / length;
+    if (offLine(p) > ON_FACE || offLine(q) > ON_FACE)
+        return null;
+    const up = ((p[0] - a[0]) * ex + (p[1] - a[1]) * ez) / lengthSq;
+    const uq = ((q[0] - a[0]) * ex + (q[1] - a[1]) * ez) / lengthSq;
+    const lo = Math.max(0, Math.min(up, uq));
+    const hi = Math.min(1, Math.max(up, uq));
+    if ((hi - lo) * length < 1e-4)
+        return null;
+    return [
+        [a[0] + ex * lo, a[1] + ez * lo],
+        [a[0] + ex * hi, a[1] + ez * hi],
+    ];
+}
+/**
+ * The room-facing part of each boundary wall face. The clear polygon's
+ * boundary is exactly the mitered faces the room sees, clipped by T-stems
+ * and separators, so its edges are matched against each wall's footprint
+ * face edges; that also keeps collinear walls apart.
+ */
+export function roomWallFaces(geometry) {
+    const rings = clearPieces(geometry).flatMap(({ outer, holes }) => [outer, ...holes]);
+    const faces = [];
+    const seen = new Set();
+    for (const span of geometry.spans) {
+        if (span.kind !== 'wall')
+            continue;
+        const wallId = span.boundaryId;
+        const wall = geometry.context.walls.get(wallId);
+        if (!wall)
+            continue;
+        if (!rings.length) {
+            faces.push(...sampledFace(wall, span.face, span.t0, span.t1));
+            continue;
+        }
+        const key = `${wallId}:${span.face}`;
+        const footprint = geometry.context.wallFootprints.get(wallId);
+        if (seen.has(key) || !footprint)
+            continue;
+        seen.add(key);
+        const onFace = faceTest(wall, span.face);
+        const faceEdges = [...ringEdges(footprint)].filter(([a, b]) => onFace(a) && onFace(b));
+        for (const ring of rings) {
+            for (const [p, q] of ringEdges(ring)) {
+                if (!(onFace(p) && onFace(q)))
+                    continue;
+                for (const [a, b] of faceEdges) {
+                    const portion = overlap(p, q, a, b);
+                    if (portion)
+                        faces.push({ wallId, face: span.face, from: portion[0], to: portion[1] });
+                }
+            }
+        }
+    }
+    return faces;
+}
+// Only used when the clear polygon could not be computed for the room.
+function sampledFace(wall, face, t0, t1) {
+    const offset = getWallFaceOffsets(wall)[face];
+    const steps = getWallArcData(wall) ? CURVE_SAMPLES : 1;
+    const points = Array.from({ length: steps + 1 }, (_, i) => {
+        const { point, normal } = getWallCurveFrameAt(wall, t0 + ((t1 - t0) * i) / steps);
+        return [point.x + normal.x * offset, point.y + normal.y * offset];
+    });
+    return points
+        .slice(1)
+        .map((to, i) => ({ wallId: wall.id, face, from: points[i], to }));
+}
+function pushTriangles(target, outer, holes, y) {
+    const contour = outer.map(([x, z]) => new Vector2(x, z));
+    const holePoints = holes.map((ring) => ring.map(([x, z]) => new Vector2(x, z)));
+    const points = [...contour, ...holePoints.flat()];
+    for (const triangle of ShapeUtils.triangulateShape(contour, holePoints)) {
+        for (const index of triangle)
+            target.push(points[index].x, y, points[index].y);
+    }
+}
+function pushRing(target, ring, y) {
+    for (const [[ax, az], [bx, bz]] of ringEdges(ring))
+        target.push(ax, y, az, bx, y, bz);
+}
+export function buildRoomAssembly(geometry, heights) {
+    const floor = [];
+    const surfaces = [];
+    const outline = [];
+    const floorY = heights.floorY + FLOOR_LIFT;
+    for (const { outer, holes } of clearPieces(geometry)) {
+        pushTriangles(floor, outer, holes, floorY);
+        for (const ring of [outer, ...holes])
+            pushRing(outline, ring, floorY);
+    }
+    const faces = roomWallFaces(geometry);
+    const ends = new Map();
+    for (const { wallId, from, to } of faces) {
+        const top = heights.wallTops.get(wallId);
+        if (top === undefined || top <= floorY)
+            continue;
+        const [ax, az] = from;
+        const [bx, bz] = to;
+        surfaces.push(ax, floorY, az, bx, floorY, bz, bx, top, bz);
+        surfaces.push(ax, floorY, az, bx, top, bz, ax, top, az);
+        outline.push(ax, top, az, bx, top, bz);
+        for (const point of [from, to]) {
+            const key = `${wallId}:${point[0].toFixed(4)},${point[1].toFixed(4)}`;
+            const end = ends.get(key);
+            if (end)
+                end.count++;
+            else
+                ends.set(key, { point, top, count: 1 });
+        }
+    }
+    // Verticals only where a face run starts or stops, not between curve chords.
+    for (const { point, top, count } of ends.values()) {
+        if (count === 1)
+            outline.push(point[0], floorY, point[1], point[0], top, point[1]);
+    }
+    if (heights.ceiling) {
+        const { polygon, holes, y } = heights.ceiling;
+        pushTriangles(surfaces, polygon, holes, y - CEILING_DROP);
+        for (const ring of [polygon, ...holes])
+            pushRing(outline, ring, y - CEILING_DROP);
+    }
+    return {
+        floor: new Float32Array(floor),
+        surfaces: new Float32Array(surfaces),
+        outline: new Float32Array(outline),
+        faces,
+    };
+}

package/dist/ui/lib/room-name-messages.d.ts

@@ -0,0 +1,28 @@
+import type { MessageDescriptor } from '@pascal-app/core';
+/** Anything that translates a descriptor: a `PascalI18n`, or a stand-in in tests. */
+export type DescriptorTranslator = {
+    _(descriptor: MessageDescriptor): string;
+};
+/**
+ * The room-name catalog in the UI language. The catalog stays English (it is
+ * matched, numbered and stored as data); the combobox and room labels show these.
+ * The editor's `room-name-catalog.test.ts` fails when a catalog name has no entry here.
+ */
+export declare const ROOM_NAME_MESSAGES: Record<string, MessageDescriptor>;
+/**
+ * A room name in the UI language. Catalog names stay English in the scene
+ * (numbering, MCP and exports read them); a catalog name with the number the
+ * picker adds shows translated with that number ("Bedroom 2" → "Chambre 2").
+ * Anything else the user typed shows as written.
+ */
+export declare function displayRoomName(name: string, i18n: DescriptorTranslator): string;
+/**
+ * What an edit of a room's name field stores. The field shows the room's own
+ * catalog name translated ("Lounge 2" as "Salon 2"); when the edit only
+ * changes, adds or removes that name's number ("Salon 3"), it stores the
+ * English name with the new number ("Lounge 3"), as editing it in English
+ * would. Any other text, an exact translation of a different name included, is
+ * stored exactly as typed.
+ */
+export declare function editedRoomName(stored: string, text: string, i18n: DescriptorTranslator): string;
+//# sourceMappingURL=room-name-messages.d.ts.map

package/dist/ui/lib/room-name-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-name-messages.d.ts","sourceRoot":"","sources":["../../../src/ui/lib/room-name-messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEzD,qFAAqF;AACrF,MAAM,MAAM,oBAAoB,GAAG;IAAE,CAAC,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/E;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAgEhE,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,GAAG,MAAM,CAIhF;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,GAAG,MAAM,CAM/F"}

package/dist/ui/lib/room-name-messages.js

@@ -0,0 +1,112 @@
+/**
+ * The room-name catalog in the UI language. The catalog stays English (it is
+ * matched, numbered and stored as data); the combobox and room labels show these.
+ * The editor's `room-name-catalog.test.ts` fails when a catalog name has no entry here.
+ */
+export const ROOM_NAME_MESSAGES = {
+    'Living room': /* i18n */ { id: 'editor.roomName.livingRoom', message: 'Living room' },
+    'Family room': /* i18n */ { id: 'editor.roomName.familyRoom', message: 'Family room' },
+    'Dining room': /* i18n */ { id: 'editor.roomName.diningRoom', message: 'Dining room' },
+    Kitchen: /* i18n */ { id: 'editor.roomName.kitchen', message: 'Kitchen' },
+    Kitchenette: /* i18n */ { id: 'editor.roomName.kitchenette', message: 'Kitchenette' },
+    Pantry: /* i18n */ { id: 'editor.roomName.pantry', message: 'Pantry' },
+    Lounge: /* i18n */ { id: 'editor.roomName.lounge', message: 'Lounge' },
+    Den: /* i18n */ { id: 'editor.roomName.den', message: 'Den' },
+    Library: /* i18n */ { id: 'editor.roomName.library', message: 'Library' },
+    Playroom: /* i18n */ { id: 'editor.roomName.playroom', message: 'Playroom' },
+    'Home cinema': /* i18n */ { id: 'editor.roomName.homeCinema', message: 'Home cinema' },
+    'Games room': /* i18n */ { id: 'editor.roomName.gamesRoom', message: 'Games room' },
+    Sunroom: /* i18n */ { id: 'editor.roomName.sunroom', message: 'Sunroom' },
+    Bedroom: /* i18n */ { id: 'editor.roomName.bedroom', message: 'Bedroom' },
+    'Primary bedroom': /* i18n */ {
+        id: 'editor.roomName.primaryBedroom',
+        message: 'Primary bedroom',
+    },
+    'Guest room': /* i18n */ { id: 'editor.roomName.guestRoom', message: 'Guest room' },
+    "Kids' room": /* i18n */ { id: 'editor.roomName.kidsRoom', message: "Kids' room" },
+    Nursery: /* i18n */ { id: 'editor.roomName.nursery', message: 'Nursery' },
+    'Dressing room': /* i18n */ { id: 'editor.roomName.dressingRoom', message: 'Dressing room' },
+    'Walk-in closet': /* i18n */ { id: 'editor.roomName.walkInCloset', message: 'Walk-in closet' },
+    Bathroom: /* i18n */ { id: 'editor.roomName.bathroom', message: 'Bathroom' },
+    'En-suite': /* i18n */ { id: 'editor.roomName.enSuite', message: 'En-suite' },
+    'Shower room': /* i18n */ { id: 'editor.roomName.showerRoom', message: 'Shower room' },
+    Toilet: /* i18n */ { id: 'editor.roomName.toilet', message: 'Toilet' },
+    'Powder room': /* i18n */ { id: 'editor.roomName.powderRoom', message: 'Powder room' },
+    Office: /* i18n */ { id: 'editor.roomName.office', message: 'Office' },
+    Study: /* i18n */ { id: 'editor.roomName.study', message: 'Study' },
+    Studio: /* i18n */ { id: 'editor.roomName.studio', message: 'Studio' },
+    Workshop: /* i18n */ { id: 'editor.roomName.workshop', message: 'Workshop' },
+    Gym: /* i18n */ { id: 'editor.roomName.gym', message: 'Gym' },
+    Entrance: /* i18n */ { id: 'editor.roomName.entrance', message: 'Entrance' },
+    Hallway: /* i18n */ { id: 'editor.roomName.hallway', message: 'Hallway' },
+    Corridor: /* i18n */ { id: 'editor.roomName.corridor', message: 'Corridor' },
+    Landing: /* i18n */ { id: 'editor.roomName.landing', message: 'Landing' },
+    Stairwell: /* i18n */ { id: 'editor.roomName.stairwell', message: 'Stairwell' },
+    Mudroom: /* i18n */ { id: 'editor.roomName.mudroom', message: 'Mudroom' },
+    Laundry: /* i18n */ { id: 'editor.roomName.laundry', message: 'Laundry' },
+    'Utility room': /* i18n */ { id: 'editor.roomName.utilityRoom', message: 'Utility room' },
+    Storage: /* i18n */ { id: 'editor.roomName.storage', message: 'Storage' },
+    Closet: /* i18n */ { id: 'editor.roomName.closet', message: 'Closet' },
+    'Boiler room': /* i18n */ { id: 'editor.roomName.boilerRoom', message: 'Boiler room' },
+    Cellar: /* i18n */ { id: 'editor.roomName.cellar', message: 'Cellar' },
+    Basement: /* i18n */ { id: 'editor.roomName.basement', message: 'Basement' },
+    Attic: /* i18n */ { id: 'editor.roomName.attic', message: 'Attic' },
+    Garage: /* i18n */ { id: 'editor.roomName.garage', message: 'Garage' },
+    Garden: /* i18n */ { id: 'editor.roomName.garden', message: 'Garden' },
+    Patio: /* i18n */ { id: 'editor.roomName.patio', message: 'Patio' },
+    Terrace: /* i18n */ { id: 'editor.roomName.terrace', message: 'Terrace' },
+    Balcony: /* i18n */ { id: 'editor.roomName.balcony', message: 'Balcony' },
+    Porch: /* i18n */ { id: 'editor.roomName.porch', message: 'Porch' },
+    Veranda: /* i18n */ { id: 'editor.roomName.veranda', message: 'Veranda' },
+    Deck: /* i18n */ { id: 'editor.roomName.deck', message: 'Deck' },
+    Courtyard: /* i18n */ { id: 'editor.roomName.courtyard', message: 'Courtyard' },
+    'Pool area': /* i18n */ { id: 'editor.roomName.poolArea', message: 'Pool area' },
+    Carport: /* i18n */ { id: 'editor.roomName.carport', message: 'Carport' },
+    'Garden shed': /* i18n */ { id: 'editor.roomName.gardenShed', message: 'Garden shed' },
+    Mezzanine: /* i18n */ { id: 'editor.roomName.mezzanine', message: 'Mezzanine' },
+    Loft: /* i18n */ { id: 'editor.roomName.loft', message: 'Loft' },
+    'Reading nook': /* i18n */ { id: 'editor.roomName.readingNook', message: 'Reading nook' },
+    Gallery: /* i18n */ { id: 'editor.roomName.gallery', message: 'Gallery' },
+};
+/**
+ * A room name in the UI language. Catalog names stay English in the scene
+ * (numbering, MCP and exports read them); a catalog name with the number the
+ * picker adds shows translated with that number ("Bedroom 2" → "Chambre 2").
+ * Anything else the user typed shows as written.
+ */
+export function displayRoomName(name, i18n) {
+    const { lead, base, number, trail } = roomNameParts(name);
+    const label = catalogLabel(base, i18n);
+    return label === undefined ? name : `${lead}${label}${number}${trail}`;
+}
+/**
+ * What an edit of a room's name field stores. The field shows the room's own
+ * catalog name translated ("Lounge 2" as "Salon 2"); when the edit only
+ * changes, adds or removes that name's number ("Salon 3"), it stores the
+ * English name with the new number ("Lounge 3"), as editing it in English
+ * would. Any other text, an exact translation of a different name included, is
+ * stored exactly as typed.
+ */
+export function editedRoomName(stored, text, i18n) {
+    const own = roomNameParts(stored).base;
+    const label = catalogLabel(own, i18n);
+    const edited = roomNameParts(text);
+    if (label === undefined || edited.base !== label)
+        return text;
+    return `${edited.lead}${own}${edited.number}${edited.trail}`;
+}
+function roomNameParts(name) {
+    const match = /^(\s*)(.*?)(\s+\d+)?(\s*)$/.exec(name);
+    return {
+        lead: match?.[1] ?? '',
+        base: match?.[2] ?? '',
+        number: match?.[3] ?? '',
+        trail: match?.[4] ?? '',
+    };
+}
+function catalogLabel(english, i18n) {
+    // Own keys only: a room named "constructor" or "__proto__" is free text.
+    if (!(english && Object.hasOwn(ROOM_NAME_MESSAGES, english)))
+        return undefined;
+    return i18n._(ROOM_NAME_MESSAGES[english]);
+}

package/dist/ui/lib/room-selection.d.ts

@@ -0,0 +1,58 @@
+import { type AnyNode, type BoundarySpan, createRoomTopologyIndex, type MultiPolygon, roomClearPolygon, type TopologyRoom, type ZoneNode } from '@pascal-app/core';
+import type { SelectionModifierKeys } from './selection-modifiers';
+export type RoomKey = {
+    levelId: string;
+    zoneId: string;
+};
+export declare function sameRoom(a: RoomKey | null, b: RoomKey | null): boolean;
+export declare function shouldSelectRoom(selected: RoomKey | null, hit: RoomKey | null, modifiers: SelectionModifierKeys): boolean;
+export type RoomSelectionGeometry = TopologyRoom & {
+    key: RoomKey;
+    boundaryWallIds: string[];
+    clearPolygon: ReturnType<typeof roomClearPolygon>;
+    area: number;
+    hitPolygon: MultiPolygon;
+    /** A stacked open-below room (`floor.support: 'open'`) inside its host room. */
+    mezzanine: {
+        hostZoneId: string;
+    } | null;
+};
+export type RoomSelectionRecord = RoomSelectionGeometry & {
+    geometry: RoomSelectionGeometry;
+    name: string;
+    zoneId: string;
+    slabId: string | null;
+    slabName: string | null;
+    ceilingId: string | null;
+    ceilingName: string | null;
+};
+type Nodes = Record<string, AnyNode>;
+export declare function isMezzanineZone(node: AnyNode | undefined): node is ZoneNode;
+/**
+ * A zone that bounds no room (a drawn area), outlined the way a room is: its
+ * polygon as the floor, no walls of its own.
+ */
+export declare function describeZoneOutline(levelId: string, zone: ZoneNode): RoomSelectionRecord;
+type RoomHitIndex = Pick<ReturnType<typeof createRoomTopologyIndex>, 'roomAtPoint' | 'roomForWallHit' | 'spansForWall'> & {
+    /** The selectable room a zone is (a mezzanine's own plate or ceiling points at it). */
+    roomForZone?: (levelId: string, zoneId: string) => TopologyRoom | null;
+};
+export declare function resolveRoomHit<T extends RoomHitIndex>(index: T, levelId: string, node: AnyNode | null, point: [number, number], view?: '2d' | '3d'): ReturnType<T['roomAtPoint']>;
+export declare class RoomSelectionIndex {
+    readonly levelId: string;
+    readonly topology: import("@pascal-app/core").RoomTopologyIndex<import("@pascal-app/core").ExtractedRoom>;
+    private nodes;
+    private records;
+    private geometry;
+    private candidates;
+    private revision;
+    private readonly roomsById;
+    roomAtPoint(_levelId: string, point: [number, number]): RoomSelectionGeometry | null;
+    roomForZone(_levelId: string, zoneId: string): RoomSelectionGeometry | null;
+    roomForWallHit(levelId: string, wallId: string, face: 'a' | 'b', t: number): RoomSelectionGeometry | null;
+    spansForWall(levelId: string, wallId: string): readonly BoundarySpan[];
+    constructor(levelId: string);
+    update(nodes: Nodes): RoomSelectionRecord[];
+}
+export {};
+//# sourceMappingURL=room-selection.d.ts.map

package/dist/ui/lib/room-selection.d.ts.map

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