@pascal-app/viewer 1.1.0 → 1.1.2

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

@@ -0,0 +1,317 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { floorplanAnnotationObstacleMode, isFloorplanAnnotationObstacleGeometry, loadAssetUrl, readFloorplanGeometryMetadata, } from '@pascal-app/core';
+import { memo, useEffect, useState } from 'react';
+import { FloorplanDimensionRenderer, FloorplanDimensionStringRenderer, } from './floorplan-dimension-renderer';
+import { resolveFloorplanLabelAngle } from './floorplan-label-angle';
+const STATIC_LABEL_UNITS_PER_PIXEL = 0.01;
+const DOCUMENT_DEFAULT_TEXT_SIZE_PT = 8;
+const DOCUMENT_ROOM_NAME_TEXT_SIZE_PT = 8;
+const DOCUMENT_ROOM_NUMBER_TEXT_SIZE_PT = 7;
+const DOCUMENT_ROOM_DETAIL_TEXT_SIZE_PT = 5.5;
+const DOCUMENT_COLUMN_MARK_TEXT_SIZE_PT = 7;
+const DOCUMENT_DEFAULT_STROKE_WIDTH_PT = 0.5;
+const DOCUMENT_TEXT_OUTLINE_MIN_WIDTH_PT = 0.75;
+const DOCUMENT_MARK_HEIGHT_PT = 14;
+const PDF_ANNOTATION_STROKE_WIDTH_PT = 0.5;
+/**
+ * Pure-data → SVG converter. Walks a `FloorplanGeometry` tree returned by
+ * `def.floorplan(node, ctx)` and emits the matching React-SVG nodes.
+ *
+ * Coordinates are level-local meters. The wrapping floor-plan panel
+ * applies the world→SVG transform via its viewBox, so kinds emit
+ * geometry in the same units they reason about in 3D.
+ *
+ * Group transforms compose: `transform={translate(x y) rotate(deg)}`.
+ * Rotations are radians at the data layer (consistent with three.js
+ * conventions used by `def.geometry`) and converted to degrees for SVG
+ * here — kinds never touch units.
+ *
+ * Styling props map straight onto SVG attributes. Builders that need
+ * theme colors should declare them inline or expose them as registry
+ * tokens later (deferred until a real need surfaces — AI-authored kinds
+ * can pick safe defaults today).
+ */
+export const FloorplanGeometryRenderer = memo(function FloorplanGeometryRenderer({ geometry, pointerEventsOverride, sceneRotationDeg = 0, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode = 'screen', }) {
+    return renderNode(geometry, 0, pointerEventsOverride, sceneRotationDeg, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode);
+});
+function styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode = 'screen') {
+    // Shared SVG attribute mapping for any styled primitive. Keeps the per-
+    // primitive switch arms terse and ensures new style fields land
+    // everywhere at once. `as any` avoids re-asserting every variant
+    // includes the style fields — they all do, except `group` (which is
+    // filtered out by the caller's type bound).
+    const s = g;
+    const annotationMetadata = readFloorplanGeometryMetadata(g);
+    const documentStyle = resolveDocumentFloorplanAnnotationStyle(g, annotationUnitsPerPoint);
+    const vectorEffect = documentStyle.vectorEffect ?? s.vectorEffect;
+    const resolvedStrokeWidth = documentStyle.strokeWidth ?? s.strokeWidth;
+    const strokeWidth = renderMode === 'pdf' &&
+        vectorEffect === 'non-scaling-stroke' &&
+        resolvedStrokeWidth !== undefined
+        ? Math.min(PDF_ANNOTATION_STROKE_WIDTH_PT, resolvedStrokeWidth)
+        : resolvedStrokeWidth;
+    return {
+        'data-floorplan-annotation-obstacle': floorplanAnnotationObstacleMode(g),
+        'data-floorplan-annotation-role': annotationMetadata.annotationRole,
+        fill: documentStyle.fill ?? s.fill ?? 'none',
+        fillRule: s.fillRule,
+        fillOpacity: s.fillOpacity,
+        stroke: documentStyle.stroke ?? s.stroke,
+        strokeWidth,
+        strokeDasharray: s.strokeDasharray,
+        strokeLinecap: s.strokeLinecap,
+        strokeLinejoin: s.strokeLinejoin,
+        strokeOpacity: s.strokeOpacity,
+        opacity: s.opacity,
+        vectorEffect,
+        pointerEvents: pointerEventsOverride ?? s.pointerEvents,
+        style: s.cursor ? { cursor: s.cursor } : undefined,
+    };
+}
+export function resolveDocumentFloorplanAnnotationStyle(geometry, annotationUnitsPerPoint) {
+    if (annotationUnitsPerPoint === undefined)
+        return {};
+    const styled = geometry;
+    if (!styled.stroke && geometry.kind !== 'text')
+        return {};
+    if (geometry.kind === 'text') {
+        const sourceFontSize = Math.max(geometry.fontSize, 1e-6);
+        const sourceStrokeWidth = geometry.strokeWidth ?? 0;
+        const outlineRatio = sourceStrokeWidth > 0 ? sourceStrokeWidth / sourceFontSize : 0;
+        const fontSize = documentTextFontSize(geometry, annotationUnitsPerPoint);
+        return {
+            strokeWidth: geometry.stroke && outlineRatio > 0
+                ? Math.max(DOCUMENT_TEXT_OUTLINE_MIN_WIDTH_PT * annotationUnitsPerPoint, fontSize * outlineRatio)
+                : undefined,
+        };
+    }
+    return {
+        strokeWidth: documentStrokeWidth(styled, annotationUnitsPerPoint),
+        vectorEffect: 'non-scaling-stroke',
+    };
+}
+function documentTextFontSize(geometry, annotationUnitsPerPoint) {
+    return documentTextSizePt(geometry) * annotationUnitsPerPoint;
+}
+function documentTextSizePt(geometry) {
+    const metadata = readFloorplanGeometryMetadata(geometry);
+    // an explicit paper size wins over the role's (a sheet's room tag sets its own)
+    if (typeof metadata.textSizePt === 'number' && metadata.textSizePt > 0)
+        return metadata.textSizePt;
+    switch (metadata.annotationRole) {
+        case 'room-label':
+            if (geometry.fontSize >= 0.18)
+                return DOCUMENT_ROOM_NAME_TEXT_SIZE_PT;
+            if (geometry.fontSize >= 0.145)
+                return DOCUMENT_ROOM_NUMBER_TEXT_SIZE_PT;
+            return DOCUMENT_ROOM_DETAIL_TEXT_SIZE_PT;
+        case 'column-center':
+        case 'stair-annotation':
+            return DOCUMENT_COLUMN_MARK_TEXT_SIZE_PT;
+        default:
+            return DOCUMENT_DEFAULT_TEXT_SIZE_PT;
+    }
+}
+function documentStrokeWidth(geometry, annotationUnitsPerPoint) {
+    return Math.max(DOCUMENT_DEFAULT_STROKE_WIDTH_PT, Math.min(1.2, geometry.strokeWidth ?? 0.5));
+}
+export function documentRectGeometryAttrs(geometry, annotationUnitsPerPoint) {
+    if (annotationUnitsPerPoint === undefined || !isAnnotationMarkRect(geometry)) {
+        return {
+            x: geometry.x,
+            y: geometry.y,
+            width: geometry.width,
+            height: geometry.height,
+            rx: geometry.rx,
+            ry: geometry.ry,
+        };
+    }
+    const centerX = geometry.x + geometry.width / 2;
+    const centerY = geometry.y + geometry.height / 2;
+    const height = DOCUMENT_MARK_HEIGHT_PT * annotationUnitsPerPoint;
+    const width = Math.max(height * 1.6, (geometry.width / Math.max(geometry.height, 1e-6)) * height);
+    return {
+        x: centerX - width / 2,
+        y: centerY - height / 2,
+        width,
+        height,
+        rx: height / 2,
+        ry: height / 2,
+    };
+}
+function isAnnotationMarkRect(geometry) {
+    return geometry.fill === '#ffffff' && !!geometry.stroke && geometry.height <= 0.5;
+}
+export function documentCircleGeometryAttrs(geometry, annotationUnitsPerPoint) {
+    if (annotationUnitsPerPoint === undefined || !isAnnotationMarkCircle(geometry)) {
+        return { r: geometry.r };
+    }
+    return { r: Math.max(geometry.r, (DOCUMENT_MARK_HEIGHT_PT / 2) * annotationUnitsPerPoint) };
+}
+function isAnnotationMarkCircle(geometry) {
+    return geometry.fill === '#ffffff' && !!geometry.stroke && geometry.r <= 0.25;
+}
+export function resolveDocumentAnnotationGroupChildren(children, annotationUnitsPerPoint) {
+    if (annotationUnitsPerPoint === undefined)
+        return children;
+    const next = [...children];
+    let start = 0;
+    while (start < next.length) {
+        const first = next[start];
+        if (!isDocumentTextLine(first)) {
+            start++;
+            continue;
+        }
+        let end = start + 1;
+        while (end < next.length && isSameDocumentTextRun(first, next[end]))
+            end++;
+        if (end - start > 1) {
+            const run = next.slice(start, end);
+            const adjusted = positionDocumentTextRun(run, annotationUnitsPerPoint);
+            for (let index = 0; index < adjusted.length; index++) {
+                const line = adjusted[index];
+                if (line)
+                    next[start + index] = line;
+            }
+        }
+        start = end;
+    }
+    return next;
+}
+function isDocumentTextLine(geometry) {
+    return geometry?.kind === 'text' && geometry.upright === true;
+}
+function isSameDocumentTextRun(first, candidate) {
+    return (isDocumentTextLine(candidate) &&
+        Math.abs(candidate.x - first.x) < 1e-6 &&
+        candidate.textAnchor === first.textAnchor &&
+        readFloorplanGeometryMetadata(candidate).annotationRole ===
+            readFloorplanGeometryMetadata(first).annotationRole);
+}
+function positionDocumentTextRun(run, annotationUnitsPerPoint) {
+    const centerY = run.reduce((sum, line) => sum + line.y, 0) / run.length;
+    const steps = run.slice(0, -1).map((line, index) => {
+        const next = run[index + 1] ?? line;
+        const largerFontPt = Math.max(documentTextSizePt(line), documentTextSizePt(next));
+        return largerFontPt * 1.25 * annotationUnitsPerPoint;
+    });
+    const totalHeight = steps.reduce((sum, step) => sum + step, 0);
+    let y = centerY - totalHeight / 2;
+    return run.map((line, index) => {
+        if (index > 0)
+            y += steps[index - 1] ?? 0;
+        return { ...line, y };
+    });
+}
+function renderNode(g, keyHint, pointerEventsOverride, sceneRotationDeg = 0, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode = 'screen') {
+    switch (g.kind) {
+        case 'path':
+            return (_jsx("path", { d: g.d, ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        case 'polygon':
+            return (_jsx("polygon", { points: pointsToAttr(g.points), ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        case 'polyline':
+            return (_jsx("polyline", { points: pointsToAttr(g.points), ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        case 'rect': {
+            const attrs = documentRectGeometryAttrs(g, annotationUnitsPerPoint);
+            return (_jsx("rect", { height: attrs.height, rx: attrs.rx, ry: attrs.ry, width: attrs.width, x: attrs.x, y: attrs.y, ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        }
+        case 'circle': {
+            const attrs = documentCircleGeometryAttrs(g, annotationUnitsPerPoint);
+            return (_jsx("circle", { cx: g.cx, cy: g.cy, r: attrs.r, ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        }
+        case 'line':
+            return (_jsx("line", { x1: g.x1, x2: g.x2, y1: g.y1, y2: g.y2, ...styleAttrs(g, pointerEventsOverride, annotationUnitsPerPoint, renderMode) }, keyHint));
+        case 'text': {
+            const fontSize = annotationUnitsPerPoint !== undefined
+                ? documentTextFontSize(g, annotationUnitsPerPoint)
+                : g.fontSize;
+            const textStyle = resolveDocumentFloorplanAnnotationStyle(g, annotationUnitsPerPoint);
+            const pdfOutlinedText = renderMode === 'pdf' && g.paintOrder === 'stroke' && !!g.stroke;
+            const fill = pdfOutlinedText && g.fill?.toLocaleLowerCase() === '#ffffff'
+                ? g.stroke
+                : (g.fill ?? '#171717');
+            if (g.upright) {
+                return (_jsx("g", { "data-floorplan-annotation-obstacle": floorplanAnnotationObstacleMode(g), transform: `translate(${g.x} ${g.y}) rotate(${-sceneRotationDeg})`, children: _jsx("text", { dominantBaseline: g.dominantBaseline ?? 'middle', fill: fill, fontFamily: g.fontFamily, fontSize: fontSize, fontWeight: g.fontWeight, opacity: g.opacity, paintOrder: pdfOutlinedText ? undefined : g.paintOrder, pointerEvents: pointerEventsOverride, stroke: pdfOutlinedText ? undefined : g.stroke, strokeLinecap: !pdfOutlinedText && g.stroke ? 'round' : undefined, strokeLinejoin: !pdfOutlinedText && g.stroke ? 'round' : undefined, strokeWidth: pdfOutlinedText ? undefined : (textStyle.strokeWidth ?? g.strokeWidth), textAnchor: g.textAnchor ?? 'start', x: 0, y: 0, children: g.text }) }, keyHint));
+            }
+            return (_jsx("text", { "data-floorplan-annotation-obstacle": floorplanAnnotationObstacleMode(g), dominantBaseline: g.dominantBaseline ?? 'middle', fill: fill, fontFamily: g.fontFamily, fontSize: fontSize, fontWeight: g.fontWeight, opacity: g.opacity, paintOrder: pdfOutlinedText ? undefined : g.paintOrder, stroke: pdfOutlinedText ? undefined : g.stroke, strokeLinecap: !pdfOutlinedText && g.stroke ? 'round' : undefined, strokeLinejoin: !pdfOutlinedText && g.stroke ? 'round' : undefined, strokeWidth: pdfOutlinedText ? undefined : (textStyle.strokeWidth ?? g.strokeWidth), textAnchor: g.textAnchor ?? 'start', pointerEvents: pointerEventsOverride, x: g.x, y: g.y, children: g.text }, keyHint));
+        }
+        case 'dimension':
+            return (_jsx(FloorplanDimensionRenderer, { geometry: g, sceneRotationDeg: sceneRotationDeg, annotationUnitsPerPoint: annotationUnitsPerPoint, renderMode: renderMode }, keyHint));
+        case 'dimension-string':
+            return (_jsx(FloorplanDimensionStringRenderer, { annotationUnitsPerPoint: annotationUnitsPerPoint, geometry: g, renderMode: renderMode, sceneRotationDeg: sceneRotationDeg }, keyHint));
+        case 'dimension-label': {
+            const unitsPerPixel = annotationUnitsPerPoint ?? screenUnitsPerPixel ?? STATIC_LABEL_UNITS_PER_PIXEL;
+            const documentMode = annotationUnitsPerPoint !== undefined;
+            const outlined = g.appearance === 'outlined';
+            const pdfOutlined = outlined && renderMode === 'pdf';
+            const padX = unitsPerPixel * 6;
+            const padY = unitsPerPixel * 3;
+            const fontSize = unitsPerPixel * (documentMode ? 8 : outlined ? 12 : 10);
+            const textWidth = g.text.length * unitsPerPixel * 6.2;
+            const plateW = textWidth + padX * 2;
+            const plateH = fontSize + padY * 2;
+            const degrees = resolveFloorplanLabelAngle(g.angle, sceneRotationDeg, g.screenUpright);
+            const labelTransform = `translate(${g.cx} ${g.cy}) rotate(${degrees}) translate(0 ${-(g.offsetPx ?? 0) * unitsPerPixel})`;
+            return (_jsxs("g", { "data-floorplan-annotation-angle-radians": g.angle, "data-floorplan-annotation-default-transform": labelTransform, "data-floorplan-annotation-label": "", "data-floorplan-annotation-priority": "20", "data-floorplan-annotation-screen-upright": g.screenUpright ? 'true' : undefined, "data-floorplan-annotation-transform-after-rotation": `translate(0 ${-(g.offsetPx ?? 0) * unitsPerPixel})`, "data-floorplan-annotation-transform-before-rotation": `translate(${g.cx} ${g.cy})`, pointerEvents: "none", transform: labelTransform, children: [outlined && !pdfOutlined ? null : (_jsx("rect", { "data-floorplan-dimension-label-plate": pdfOutlined ? '' : undefined, fill: "#ffffff", height: plateH, opacity: 0.92, rx: unitsPerPixel * 3, ry: unitsPerPixel * 3, stroke: pdfOutlined ? undefined : '#334155', strokeWidth: pdfOutlined ? undefined : unitsPerPixel * 0.5, width: plateW, x: -plateW / 2, y: -plateH / 2 })), _jsx("text", { dominantBaseline: "middle", fill: pdfOutlined ? '#111827' : outlined ? '#ffffff' : '#111827', fontFamily: outlined && !pdfOutlined
+                            ? 'system-ui, -apple-system, sans-serif'
+                            : 'ui-monospace, SFMono-Regular, Menlo, monospace', fontSize: fontSize, fontWeight: outlined ? 500 : 600, paintOrder: outlined && !pdfOutlined ? 'stroke' : undefined, stroke: outlined && !pdfOutlined ? '#334155' : undefined, strokeLinecap: outlined && !pdfOutlined ? 'round' : undefined, strokeLinejoin: outlined && !pdfOutlined ? 'round' : undefined, strokeWidth: outlined && !pdfOutlined ? fontSize * 0.35 : undefined, textAnchor: "middle", x: 0, y: 0, children: g.text })] }, keyHint));
+        }
+        case 'image':
+            return (_jsx(FloorplanImage, { center: g.center, height: g.height, opacity: g.opacity, preserveAspectRatio: g.preserveAspectRatio ?? 'xMidYMid meet', rotation: g.rotation ?? 0, url: g.url, width: g.width }, keyHint));
+        case 'group': {
+            const transform = formatTransform(g.transform);
+            const children = resolveDocumentAnnotationGroupChildren(g.children, annotationUnitsPerPoint);
+            return (_jsx("g", { "data-floorplan-annotation-obstacle": isFloorplanAnnotationObstacleGeometry(g) ? '' : undefined, transform: transform, children: children.map((child, i) => renderNode(child, i, pointerEventsOverride, sceneRotationDeg, annotationUnitsPerPoint, screenUnitsPerPixel, renderMode)) }, keyHint));
+        }
+        // The remaining interactive primitives (hatch / hit-line / endpoint-handle)
+        // need the SVG context + theme palette + units-per-
+        // pixel that only the registry layer has access to. They're rendered
+        // by `floorplan-registry-layer.tsx`'s interactive walker instead. If
+        // a caller routes one of these through this pure renderer it
+        // silently drops — the static renderer is for static output.
+        default:
+            return null;
+    }
+}
+function pointsToAttr(points) {
+    return points.map(([x, y]) => `${x},${y}`).join(' ');
+}
+function formatTransform(t) {
+    if (!t)
+        return undefined;
+    const parts = [];
+    if (t.translate)
+        parts.push(`translate(${t.translate[0]} ${t.translate[1]})`);
+    if (t.rotate !== undefined)
+        parts.push(`rotate(${(t.rotate * 180) / Math.PI})`);
+    return parts.length > 0 ? parts.join(' ') : undefined;
+}
+/**
+ * `image` primitive renderer. Resolves the URL asynchronously via
+ * `loadAssetUrl` (handles CDN / Supabase storage) and renders an SVG
+ * `<image>` centered at `center`, rotated around it, sized in plan-local
+ * metres. While the resolution is in flight, renders nothing.
+ */
+function FloorplanImage({ url, center, width, height, rotation, preserveAspectRatio, opacity, }) {
+    const [resolvedUrl, setResolvedUrl] = useState(null);
+    useEffect(() => {
+        if (!url) {
+            setResolvedUrl(null);
+            return;
+        }
+        let cancelled = false;
+        setResolvedUrl(null);
+        loadAssetUrl(url).then((next) => {
+            if (!cancelled)
+                setResolvedUrl(next);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [url]);
+    if (!resolvedUrl)
+        return null;
+    const rotationDeg = (rotation * 180) / Math.PI;
+    return (_jsx("g", { pointerEvents: "none", transform: `translate(${center[0]} ${center[1]}) rotate(${rotationDeg})`, children: _jsx("image", { height: height, href: resolvedUrl, opacity: opacity, preserveAspectRatio: preserveAspectRatio, width: width, x: -width / 2, y: -height / 2 }) }));
+}

package/dist/ui/floorplan/floorplan-label-angle.d.ts

@@ -0,0 +1,24 @@
+export declare function resolveFloorplanLabelAngle(angleRadians: number, sceneRotationDeg: number, screenUpright?: boolean): number;
+export declare function shouldUpdateFloorplanLabelRotation(previousRotationDeg: number | null, nextRotationDeg: number, minimumDeltaDeg?: number): boolean;
+export declare function resolveFloorplanAnnotationUpdate({ layoutInputsChanged, previousRotationDeg, nextRotationDeg, }: {
+    layoutInputsChanged: boolean;
+    previousRotationDeg: number | null;
+    nextRotationDeg: number;
+}): {
+    resolveCollisions: boolean;
+    updateLabelPresentation: boolean;
+};
+export declare function resolveFloorplanAnnotationLabelTransform({ angleRadians, sceneRotationDeg, screenUpright, beforeRotation, afterRotation, layoutDx, layoutDy, }: {
+    angleRadians: number;
+    sceneRotationDeg: number;
+    screenUpright: boolean;
+    beforeRotation: string;
+    afterRotation: string;
+    layoutDx?: number;
+    layoutDy?: number;
+}): {
+    defaultTransform: string;
+    transform: string;
+};
+export declare function updateSvgFloorplanLabelOrientations(labels: Iterable<SVGGElement>, sceneRotationDeg: number): number;
+//# sourceMappingURL=floorplan-label-angle.d.ts.map

package/dist/ui/floorplan/floorplan-label-angle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-label-angle.d.ts","sourceRoot":"","sources":["../../../src/ui/floorplan/floorplan-label-angle.ts"],"names":[],"mappings":"AAAA,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,aAAa,UAAQ,GACpB,MAAM,CASR;AAED,wBAAgB,kCAAkC,CAChD,mBAAmB,EAAE,MAAM,GAAG,IAAI,EAClC,eAAe,EAAE,MAAM,EACvB,eAAe,SAAI,GAClB,OAAO,CAIT;AAED,wBAAgB,gCAAgC,CAAC,EAC/C,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,GAChB,EAAE;IACD,mBAAmB,EAAE,OAAO,CAAA;IAC5B,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,eAAe,EAAE,MAAM,CAAA;CACxB,GAAG;IACF,iBAAiB,EAAE,OAAO,CAAA;IAC1B,uBAAuB,EAAE,OAAO,CAAA;CACjC,CAOA;AAED,wBAAgB,wCAAwC,CAAC,EACvD,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,aAAa,EACb,QAAY,EACZ,QAAY,GACb,EAAE;IACD,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,OAAO,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,GAAG;IACF,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;CAClB,CAYA;AAED,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC7B,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAwBR"}

package/dist/ui/floorplan/floorplan-label-angle.js

@@ -0,0 +1,60 @@
+export function resolveFloorplanLabelAngle(angleRadians, sceneRotationDeg, screenUpright = false) {
+    if (screenUpright)
+        return -sceneRotationDeg;
+    let localAngleDeg = (angleRadians * 180) / Math.PI;
+    let screenAngleDeg = localAngleDeg + sceneRotationDeg;
+    screenAngleDeg = ((((screenAngleDeg + 180) % 360) + 360) % 360) - 180;
+    if (screenAngleDeg > 90)
+        localAngleDeg -= 180;
+    else if (screenAngleDeg <= -90)
+        localAngleDeg += 180;
+    return ((((localAngleDeg + 180) % 360) + 360) % 360) - 180;
+}
+export function shouldUpdateFloorplanLabelRotation(previousRotationDeg, nextRotationDeg, minimumDeltaDeg = 1) {
+    if (previousRotationDeg === null)
+        return true;
+    const deltaDeg = ((((nextRotationDeg - previousRotationDeg + 180) % 360) + 360) % 360) - 180;
+    return Math.abs(deltaDeg) >= minimumDeltaDeg;
+}
+export function resolveFloorplanAnnotationUpdate({ layoutInputsChanged, previousRotationDeg, nextRotationDeg, }) {
+    return {
+        resolveCollisions: layoutInputsChanged,
+        updateLabelPresentation: layoutInputsChanged ||
+            shouldUpdateFloorplanLabelRotation(previousRotationDeg, nextRotationDeg),
+    };
+}
+export function resolveFloorplanAnnotationLabelTransform({ angleRadians, sceneRotationDeg, screenUpright, beforeRotation, afterRotation, layoutDx = 0, layoutDy = 0, }) {
+    const degrees = resolveFloorplanLabelAngle(angleRadians, sceneRotationDeg, screenUpright);
+    const defaultTransform = [beforeRotation, `rotate(${degrees})`, afterRotation]
+        .filter(Boolean)
+        .join(' ');
+    return {
+        defaultTransform,
+        transform: layoutDx === 0 && layoutDy === 0
+            ? defaultTransform
+            : `${defaultTransform} translate(${layoutDx} ${layoutDy})`,
+    };
+}
+export function updateSvgFloorplanLabelOrientations(labels, sceneRotationDeg) {
+    let updated = 0;
+    for (const label of labels) {
+        const angleRadians = Number(label.dataset.floorplanAnnotationAngleRadians);
+        if (!Number.isFinite(angleRadians))
+            continue;
+        const { defaultTransform, transform } = resolveFloorplanAnnotationLabelTransform({
+            angleRadians,
+            sceneRotationDeg,
+            screenUpright: label.dataset.floorplanAnnotationScreenUpright === 'true',
+            beforeRotation: label.dataset.floorplanAnnotationTransformBeforeRotation ?? '',
+            afterRotation: label.dataset.floorplanAnnotationTransformAfterRotation ?? '',
+            layoutDx: Number(label.dataset.floorplanAnnotationLayoutDx ?? 0),
+            layoutDy: Number(label.dataset.floorplanAnnotationLayoutDy ?? 0),
+        });
+        if (label.getAttribute('transform') === transform)
+            continue;
+        label.dataset.floorplanAnnotationDefaultTransform = defaultTransform;
+        label.setAttribute('transform', transform);
+        updated += 1;
+    }
+    return updated;
+}

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

@@ -0,0 +1,18 @@
+export declare function setFloorplanCompassRotation(compass: {
+    style: {
+        transform: string;
+    };
+} | null, rotationDeg: number): void;
+export type FloorplanNavigationSyncScheduler<Pose> = {
+    update: (pose: Pose) => void;
+    flush: () => void;
+    discard: () => void;
+};
+export declare function createFloorplanNavigationSyncScheduler<Pose>({ applyPresentation, commit, settleMs, schedule, cancel, }: {
+    applyPresentation: (pose: Pose) => void;
+    commit: (pose: Pose) => void;
+    settleMs?: number;
+    schedule?: (callback: () => void, delay: number) => ReturnType<typeof globalThis.setTimeout>;
+    cancel?: (timer: ReturnType<typeof globalThis.setTimeout>) => void;
+}): FloorplanNavigationSyncScheduler<Pose>;
+//# sourceMappingURL=floorplan-navigation-sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-navigation-sync.d.ts","sourceRoot":"","sources":["../../../src/ui/floorplan/floorplan-navigation-sync.ts"],"names":[],"mappings":"AAAA,wBAAgB,2BAA2B,CACzC,OAAO,EAAE;IAAE,KAAK,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAAG,IAAI,EAChD,WAAW,EAAE,MAAM,GAClB,IAAI,CAIN;AAED,MAAM,MAAM,gCAAgC,CAAC,IAAI,IAAI;IACnD,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IAC5B,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,CAAA;AAED,wBAAgB,sCAAsC,CAAC,IAAI,EAAE,EAC3D,iBAAiB,EACjB,MAAM,EACN,QAAc,EACd,QAAgC,EAChC,MAAgC,GACjC,EAAE;IACD,iBAAiB,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IACvC,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,UAAU,CAAC,UAAU,CAAC,CAAA;IAC5F,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;CACnE,GAAG,gCAAgC,CAAC,IAAI,CAAC,CAqCzC"}

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

@@ -0,0 +1,41 @@
+export function setFloorplanCompassRotation(compass, rotationDeg) {
+    if (compass) {
+        compass.style.transform = `rotate(${rotationDeg}deg)`;
+    }
+}
+export function createFloorplanNavigationSyncScheduler({ applyPresentation, commit, settleMs = 120, schedule = globalThis.setTimeout, cancel = globalThis.clearTimeout, }) {
+    let latestPose = null;
+    let settleTimer = null;
+    const clearSettleTimer = () => {
+        if (settleTimer === null)
+            return;
+        cancel(settleTimer);
+        settleTimer = null;
+    };
+    const flush = () => {
+        clearSettleTimer();
+        if (latestPose === null)
+            return;
+        const pose = latestPose;
+        latestPose = null;
+        commit(pose);
+    };
+    const update = (pose) => {
+        latestPose = pose;
+        applyPresentation(pose);
+        clearSettleTimer();
+        settleTimer = schedule(() => {
+            settleTimer = null;
+            if (latestPose === null)
+                return;
+            const settledPose = latestPose;
+            latestPose = null;
+            commit(settledPose);
+        }, settleMs);
+    };
+    const discard = () => {
+        clearSettleTimer();
+        latestPose = null;
+    };
+    return { update, flush, discard };
+}

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

@@ -0,0 +1,26 @@
+import type { FloorplanGeometry, FloorplanPoint } from '@pascal-app/core';
+export type FloorplanBounds = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export type FloorplanViewBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type FloorplanViewport = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export declare function clientToFloorplanPoint(viewBox: FloorplanViewBox, viewport: FloorplanViewport, clientX: number, clientY: number): FloorplanPoint;
+export declare function scaleFloorplanViewBox(viewBox: FloorplanViewBox, factor: number, anchorX?: number, anchorY?: number): FloorplanViewBox;
+export declare function scaleFloorplanViewBoxBetweenClients(viewBox: FloorplanViewBox, factor: number, viewport: FloorplanViewport, sourceClient: FloorplanPoint, targetClient: FloorplanPoint): FloorplanViewBox;
+export declare function panFloorplanViewBox(viewBox: FloorplanViewBox, viewport: FloorplanViewport, sourceClient: FloorplanPoint, targetClient: FloorplanPoint): FloorplanViewBox;
+export declare function getFloorplanBounds(geometries: readonly FloorplanGeometry[]): FloorplanBounds | null;
+export declare function padFloorplanBounds(bounds: FloorplanBounds, ratio?: number): FloorplanBounds;
+//# sourceMappingURL=floorplan-preview-geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-preview-geometry.d.ts","sourceRoot":"","sources":["../../../src/ui/floorplan/floorplan-preview-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEzE,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAwBD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,cAAc,CAGhB;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,MAAM,EACd,OAAO,SAAM,EACb,OAAO,SAAM,GACZ,gBAAgB,CAYlB;AAED,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,iBAAiB,EAC3B,YAAY,EAAE,cAAc,EAC5B,YAAY,EAAE,cAAc,GAC3B,gBAAgB,CAclB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,iBAAiB,EAC3B,YAAY,EAAE,cAAc,EAC5B,YAAY,EAAE,cAAc,GAC3B,gBAAgB,CAQlB;AA6JD,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,SAAS,iBAAiB,EAAE,GACvC,eAAe,GAAG,IAAI,CAKxB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,SAAO,GAAG,eAAe,CAUzF"}