@pascal-app/viewer 1.0.7 → 1.1.1

package/dist/ui/lib/viewer-selection.js

@@ -0,0 +1,462 @@
+import { area, buildUnitReport, containsPoint, DEFAULT_LEVEL_HEIGHT, emitter, getLevelDisplayName, resolveSelectionProxyId, roomFloorElevation, sceneRegistry, } from '@pascal-app/core';
+import { useEffect } from 'react';
+import { Box3, Sphere, Vector3, } from 'three';
+import useViewer from '../../store/use-viewer';
+import { useBelowGrade } from './below-grade';
+import { nodeDisplayLabel } from './node-display-label';
+import { displayRoomName } from './room-name-messages';
+import { RoomSelectionIndex, resolveRoomHit } from './room-selection';
+const NO_MODIFIERS = { alt: false, ctrl: false, meta: false, shift: false };
+/** Surfaces a room is picked through, room first: its walls, its floor, its ceiling. */
+const ROOM_SURFACES = new Set(['wall', 'slab', 'ceiling']);
+/** Kinds a viewer click never lands on: they pass the pointer to what lies behind. */
+export const VIEWER_PASS_THROUGH_KINDS = new Set([
+    'site',
+    'building',
+    'level',
+    'zone',
+    'ceiling',
+    'scan',
+    'guide',
+    'spawn',
+]);
+const indexes = new WeakMap();
+function roomIndex(levelId, nodes) {
+    let levels = indexes.get(nodes);
+    if (!levels) {
+        levels = new Map();
+        indexes.set(nodes, levels);
+    }
+    let index = levels.get(levelId);
+    if (!index) {
+        index = new RoomSelectionIndex(levelId);
+        levels.set(levelId, index);
+    }
+    index.update(nodes);
+    return index;
+}
+/** The rooms the walls of a level close, as the editor detects them. */
+export function viewerRooms(levelId, nodes) {
+    return roomIndex(levelId, nodes).update(nodes);
+}
+export function levelOfNode(nodeId, nodes) {
+    const seen = new Set();
+    let current = nodes[nodeId];
+    while (current && !seen.has(current.id)) {
+        if (current.type === 'level')
+            return current.id;
+        seen.add(current.id);
+        current = current.parentId ? nodes[current.parentId] : undefined;
+    }
+    return null;
+}
+function buildingOfLevel(levelId, nodes) {
+    const level = levelId ? nodes[levelId] : undefined;
+    const parent = level?.parentId ? nodes[level.parentId] : undefined;
+    if (parent?.type === 'building')
+        return parent.id;
+    const building = Object.values(nodes).find((node) => node.type === 'building');
+    return building?.id ?? null;
+}
+const hitPoint = new Vector3();
+/**
+ * The parametric hit source: a node event as a pick, with the hit in its
+ * level's local XZ. A hit on a hidden floor, or on a kind a click passes
+ * through, is no pick: the pointer goes on to what lies behind it.
+ */
+export function viewerPickFromNodeEvent(event, nodes) {
+    if (VIEWER_PASS_THROUGH_KINDS.has(event.node.type))
+        return null;
+    const levelId = levelOfNode(event.node.id, nodes);
+    const level = levelId ? sceneRegistry.nodes.get(levelId) : undefined;
+    if (level?.visible === false)
+        return null;
+    if (!level)
+        return { nodeId: event.node.id, point: null };
+    level.updateWorldMatrix(true, false);
+    hitPoint.set(...event.position);
+    level.worldToLocal(hitPoint);
+    return { nodeId: event.node.id, point: [hitPoint.x, hitPoint.z] };
+}
+/**
+ * What a pick acts on. A wall, floor or ceiling picks the room it bounds;
+ * once that room is selected, its own surfaces are picked as themselves.
+ * Anything else (an item, a door, a stair) is picked directly. Alt, Shift,
+ * Ctrl and Meta skip the room, as in the editor.
+ */
+export function resolveViewerTarget(selection, pick, nodes, modifiers = NO_MODIFIERS) {
+    const node = nodes[pick.nodeId];
+    if (!node || VIEWER_PASS_THROUGH_KINDS.has(node.type))
+        return null;
+    const levelId = levelOfNode(node.id, nodes);
+    const bypass = modifiers.alt || modifiers.shift || modifiers.ctrl || modifiers.meta;
+    if (!bypass && levelId && pick.point && ROOM_SURFACES.has(node.type)) {
+        const room = resolveRoomHit(roomIndex(levelId, nodes), levelId, node, [pick.point[0], pick.point[1]], '3d');
+        if (room) {
+            const { zoneId } = room.key;
+            return selection.zoneId === zoneId
+                ? { kind: 'node', levelId, nodeId: node.id, zoneId }
+                : { kind: 'room', levelId, zoneId };
+        }
+    }
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    // A roof selects whole: its segments and its faces of other kinds (`capabilities.roofs`).
+    const owner = parent?.type === 'roof' ? parent : node;
+    const nodeId = resolveSelectionProxyId(owner, nodes);
+    return { kind: 'node', levelId, nodeId, zoneId: null };
+}
+/**
+ * The selection a click makes. Empty space clears the room and the element
+ * and keeps the floor; nothing pops the user up a level.
+ */
+export function resolveViewerClick(selection, pick, nodes, modifiers = NO_MODIFIERS) {
+    const target = pick ? resolveViewerTarget(selection, pick, nodes, modifiers) : null;
+    if (!target)
+        return { ...selection, zoneId: null, selectedIds: [] };
+    const levelId = target.levelId ?? selection.levelId;
+    const buildingId = buildingOfLevel(levelId, nodes) ?? selection.buildingId;
+    if (target.kind === 'room') {
+        return { buildingId, levelId, zoneId: target.zoneId, selectedIds: [] };
+    }
+    const toggles = modifiers.shift || modifiers.ctrl || modifiers.meta;
+    const sameFloor = levelId === selection.levelId;
+    const selectedIds = toggles && sameFloor
+        ? selection.selectedIds.includes(target.nodeId)
+            ? selection.selectedIds.filter((id) => id !== target.nodeId)
+            : [...selection.selectedIds, target.nodeId]
+        : [target.nodeId];
+    return {
+        buildingId,
+        levelId,
+        zoneId: target.zoneId,
+        selectedIds,
+    };
+}
+/** What a hover would select: a room's id (its highlight) or the element's (its outline). */
+export function resolveViewerHover(selection, pick, nodes) {
+    const target = pick ? resolveViewerTarget(selection, pick, nodes) : null;
+    if (!target)
+        return null;
+    return target.kind === 'room' ? target.zoneId : target.nodeId;
+}
+/**
+ * The current floor reads as the editor shows it: the levels above it step
+ * aside (in the stacked display) so its rooms are in view and in reach, and the
+ * ground is veiled over it when it lies below grade. Mount it in the surface's DOM tree,
+ * beside the editor's own level display, so one hands the flag to the other in
+ * order.
+ */
+export function useViewerFloorDisplay() {
+    // A walkthrough tours the whole building.
+    const walking = useViewer((s) => s.walkthroughMode);
+    useBelowGrade(!walking);
+    useEffect(() => {
+        if (walking)
+            return;
+        useViewer.setState({ hideLevelsAboveSelection: true });
+        return () => {
+            useViewer.setState({ hideLevelsAboveSelection: false });
+        };
+    }, [walking]);
+}
+// ── Applying it to the shared store ──────────────────────────────────────────
+function writeSelection(selection) {
+    const viewer = useViewer.getState();
+    viewer.setSelection(selection);
+    if (viewer.focusedUnitId)
+        viewer.setFocusedUnit(null);
+    viewer.setHoveredId(null);
+}
+export function applyViewerClick(pick, nodes, modifiers = NO_MODIFIERS) {
+    writeSelection(resolveViewerClick(useViewer.getState().selection, pick, nodes, modifiers));
+}
+export function applyViewerHover(pick, nodes) {
+    const viewer = useViewer.getState();
+    const hovered = resolveViewerHover(viewer.selection, pick, nodes);
+    viewer.setHoveredId(hovered);
+}
+/** A floor from the floor list: the floor alone, framed. */
+export function selectViewerLevel(levelId, source) {
+    writeSelection({
+        buildingId: buildingOfLevel(levelId, source.nodes),
+        levelId: levelId,
+        zoneId: null,
+        selectedIds: [],
+    });
+    frameViewerNode(levelId, source);
+}
+/** The whole building again, framed. */
+export function selectViewerBuilding(source) {
+    const buildingId = buildingOfLevel(null, source.nodes);
+    writeSelection({ buildingId, levelId: null, zoneId: null, selectedIds: [] });
+    if (buildingId)
+        frameViewerNode(buildingId, source);
+}
+/** A room or zone from its pill, the bar or the sidebar: selected on its floor, framed. */
+export function selectViewerRoom(zoneId, source) {
+    const zone = source.nodes[zoneId];
+    if (zone?.type !== 'zone' || !zone.parentId)
+        return;
+    const levelId = zone.parentId;
+    writeSelection({
+        buildingId: buildingOfLevel(levelId, source.nodes),
+        levelId,
+        zoneId: zone.id,
+        selectedIds: [],
+    });
+    frameViewerNode(zone.id, source);
+}
+/**
+ * A unit from the sidebar: its rooms highlighted and framed. The floor stays
+ * when it holds one of the unit's rooms, else the unit's lowest floor shows.
+ */
+export function selectViewerUnit(unitId, source) {
+    const unit = source.nodes[unitId];
+    if (unit?.type !== 'unit')
+        return;
+    const viewer = useViewer.getState();
+    const levels = unitLevels(unit, source.nodes);
+    const current = viewer.selection.levelId;
+    const levelId = (current && levels.includes(current) ? current : (levels[0] ?? current));
+    viewer.setSelection({
+        buildingId: buildingOfLevel(levelId, source.nodes),
+        levelId,
+        zoneId: null,
+        selectedIds: [],
+    });
+    viewer.setHoveredId(null);
+    viewer.setFocusedUnit(unit.id);
+    frameViewerNode(unit.id, source);
+}
+function unitLevels(unit, nodes) {
+    const ordinals = new Map();
+    for (const member of buildUnitReport(unit, nodes).members) {
+        if (member.levelId && member.levelOrdinal !== null)
+            ordinals.set(member.levelId, member.levelOrdinal);
+    }
+    return [...ordinals.entries()].sort((a, b) => a[1] - b[1]).map(([id]) => id);
+}
+// ── Framing ──────────────────────────────────────────────────────────────────
+const corner = new Vector3();
+const box = new Box3();
+function expandByZone(target, zone, source) {
+    const level = zone.parentId ? source.objectFor(zone.parentId) : undefined;
+    level?.updateWorldMatrix(true, false);
+    const floorY = roomFloorElevation(source.nodes, zone.id);
+    for (const [x, z] of zone.polygon) {
+        for (const y of [floorY, floorY + DEFAULT_LEVEL_HEIGHT]) {
+            corner.set(x, y, z);
+            if (level)
+                corner.applyMatrix4(level.matrixWorld);
+            target.expandByPoint(corner);
+        }
+    }
+}
+/** The frame request for a node: the box it spans, and its saved view when it has one. */
+function viewerFrameEvent(id, source) {
+    const node = source.nodes[id];
+    if (!node)
+        return null;
+    const saved = node.camera;
+    const pose = saved?.position && saved.target ? { position: saved.position, target: saved.target } : null;
+    box.makeEmpty();
+    if (node.type === 'zone')
+        expandByZone(box, node, source);
+    else if (node.type === 'unit') {
+        for (const memberId of node.members) {
+            const member = source.nodes[memberId];
+            if (member?.type === 'zone')
+                expandByZone(box, member, source);
+        }
+    }
+    else {
+        const object = source.objectFor(id);
+        if (object)
+            box.setFromObject(object);
+    }
+    const bounds = box.isEmpty() ? null : { min: box.min.toArray(), max: box.max.toArray() };
+    if (pose)
+        return { bounds, pose };
+    return bounds ? { bounds } : null;
+}
+/** Framing glides to its pose, or jumps there when the person asks for reduced motion. */
+export function framingAnimates() {
+    return !(typeof window !== 'undefined' && window.matchMedia?.('(prefers-reduced-motion: reduce)').matches);
+}
+export function frameViewerNode(id, source) {
+    const event = viewerFrameEvent(id, source);
+    if (event)
+        emitter.emit('camera-controls:frame', event);
+}
+/**
+ * Where a camera frames a box: about 45° above it, far enough for the box to
+ * fill the view, along the heading the camera already has so the scene does
+ * not swing round.
+ */
+export function framedLookAt(event, from, fovDegrees = 50) {
+    if (event.pose)
+        return event.pose;
+    if (!event.bounds)
+        return null;
+    const { min, max } = event.bounds;
+    const center = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
+    const radius = Math.max(Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2, 1);
+    const halfFov = (Math.min(Math.max(fovDegrees, 10), 120) * Math.PI) / 360;
+    const distance = Math.max((radius / Math.sin(halfFov)) * 1.6, 6);
+    const dx = from.position[0] - from.target[0];
+    const dz = from.position[2] - from.target[2];
+    const heading = Math.hypot(dx, dz) > 1e-6 ? Math.atan2(dx, dz) : Math.PI / 4;
+    const elevation = Math.PI / 4;
+    const flat = Math.cos(elevation) * distance;
+    return {
+        position: [
+            center[0] + Math.sin(heading) * flat,
+            center[1] + Math.sin(elevation) * distance,
+            center[2] + Math.cos(heading) * flat,
+        ],
+        target: center,
+    };
+}
+const framePosition = new Vector3();
+const frameTarget = new Vector3();
+const frameSphere = new Sphere();
+/** Apply the shared framing pose, fitting the orthographic viewport as well. */
+export function frameViewerCamera(control, camera, event) {
+    control.getPosition(framePosition);
+    control.getTarget(frameTarget);
+    const pose = framedLookAt(event, { position: framePosition.toArray(), target: frameTarget.toArray() }, camera.isPerspectiveCamera
+        ? camera.fov
+        : undefined);
+    if (!pose)
+        return;
+    const animate = framingAnimates();
+    control.setLookAt(...pose.position, ...pose.target, animate);
+    if (camera.isOrthographicCamera && event.bounds && !event.pose) {
+        box.min.set(...event.bounds.min);
+        box.max.set(...event.bounds.max);
+        box.getBoundingSphere(frameSphere);
+        frameSphere.radius = Math.max(frameSphere.radius * 1.3, 1);
+        control.fitToSphere(frameSphere, animate);
+    }
+}
+/**
+ * The viewer chrome's name for a zone, in the editor's UI language (the scene
+ * keeps its stored name). `i18n` is the caller's scoped `usePascalI18n()`.
+ */
+export function zoneLabel(zone, i18n) {
+    const name = zone.name?.trim();
+    if (name)
+        return displayRoomName(name, i18n);
+    return zone.spaceRole === 'room'
+        ? i18n._({ id: 'editor.roomLabel.room', message: 'Room' })
+        : i18n._({ id: 'editor.roomLabel.zone', message: 'Zone' });
+}
+/**
+ * The bar: building › floor › room › element. An element inside a room shows
+ * that room (`roomOf`) without selecting it; a focused unit stands where the
+ * room would.
+ */
+export function viewerBreadcrumb(selection, focusedUnitId, nodes, i18n, roomOf = () => null) {
+    const crumbs = [];
+    const elementId = selection.selectedIds[0] ?? null;
+    const element = elementId ? nodes[elementId] : undefined;
+    const levelId = selection.levelId ?? (element ? levelOfNode(element.id, nodes) : null);
+    const buildingId = selection.buildingId ?? buildingOfLevel(levelId, nodes);
+    const building = buildingId ? nodes[buildingId] : undefined;
+    if (building?.type === 'building') {
+        crumbs.push({ kind: 'building', id: building.id, label: building.name || 'Building' });
+    }
+    const level = levelId ? nodes[levelId] : undefined;
+    if (level?.type !== 'level')
+        return crumbs;
+    crumbs.push({ kind: 'level', id: level.id, label: getLevelDisplayName(level) });
+    const unit = focusedUnitId ? nodes[focusedUnitId] : undefined;
+    if (unit?.type === 'unit')
+        crumbs.push({ kind: 'unit', id: unit.id, label: unit.name });
+    const roomId = selection.zoneId ?? (element ? roomOf(element.id, level.id) : null);
+    const room = roomId ? nodes[roomId] : undefined;
+    if (room?.type === 'zone')
+        crumbs.push({ kind: 'room', id: room.id, label: zoneLabel(room, i18n) });
+    if (element)
+        crumbs.push({ kind: 'node', id: element.id, label: nodeDisplayLabel(element) });
+    return crumbs;
+}
+/** The room or zone of a level around a level-local point: a detected room first. */
+function roomAtLevelPoint(levelId, point, nodes) {
+    const at = [point[0], point[1]];
+    const room = roomIndex(levelId, nodes).roomAtPoint(levelId, at);
+    if (room)
+        return room.key.zoneId;
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'zone' || node.parentId !== levelId || node.polygon.length < 3)
+            continue;
+        if (containsPoint([{ outer: node.polygon, holes: node.holes ?? [] }], at))
+            return node.id;
+    }
+    return null;
+}
+const center = new Vector3();
+/** The room an element stands in, from where its object sits on its floor. */
+export function roomOfObject(nodeId, levelId, source) {
+    const object = source.objectFor(nodeId);
+    const level = source.objectFor(levelId);
+    if (!(object && level))
+        return null;
+    box.setFromObject(object);
+    if (box.isEmpty())
+        object.getWorldPosition(center);
+    else
+        box.getCenter(center);
+    level.updateWorldMatrix(true, false);
+    level.worldToLocal(center);
+    return roomAtLevelPoint(levelId, [center.x, center.z], source.nodes);
+}
+/**
+ * What sits under the current floor: its units, its rooms, its other zones.
+ * An empty section is left out.
+ */
+export function viewerSidebarSections(levelId, nodes, i18n) {
+    const zones = Object.values(nodes).filter((node) => node.type === 'zone' && node.parentId === levelId && node.visible !== false);
+    const zoneRow = (zone) => ({
+        id: zone.id,
+        label: zoneLabel(zone, i18n),
+        color: zone.color,
+        areaM2: area([{ outer: zone.polygon, holes: zone.holes ?? [] }]),
+    });
+    const byName = (a, b) => a.label.localeCompare(b.label);
+    const units = Object.values(nodes)
+        .filter((node) => node.type === 'unit')
+        .flatMap((unit) => {
+        const report = buildUnitReport(unit, nodes);
+        const here = report.members.filter((member) => member.levelId === levelId);
+        if (here.length === 0)
+            return [];
+        return [
+            {
+                id: unit.id,
+                label: unit.name,
+                color: unit.color,
+                areaM2: here.reduce((sum, member) => sum + member.areaM2, 0),
+            },
+        ];
+    })
+        .sort(byName);
+    const sections = [
+        { kind: 'units', rows: units },
+        {
+            kind: 'rooms',
+            rows: zones
+                .filter((zone) => zone.spaceRole === 'room')
+                .map(zoneRow)
+                .sort(byName),
+        },
+        {
+            kind: 'zones',
+            rows: zones
+                .filter((zone) => zone.spaceRole !== 'room')
+                .map(zoneRow)
+                .sort(byName),
+        },
+    ];
+    return sections.filter((section) => section.rows.length > 0);
+}

package/dist/ui/lib/zone-content.d.ts

@@ -0,0 +1,6 @@
+import { type AnyNode, type AnyNodeId, type ZoneNode } from '@pascal-app/core';
+type Point2D = [number, number];
+export declare function polygonMatchesZoneFootprint(surfacePolygon: Point2D[], footprint: Point2D[]): boolean;
+export declare function collectZoneContentIds(nodes: Readonly<Record<AnyNodeId, AnyNode>>, zone: ZoneNode): AnyNodeId[];
+export {};
+//# sourceMappingURL=zone-content.d.ts.map

package/dist/ui/lib/zone-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-content.d.ts","sourceRoot":"","sources":["../../../src/ui/lib/zone-content.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAOd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAwC/B,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,OAAO,EAAE,EACzB,SAAS,EAAE,OAAO,EAAE,GACnB,OAAO,CAMT;AAwCD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,IAAI,EAAE,QAAQ,GACb,SAAS,EAAE,CA4Bb"}

package/dist/ui/lib/zone-content.js

@@ -0,0 +1,96 @@
+import { pointInPolygon2D, pointOnSegment, } from '@pascal-app/core';
+const POINT_TOLERANCE = 0.5;
+const COLLINEAR_TOLERANCE = 1e-6;
+const SURFACE_POLYGON_TOLERANCE = 0.15;
+function getPointToSegmentDistance(point, start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const lengthSq = dx * dx + dz * dz;
+    if (lengthSq === 0)
+        return Math.hypot(point[0] - start[0], point[1] - start[1]);
+    const rawT = ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSq;
+    const t = Math.max(0, Math.min(1, rawT));
+    const projected = [start[0] + t * dx, start[1] + t * dz];
+    return Math.hypot(point[0] - projected[0], point[1] - projected[1]);
+}
+function pointInPolygonWithTolerance(point, polygon) {
+    if (pointInPolygon2D(point, polygon, { includeBoundary: true }))
+        return true;
+    return polygon.some((start, index) => {
+        const end = polygon[(index + 1) % polygon.length];
+        return end ? getPointToSegmentDistance(point, start, end) <= POINT_TOLERANCE : false;
+    });
+}
+function polygonContainsWithTolerance(outer, inner, tolerance) {
+    return inner.every((point) => {
+        if (pointInPolygon2D(point, outer, { includeBoundary: true }))
+            return true;
+        return outer.some((start, index) => {
+            const end = outer[(index + 1) % outer.length];
+            return end ? getPointToSegmentDistance(point, start, end) <= tolerance : false;
+        });
+    });
+}
+export function polygonMatchesZoneFootprint(surfacePolygon, footprint) {
+    if (surfacePolygon.length < 3)
+        return false;
+    return (polygonContainsWithTolerance(footprint, surfacePolygon, SURFACE_POLYGON_TOLERANCE) &&
+        polygonContainsWithTolerance(surfacePolygon, footprint, SURFACE_POLYGON_TOLERANCE));
+}
+function areSegmentsCollinear(a, b, c, d) {
+    const abx = b[0] - a[0];
+    const abz = b[1] - a[1];
+    const acx = c[0] - a[0];
+    const acz = c[1] - a[1];
+    const adx = d[0] - a[0];
+    const adz = d[1] - a[1];
+    const crossC = abx * acz - abz * acx;
+    const crossD = abx * adz - abz * adx;
+    return Math.abs(crossC) <= COLLINEAR_TOLERANCE && Math.abs(crossD) <= COLLINEAR_TOLERANCE;
+}
+function segmentsOverlap(a, b, c, d) {
+    const useX = Math.abs(b[0] - a[0]) >= Math.abs(b[1] - a[1]);
+    const a0 = useX ? a[0] : a[1];
+    const a1 = useX ? b[0] : b[1];
+    const c0 = useX ? c[0] : c[1];
+    const c1 = useX ? d[0] : d[1];
+    const minA = Math.min(a0, a1);
+    const maxA = Math.max(a0, a1);
+    const minC = Math.min(c0, c1);
+    const maxC = Math.max(c0, c1);
+    return Math.max(minA, minC) <= Math.min(maxA, maxC) + COLLINEAR_TOLERANCE;
+}
+function wallLiesOnZoneBoundary(wall, polygon) {
+    return polygon.some((start, index) => {
+        const end = polygon[(index + 1) % polygon.length];
+        if (!end)
+            return false;
+        return (areSegmentsCollinear(wall.start, wall.end, start, end) &&
+            segmentsOverlap(wall.start, wall.end, start, end) &&
+            pointOnSegment(wall.start, start, end, POINT_TOLERANCE) &&
+            pointOnSegment(wall.end, start, end, POINT_TOLERANCE));
+    });
+}
+export function collectZoneContentIds(nodes, zone) {
+    const levelId = zone.parentId;
+    if (!levelId)
+        return [];
+    const footprint = zone.polygon.map((point) => [point[0], point[1]]);
+    const boundaryWalls = Object.values(nodes)
+        .filter((node) => node.type === 'wall' && node.parentId === levelId)
+        .filter((wall) => wallLiesOnZoneBoundary(wall, footprint));
+    const surfaces = Object.values(nodes)
+        .filter((node) => (node.type === 'slab' || node.type === 'ceiling') && node.parentId === levelId)
+        .filter((surface) => {
+        const polygon = surface.polygon.map((point) => [point[0], point[1]]);
+        return polygonMatchesZoneFootprint(polygon, footprint);
+    });
+    const floorItems = Object.values(nodes)
+        .filter((node) => node.type === 'item' && node.parentId === levelId)
+        .filter((item) => pointInPolygonWithTolerance([item.position[0], item.position[2]], footprint));
+    return Array.from(new Set([
+        ...boundaryWalls.map((wall) => wall.id),
+        ...surfaces.map((surface) => surface.id),
+        ...floorItems.map((item) => item.id),
+    ]));
+}

package/dist/ui/primitives/button.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from 'class-variance-authority';
+import type * as React from 'react';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "ghost" | "link" | "outline" | "secondary" | null | undefined;
+    size?: "default" | "icon" | "icon-lg" | "icon-sm" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ref, ...props }: React.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+export { Button, buttonVariants };
+//# sourceMappingURL=button.d.ts.map

package/dist/ui/primitives/button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button.d.ts","sourceRoot":"","sources":["../../../src/ui/primitives/button.tsx"],"names":[],"mappings":"AACA,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACjE,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAInC,QAAA,MAAM,cAAc;;;8EA4BnB,CAAA;AAED,iBAAS,MAAM,CAAC,EACd,SAAS,EACT,OAAO,EACP,IAAI,EACJ,OAAe,EACf,GAAG,EACH,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,GAC/B,YAAY,CAAC,OAAO,cAAc,CAAC,GAAG;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,qBAoBF;AAED,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAA"}

package/dist/ui/primitives/button.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Slot } from '@radix-ui/react-slot';
+import { cva } from 'class-variance-authority';
+import { cn } from '../lib/cn';
+const buttonVariants = cva("inline-flex shrink-0 items-center justify-center gap-2 whitespace-nowrap rounded-md font-barlow font-medium text-sm outline-none transition-all focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&_svg:not([class*='size-'])]:size-4 [&_svg]:pointer-events-none [&_svg]:shrink-0", {
+    variants: {
+        variant: {
+            default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+            destructive: 'bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:bg-destructive/60 dark:focus-visible:ring-destructive/40',
+            outline: 'border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50',
+            secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+            ghost: 'hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50',
+            link: 'text-primary underline-offset-4 hover:underline',
+        },
+        size: {
+            default: 'h-9 px-4 py-2 has-[>svg]:px-3',
+            sm: 'h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5',
+            lg: 'h-10 rounded-md px-6 has-[>svg]:px-4',
+            icon: 'size-9',
+            'icon-sm': 'size-8',
+            'icon-lg': 'size-10',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+        size: 'default',
+    },
+});
+function Button({ className, variant, size, asChild = false, ref, ...props }) {
+    if (asChild) {
+        return (_jsx(Slot, { className: cn(buttonVariants({ variant, size, className })), "data-slot": "button", ref: ref, ...props }));
+    }
+    return (_jsx("button", { className: cn(buttonVariants({ variant, size, className })), "data-slot": "button", ref: ref, ...props }));
+}
+export { Button, buttonVariants };

package/dist/ui/primitives/dropdown-menu.d.ts

@@ -0,0 +1,26 @@
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import type * as React from 'react';
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): React.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): React.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): React.JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): React.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): React.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: 'default' | 'destructive';
+}): React.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): React.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): React.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): React.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): React.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<'span'>): React.JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): React.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): React.JSX.Element;
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, };
+//# sourceMappingURL=dropdown-menu.d.ts.map

package/dist/ui/primitives/dropdown-menu.d.ts.map

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