@pascal-app/viewer 1.1.0 → 1.1.1

package/dist/ui/floorplan/floorplan-preview-geometry.js

@@ -0,0 +1,173 @@
+const IDENTITY = { tx: 0, ty: 0, rotation: 0 };
+const MIN_VIEWBOX_SIZE = 0.25;
+const MAX_VIEWBOX_SIZE = 500;
+function clientToViewBoxFraction(viewBox, viewport, clientX, clientY) {
+    const viewportWidth = Math.max(viewport.width, 1);
+    const viewportHeight = Math.max(viewport.height, 1);
+    const scale = Math.min(viewportWidth / viewBox.width, viewportHeight / viewBox.height);
+    const renderedWidth = viewBox.width * scale;
+    const renderedHeight = viewBox.height * scale;
+    const renderedLeft = viewport.left + (viewportWidth - renderedWidth) / 2;
+    const renderedTop = viewport.top + (viewportHeight - renderedHeight) / 2;
+    return [(clientX - renderedLeft) / renderedWidth, (clientY - renderedTop) / renderedHeight];
+}
+export function clientToFloorplanPoint(viewBox, viewport, clientX, clientY) {
+    const [fractionX, fractionY] = clientToViewBoxFraction(viewBox, viewport, clientX, clientY);
+    return [viewBox.x + fractionX * viewBox.width, viewBox.y + fractionY * viewBox.height];
+}
+export function scaleFloorplanViewBox(viewBox, factor, anchorX = 0.5, anchorY = 0.5) {
+    const minFactor = Math.max(MIN_VIEWBOX_SIZE / viewBox.width, MIN_VIEWBOX_SIZE / viewBox.height);
+    const maxFactor = Math.min(MAX_VIEWBOX_SIZE / viewBox.width, MAX_VIEWBOX_SIZE / viewBox.height);
+    const clampedFactor = Math.min(Math.max(factor, minFactor), maxFactor);
+    const width = viewBox.width * clampedFactor;
+    const height = viewBox.height * clampedFactor;
+    return {
+        x: viewBox.x + (viewBox.width - width) * anchorX,
+        y: viewBox.y + (viewBox.height - height) * anchorY,
+        width,
+        height,
+    };
+}
+export function scaleFloorplanViewBoxBetweenClients(viewBox, factor, viewport, sourceClient, targetClient) {
+    const sourcePoint = clientToFloorplanPoint(viewBox, viewport, sourceClient[0], sourceClient[1]);
+    const [targetX, targetY] = clientToViewBoxFraction(viewBox, viewport, targetClient[0], targetClient[1]);
+    const scaled = scaleFloorplanViewBox(viewBox, factor, 0, 0);
+    return {
+        ...scaled,
+        x: sourcePoint[0] - targetX * scaled.width,
+        y: sourcePoint[1] - targetY * scaled.height,
+    };
+}
+export function panFloorplanViewBox(viewBox, viewport, sourceClient, targetClient) {
+    const sourcePoint = clientToFloorplanPoint(viewBox, viewport, sourceClient[0], sourceClient[1]);
+    const targetPoint = clientToFloorplanPoint(viewBox, viewport, targetClient[0], targetClient[1]);
+    return {
+        ...viewBox,
+        x: viewBox.x + sourcePoint[0] - targetPoint[0],
+        y: viewBox.y + sourcePoint[1] - targetPoint[1],
+    };
+}
+function applyTransform(point, transform) {
+    const cos = Math.cos(transform.rotation);
+    const sin = Math.sin(transform.rotation);
+    return [
+        point[0] * cos - point[1] * sin + transform.tx,
+        point[0] * sin + point[1] * cos + transform.ty,
+    ];
+}
+function composeTransform(parent, child) {
+    const translated = applyTransform(child.translate ?? [0, 0], parent);
+    return {
+        tx: translated[0],
+        ty: translated[1],
+        rotation: parent.rotation + (child.rotate ?? 0),
+    };
+}
+function includePoint(bounds, point) {
+    if (!bounds)
+        return { minX: point[0], minY: point[1], maxX: point[0], maxY: point[1] };
+    return {
+        minX: Math.min(bounds.minX, point[0]),
+        minY: Math.min(bounds.minY, point[1]),
+        maxX: Math.max(bounds.maxX, point[0]),
+        maxY: Math.max(bounds.maxY, point[1]),
+    };
+}
+function includePoints(bounds, points, transform) {
+    let next = bounds;
+    for (const point of points)
+        next = includePoint(next, applyTransform(point, transform));
+    return next;
+}
+function geometryBounds(geometry, transform, bounds) {
+    switch (geometry.kind) {
+        case 'group': {
+            const nextTransform = geometry.transform
+                ? composeTransform(transform, geometry.transform)
+                : transform;
+            return geometry.children.reduce((next, child) => geometryBounds(child, nextTransform, next), bounds);
+        }
+        case 'polygon':
+        case 'polyline':
+        case 'hatch':
+            return includePoints(bounds, geometry.points, transform);
+        case 'rect':
+            return includePoints(bounds, [
+                [geometry.x, geometry.y],
+                [geometry.x + geometry.width, geometry.y],
+                [geometry.x + geometry.width, geometry.y + geometry.height],
+                [geometry.x, geometry.y + geometry.height],
+            ], transform);
+        case 'circle': {
+            const center = applyTransform([geometry.cx, geometry.cy], transform);
+            return includePoints(bounds, [
+                [center[0] - geometry.r, center[1] - geometry.r],
+                [center[0] + geometry.r, center[1] + geometry.r],
+            ], IDENTITY);
+        }
+        case 'line':
+        case 'hit-line':
+        case 'edge-handle':
+            return includePoints(bounds, [
+                [geometry.x1, geometry.y1],
+                [geometry.x2, geometry.y2],
+            ], transform);
+        case 'text':
+            return includePoint(bounds, applyTransform([geometry.x, geometry.y], transform));
+        case 'image': {
+            const halfWidth = geometry.width / 2;
+            const halfHeight = geometry.height / 2;
+            const imageTransform = composeTransform(transform, {
+                translate: geometry.center,
+                rotate: geometry.rotation,
+            });
+            return includePoints(bounds, [
+                [-halfWidth, -halfHeight],
+                [halfWidth, -halfHeight],
+                [halfWidth, halfHeight],
+                [-halfWidth, halfHeight],
+            ], imageTransform);
+        }
+        case 'endpoint-handle':
+        case 'midpoint-handle':
+        case 'move-handle':
+        case 'move-arrow':
+        case 'rotate-arrow':
+        case 'equal-spacing-badge':
+            return includePoint(bounds, applyTransform(geometry.point, transform));
+        case 'dimension-label':
+            return includePoint(bounds, applyTransform([geometry.cx, geometry.cy], transform));
+        case 'dimension':
+            return includePoints(bounds, [
+                geometry.start,
+                geometry.end,
+                geometry.dimensionStart ?? geometry.start,
+                geometry.dimensionEnd ?? geometry.end,
+            ], transform);
+        case 'dimension-string':
+            return geometry.segments.reduce((next, segment) => includePoints(next, [
+                segment.start,
+                segment.end,
+                segment.dimensionStart ?? segment.start,
+                segment.dimensionEnd ?? segment.end,
+            ], transform), bounds);
+        case 'path':
+            return bounds;
+        default:
+            return bounds;
+    }
+}
+export function getFloorplanBounds(geometries) {
+    return geometries.reduce((bounds, geometry) => geometryBounds(geometry, IDENTITY, bounds), null);
+}
+export function padFloorplanBounds(bounds, ratio = 0.12) {
+    const width = Math.max(bounds.maxX - bounds.minX, 1);
+    const height = Math.max(bounds.maxY - bounds.minY, 1);
+    const padding = Math.max(Math.max(width, height) * ratio, 0.75);
+    return {
+        minX: bounds.minX - padding,
+        minY: bounds.minY - padding,
+        maxX: bounds.maxX + padding,
+        maxY: bounds.maxY + padding,
+    };
+}

package/dist/ui/floorplan/floorplan-preview-navigation.d.ts

@@ -0,0 +1,22 @@
+import type { NavigationSyncPose } from '../store/navigation-sync-pose-store';
+import type { FloorplanViewBox } from './floorplan-preview-geometry';
+export type FloorplanPreviewViewportSize = {
+    width: number;
+    height: number;
+};
+export declare function nearestEquivalentDegrees(angle: number, reference: number): number;
+export declare function floorplanRotationFromCameraAzimuth(azimuth: number, reference: number): number;
+export declare function cameraAzimuthFromFloorplanRotation(rotationDeg: number): number;
+export declare function rotateFloorplanPoint(point: {
+    x: number;
+    y: number;
+}, rotationDeg: number): {
+    x: number;
+    y: number;
+};
+export declare function visibleFloorplanViewWidth(viewBox: FloorplanViewBox, viewport: FloorplanPreviewViewportSize): number;
+export declare function floorplanViewBoxFromNavigationPose(pose: NavigationSyncPose, localCenter: {
+    x: number;
+    y: number;
+}, sceneRotationDeg: number, viewport: FloorplanPreviewViewportSize): FloorplanViewBox;
+//# sourceMappingURL=floorplan-preview-navigation.d.ts.map

package/dist/ui/floorplan/floorplan-preview-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-preview-navigation.d.ts","sourceRoot":"","sources":["../../../src/ui/floorplan/floorplan-preview-navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAA;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AAEpE,MAAM,MAAM,4BAA4B,GAAG;IACzC,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAKxE;AAED,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAEpF;AAED,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,MAAM,UAErE;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC/B,WAAW,EAAE,MAAM,GAClB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAS1B;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,4BAA4B,UAIvC;AAED,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EACrC,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,4BAA4B,GACrC,gBAAgB,CAWlB"}

package/dist/ui/floorplan/floorplan-preview-navigation.js

@@ -0,0 +1,41 @@
+export function nearestEquivalentDegrees(angle, reference) {
+    let next = angle;
+    while (next - reference > 180)
+        next -= 360;
+    while (next - reference < -180)
+        next += 360;
+    return next;
+}
+export function floorplanRotationFromCameraAzimuth(azimuth, reference) {
+    return nearestEquivalentDegrees((azimuth * 180) / Math.PI, reference);
+}
+export function cameraAzimuthFromFloorplanRotation(rotationDeg) {
+    return (rotationDeg * Math.PI) / 180;
+}
+export function rotateFloorplanPoint(point, rotationDeg) {
+    if (rotationDeg === 0)
+        return point;
+    const radians = (rotationDeg * Math.PI) / 180;
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    return {
+        x: point.x * cos - point.y * sin,
+        y: point.x * sin + point.y * cos,
+    };
+}
+export function visibleFloorplanViewWidth(viewBox, viewport) {
+    const aspect = Math.max(viewport.width, 1) / Math.max(viewport.height, 1);
+    return Math.max(viewBox.width, viewBox.height * aspect);
+}
+export function floorplanViewBoxFromNavigationPose(pose, localCenter, sceneRotationDeg, viewport) {
+    const center = rotateFloorplanPoint(localCenter, sceneRotationDeg);
+    const aspect = Math.max(viewport.width, 1) / Math.max(viewport.height, 1);
+    const width = Math.max(pose.viewWidth, 0.001);
+    const height = width / aspect;
+    return {
+        x: center.x - width / 2,
+        y: center.y - height / 2,
+        width,
+        height,
+    };
+}

package/dist/ui/floorplan/floorplan-preview-visibility.d.ts

@@ -0,0 +1,8 @@
+import { type AnyNode } from '@pascal-app/core';
+/**
+ * A node draws in the plan unless it, or an ancestor whose flag reaches its
+ * descendants, is hidden. A hidden Site keeps its buildings on the plan; see
+ * `hidesDescendants`.
+ */
+export declare function isVisibleInFloorplan(node: AnyNode, nodes: Record<string, AnyNode>): boolean;
+//# sourceMappingURL=floorplan-preview-visibility.d.ts.map

package/dist/ui/floorplan/floorplan-preview-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-preview-visibility.d.ts","sourceRoot":"","sources":["../../../src/ui/floorplan/floorplan-preview-visibility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAoB,MAAM,kBAAkB,CAAA;AAEjE;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAW3F"}

package/dist/ui/floorplan/floorplan-preview-visibility.js

@@ -0,0 +1,21 @@
+import { hidesDescendants } from '@pascal-app/core';
+/**
+ * A node draws in the plan unless it, or an ancestor whose flag reaches its
+ * descendants, is hidden. A hidden Site keeps its buildings on the plan; see
+ * `hidesDescendants`.
+ */
+export function isVisibleInFloorplan(node, nodes) {
+    if (node.visible === false)
+        return false;
+    const seen = new Set([node.id]);
+    let current = node.parentId ? nodes[node.parentId] : undefined;
+    while (current) {
+        if (seen.has(current.id))
+            return true;
+        seen.add(current.id);
+        if (current.visible === false && hidesDescendants(current))
+            return false;
+        current = current.parentId ? nodes[current.parentId] : undefined;
+    }
+    return true;
+}

package/dist/ui/floorplan/floorplan-preview.d.ts

@@ -0,0 +1,19 @@
+import { type AnyNode } from '@pascal-app/core';
+export type FloorplanPreviewScene = {
+    nodes: Record<string, AnyNode>;
+    installedPlugins?: readonly string[];
+};
+export type FloorplanPreviewProps = {
+    className?: string;
+    compassHost?: Element | null;
+    levelId?: string | null;
+    navigationVisible?: boolean;
+    onLevelChange?: (levelId: string) => void;
+    scene?: FloorplanPreviewScene | null;
+    showCompass?: boolean;
+    showLevelSelector?: boolean;
+    synchronizeNavigation?: boolean;
+};
+export declare function normalizeFloorplanPreviewNodes(nodes: Record<string, unknown>): Record<string, AnyNode>;
+export declare function FloorplanPreview({ className, compassHost, levelId, navigationVisible, onLevelChange, scene, showCompass, showLevelSelector, synchronizeNavigation, }: FloorplanPreviewProps): import("react").JSX.Element;
+//# sourceMappingURL=floorplan-preview.d.ts.map

package/dist/ui/floorplan/floorplan-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-preview.d.ts","sourceRoot":"","sources":["../../../src/ui/floorplan/floorplan-preview.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EAeb,MAAM,kBAAkB,CAAA;AAwEzB,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,KAAK,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAA;IACpC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,CAAA;AA4DD,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsBzB;AA2GD,wBAAgB,gBAAgB,CAAC,EAC/B,SAAS,EACT,WAAW,EACX,OAAO,EACP,iBAAwB,EACxB,aAAa,EACb,KAAK,EACL,WAAkB,EAClB,iBAAwB,EACxB,qBAA6B,GAC9B,EAAE,qBAAqB,+BA4uBvB"}