@ubuilder-ai/workspace 0.1.0-alpha.1

package/README.md

@@ -0,0 +1,7 @@
+# `@ubuilder-ai/workspace`
+
+Shared read-only spatial workbench consumed by uBuilder-AI and its runtime adapters.
+
+It owns native Building 3D/2D/split composition, floorplan projection, navigation chrome, neutral workspace controls, divider behavior, and the hidden-but-mounted 3D runtime invariant.
+
+The package depends only on `@ubuilder-ai/core`, `@ubuilder-ai/floorplan-contract`, and React. It does not create a Canvas or import Viewer, Editor, Nodes, app code, or Three.js. Hosts inject their 3D surface and authoring behavior through explicit composition points. See `wiki/architecture/workspace.md`.

package/dist/floorplan-annotation-obstacles.d.ts

@@ -0,0 +1,4 @@
+import type { FloorplanGeometry } from '@ubuilder-ai/core';
+export declare function isFloorplanAnnotationObstacleGeometry(geometry: FloorplanGeometry): boolean;
+export declare function floorplanAnnotationObstacleMode(geometry: FloorplanGeometry): 'bounds' | 'outline' | '' | undefined;
+//# sourceMappingURL=floorplan-annotation-obstacles.d.ts.map

package/dist/floorplan-annotation-obstacles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-annotation-obstacles.d.ts","sourceRoot":"","sources":["../src/floorplan-annotation-obstacles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAG1D,wBAAgB,qCAAqC,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAQ1F;AAED,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,iBAAiB,GAC1B,QAAQ,GAAG,SAAS,GAAG,EAAE,GAAG,SAAS,CAavC"}

package/dist/floorplan-annotation-obstacles.js

@@ -0,0 +1,25 @@
+import { readFloorplanGeometryMetadata } from '@ubuilder-ai/floorplan-contract';
+export function isFloorplanAnnotationObstacleGeometry(geometry) {
+    if (floorplanAnnotationObstacleMode(geometry))
+        return true;
+    if (geometry.kind !== 'group')
+        return false;
+    const hasPlate = geometry.children.some((child) => child.kind === 'rect' || child.kind === 'circle');
+    const hasUprightText = geometry.children.some((child) => child.kind === 'text' && child.upright);
+    return hasPlate && hasUprightText;
+}
+export function floorplanAnnotationObstacleMode(geometry) {
+    const metadata = readFloorplanGeometryMetadata(geometry);
+    if (metadata.annotationObstacle)
+        return metadata.annotationObstacle;
+    switch (metadata.annotationRole) {
+        case 'room-label':
+            return geometry.kind === 'text' ? 'bounds' : undefined;
+        case 'column-center':
+            return geometry.kind === 'line' || geometry.kind === 'text' ? 'bounds' : undefined;
+        case 'stair-annotation':
+            return geometry.kind === 'polyline' || geometry.kind === 'line' ? 'outline' : 'bounds';
+        default:
+            return undefined;
+    }
+}

package/dist/floorplan-camera-sync.d.ts

@@ -0,0 +1,24 @@
+import type { CameraPose } from '@ubuilder-ai/core';
+import type { FloorplanNavigationPose, FloorplanNavigationPoseInput } from './floorplan-navigation-types';
+export declare function cameraPoseToFloorplanNavigationPose(pose: CameraPose): FloorplanNavigationPoseInput | null;
+export declare function floorplanNavigationPoseToCameraPose(navigationPose: FloorplanNavigationPose, cameraPose: CameraPose): CameraPose;
+export declare function floorplanNavigationPoseToInspectionCameraPose(navigationPose: FloorplanNavigationPose, cameraPose: CameraPose): CameraPose;
+export type FloorplanCameraSyncBridge = {
+    handoffTo3d: () => void;
+    receiveCameraPose: (pose: CameraPose) => void;
+    receiveNavigationPose: (pose: FloorplanNavigationPose | null) => void;
+    setActive: (active: boolean, options?: {
+        alignedAzimuth?: number;
+    }) => void;
+};
+export type FloorplanCameraNavigationChannel = {
+    publish: (pose: FloorplanNavigationPoseInput) => void;
+    subscribe: (listener: (pose: FloorplanNavigationPose) => void) => () => void;
+};
+export declare function createFloorplanCameraNavigationChannel(): FloorplanCameraNavigationChannel;
+export declare function createFloorplanCameraSyncBridge({ active: initialActive, applyCameraPose, publishNavigationPose, }: {
+    active?: boolean;
+    applyCameraPose: (pose: CameraPose) => void;
+    publishNavigationPose: (pose: FloorplanNavigationPoseInput) => void;
+}): FloorplanCameraSyncBridge;
+//# sourceMappingURL=floorplan-camera-sync.d.ts.map

package/dist/floorplan-camera-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-camera-sync.d.ts","sourceRoot":"","sources":["../src/floorplan-camera-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,KAAK,EACV,uBAAuB,EACvB,4BAA4B,EAC7B,MAAM,8BAA8B,CAAA;AAsCrC,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,UAAU,GACf,4BAA4B,GAAG,IAAI,CAWrC;AAED,wBAAgB,mCAAmC,CACjD,cAAc,EAAE,uBAAuB,EACvC,UAAU,EAAE,UAAU,GACrB,UAAU,CAgBZ;AAED,wBAAgB,6CAA6C,CAC3D,cAAc,EAAE,uBAAuB,EACvC,UAAU,EAAE,UAAU,GACrB,UAAU,CAoBZ;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,iBAAiB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAA;IAC7C,qBAAqB,EAAE,CAAC,IAAI,EAAE,uBAAuB,GAAG,IAAI,KAAK,IAAI,CAAA;IACrE,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CAC5E,CAAA;AAED,MAAM,MAAM,gCAAgC,GAAG;IAC7C,OAAO,EAAE,CAAC,IAAI,EAAE,4BAA4B,KAAK,IAAI,CAAA;IACrD,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,uBAAuB,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;CAC7E,CAAA;AAED,wBAAgB,sCAAsC,IAAI,gCAAgC,CAiBzF;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,MAAM,EAAE,aAAoB,EAC5B,eAAe,EACf,qBAAqB,GACtB,EAAE;IACD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,eAAe,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAA;IAC3C,qBAAqB,EAAE,CAAC,IAAI,EAAE,4BAA4B,KAAK,IAAI,CAAA;CACpE,GAAG,yBAAyB,CAqG5B"}

package/dist/floorplan-camera-sync.js

@@ -0,0 +1,187 @@
+const POSITION_EPSILON = 0.001;
+const AZIMUTH_EPSILON = 1e-4;
+const VIEW_WIDTH_EPSILON = 0.001;
+const FLOORPLAN_3D_HANDOFF_POLAR_ANGLE = Math.PI / 6;
+function angleDeltaRadians(a, b) {
+    return Math.atan2(Math.sin(a - b), Math.cos(a - b));
+}
+function normalizeNearZero(value) {
+    return Math.abs(value) < Number.EPSILON * 10 ? 0 : value;
+}
+function navigationSnapshot(pose) {
+    return {
+        target: [...pose.target],
+        azimuth: pose.azimuth,
+        viewWidth: pose.viewWidth,
+    };
+}
+function navigationSnapshotsEqual(previous, next) {
+    return (Math.abs(previous.target[0] - next.target[0]) < POSITION_EPSILON &&
+        Math.abs(previous.target[1] - next.target[1]) < POSITION_EPSILON &&
+        Math.abs(previous.target[2] - next.target[2]) < POSITION_EPSILON &&
+        Math.abs(angleDeltaRadians(previous.azimuth, next.azimuth)) < AZIMUTH_EPSILON &&
+        Math.abs(previous.viewWidth - next.viewWidth) < VIEW_WIDTH_EPSILON);
+}
+export function cameraPoseToFloorplanNavigationPose(pose) {
+    if (!(pose.viewWidth !== undefined && Number.isFinite(pose.viewWidth) && pose.viewWidth > 0)) {
+        return null;
+    }
+    return {
+        source: '3d',
+        target: [...pose.target],
+        azimuth: Math.atan2(pose.position[0] - pose.target[0], pose.position[2] - pose.target[2]),
+        viewWidth: pose.viewWidth,
+    };
+}
+export function floorplanNavigationPoseToCameraPose(navigationPose, cameraPose) {
+    const offsetX = cameraPose.position[0] - cameraPose.target[0];
+    const offsetY = cameraPose.position[1] - cameraPose.target[1];
+    const offsetZ = cameraPose.position[2] - cameraPose.target[2];
+    const horizontalDistance = Math.hypot(offsetX, offsetZ);
+    const horizontalX = normalizeNearZero(Math.sin(navigationPose.azimuth) * horizontalDistance);
+    const horizontalZ = normalizeNearZero(Math.cos(navigationPose.azimuth) * horizontalDistance);
+    const target = [...navigationPose.target];
+    return {
+        ...(cameraPose.fov === undefined ? {} : { fov: cameraPose.fov }),
+        position: [target[0] + horizontalX, target[1] + offsetY, target[2] + horizontalZ],
+        projection: cameraPose.projection,
+        target,
+        viewWidth: navigationPose.viewWidth,
+    };
+}
+export function floorplanNavigationPoseToInspectionCameraPose(navigationPose, cameraPose) {
+    const offsetX = cameraPose.position[0] - cameraPose.target[0];
+    const offsetY = cameraPose.position[1] - cameraPose.target[1];
+    const offsetZ = cameraPose.position[2] - cameraPose.target[2];
+    const distance = Math.max(0.001, Math.hypot(offsetX, offsetY, offsetZ));
+    const horizontalDistance = Math.sin(FLOORPLAN_3D_HANDOFF_POLAR_ANGLE) * distance;
+    const verticalDistance = Math.cos(FLOORPLAN_3D_HANDOFF_POLAR_ANGLE) * distance;
+    const target = [...navigationPose.target];
+    return {
+        ...(cameraPose.fov === undefined ? {} : { fov: cameraPose.fov }),
+        position: [
+            target[0] + Math.sin(navigationPose.azimuth) * horizontalDistance,
+            target[1] + verticalDistance,
+            target[2] + Math.cos(navigationPose.azimuth) * horizontalDistance,
+        ],
+        projection: cameraPose.projection,
+        target,
+        viewWidth: navigationPose.viewWidth,
+    };
+}
+export function createFloorplanCameraNavigationChannel() {
+    const listeners = new Set();
+    let revision = 0;
+    return {
+        publish: (pose) => {
+            revision += 1;
+            const revisedPose = { ...pose, revision };
+            for (const listener of listeners) {
+                listener(revisedPose);
+            }
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+export function createFloorplanCameraSyncBridge({ active: initialActive = true, applyCameraPose, publishNavigationPose, }) {
+    let active = initialActive;
+    let latestCameraPose = null;
+    let latestFloorplanNavigationPose = null;
+    let pendingNavigationPose = null;
+    let lastAppliedNavigationRevision = 0;
+    let lastPublishedNavigation = null;
+    let applyInactiveFloorplanNavigation = false;
+    let activeAlignedAzimuth = null;
+    let alignedFloorplanRevision = 0;
+    const applyPendingNavigationPose = (force = false) => {
+        if (!(latestCameraPose && pendingNavigationPose))
+            return false;
+        if (!force && pendingNavigationPose.revision === lastAppliedNavigationRevision) {
+            pendingNavigationPose = null;
+            return false;
+        }
+        const appliedPose = applyInactiveFloorplanNavigation
+            ? floorplanNavigationPoseToInspectionCameraPose(pendingNavigationPose, latestCameraPose)
+            : floorplanNavigationPoseToCameraPose(pendingNavigationPose, latestCameraPose);
+        const appliedNavigationPose = cameraPoseToFloorplanNavigationPose(appliedPose);
+        latestCameraPose = appliedPose;
+        lastAppliedNavigationRevision = pendingNavigationPose.revision;
+        pendingNavigationPose = null;
+        if (appliedNavigationPose) {
+            lastPublishedNavigation = navigationSnapshot(appliedNavigationPose);
+        }
+        applyCameraPose(appliedPose);
+        return true;
+    };
+    const publishCameraNavigationPose = (pose, alignedAzimuth) => {
+        const navigationPose = cameraPoseToFloorplanNavigationPose(pose);
+        if (!navigationPose)
+            return;
+        if (alignedAzimuth !== undefined)
+            navigationPose.azimuth = alignedAzimuth;
+        const nextSnapshot = navigationSnapshot(navigationPose);
+        if (lastPublishedNavigation &&
+            navigationSnapshotsEqual(lastPublishedNavigation, nextSnapshot)) {
+            return;
+        }
+        lastPublishedNavigation = nextSnapshot;
+        publishNavigationPose(navigationPose);
+    };
+    return {
+        handoffTo3d: () => {
+            applyInactiveFloorplanNavigation = true;
+            if (!latestFloorplanNavigationPose)
+                return;
+            pendingNavigationPose = latestFloorplanNavigationPose;
+            applyPendingNavigationPose(true);
+        },
+        receiveCameraPose: (pose) => {
+            latestCameraPose = pose;
+            if ((active || applyInactiveFloorplanNavigation) && applyPendingNavigationPose())
+                return;
+            if (!active)
+                applyInactiveFloorplanNavigation = false;
+            publishCameraNavigationPose(pose, activeAlignedAzimuth ?? undefined);
+        },
+        receiveNavigationPose: (pose) => {
+            if (pose?.source === '2d') {
+                latestFloorplanNavigationPose = pose;
+                if (pose.revision > alignedFloorplanRevision) {
+                    activeAlignedAzimuth = null;
+                }
+            }
+            if ((!active && !applyInactiveFloorplanNavigation) ||
+                pose?.source !== '2d' ||
+                pose.revision === lastAppliedNavigationRevision ||
+                pose.revision === pendingNavigationPose?.revision) {
+                return;
+            }
+            pendingNavigationPose = pose;
+            applyPendingNavigationPose();
+        },
+        setActive: (nextActive, options) => {
+            const alignedAzimuth = options?.alignedAzimuth;
+            if (active === nextActive && alignedAzimuth === undefined)
+                return;
+            active = nextActive;
+            if (active) {
+                applyInactiveFloorplanNavigation = false;
+                activeAlignedAzimuth = alignedAzimuth ?? null;
+                alignedFloorplanRevision = latestFloorplanNavigationPose?.revision ?? 0;
+            }
+            if (!active) {
+                activeAlignedAzimuth = null;
+                alignedFloorplanRevision = 0;
+                if (!applyInactiveFloorplanNavigation)
+                    pendingNavigationPose = null;
+                return;
+            }
+            if (latestCameraPose) {
+                publishCameraNavigationPose(latestCameraPose, alignedAzimuth);
+            }
+        },
+    };
+}

package/dist/floorplan-coordinates.d.ts

@@ -0,0 +1,10 @@
+export type FloorplanPoint = {
+    x: number;
+    y: number;
+};
+export declare function worldToFloorplanLocalPoint(worldX: number, worldZ: number, buildingPosition: readonly [number, number, number], buildingRotationY: number): FloorplanPoint;
+export declare function floorplanLocalToWorldPoint(point: FloorplanPoint | readonly [number, number], buildingPosition: readonly [number, number, number], buildingRotationY: number): {
+    x: number;
+    z: number;
+};
+//# sourceMappingURL=floorplan-coordinates.d.ts.map

package/dist/floorplan-coordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-coordinates.d.ts","sourceRoot":"","sources":["../src/floorplan-coordinates.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAAA;AAMD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACnD,iBAAiB,EAAE,MAAM,GACxB,cAAc,CAUhB;AAGD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,cAAc,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACjD,gBAAgB,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACnD,iBAAiB,EAAE,MAAM,GACxB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAU1B"}

package/dist/floorplan-coordinates.js

@@ -0,0 +1,25 @@
+// Converts a world X/Z point into the floor-plan-local (building-local)
+// frame used by the SVG scene `<g>` and every stored node position. The
+// inverse of `floorplanLocalToWorldPoint`. Shared so every Floorplan surface
+// resolves the same frame instead of feeding world coordinates to local math.
+export function worldToFloorplanLocalPoint(worldX, worldZ, buildingPosition, buildingRotationY) {
+    const dx = worldX - buildingPosition[0];
+    const dz = worldZ - buildingPosition[2];
+    const cos = Math.cos(buildingRotationY);
+    const sin = Math.sin(buildingRotationY);
+    return {
+        x: dx * cos - dz * sin,
+        y: dx * sin + dz * cos,
+    };
+}
+// Inverse of `worldToFloorplanLocalPoint`: floor-plan-local X/Y to world X/Z.
+export function floorplanLocalToWorldPoint(point, buildingPosition, buildingRotationY) {
+    const localX = 'x' in point ? point.x : point[0];
+    const localY = 'y' in point ? point.y : point[1];
+    const cos = Math.cos(buildingRotationY);
+    const sin = Math.sin(buildingRotationY);
+    return {
+        x: buildingPosition[0] + localX * cos + localY * sin,
+        z: buildingPosition[2] - localX * sin + localY * cos,
+    };
+}

package/dist/floorplan-dimension-renderer.d.ts

@@ -0,0 +1,42 @@
+import type { FloorplanGeometry, FloorplanPoint } from '@ubuilder-ai/core';
+type FloorplanDimensionRenderMode = 'screen' | 'pdf';
+type DimensionGeometry = Extract<FloorplanGeometry, {
+    kind: 'dimension';
+}>;
+type DimensionStringGeometry = Extract<FloorplanGeometry, {
+    kind: 'dimension-string';
+}>;
+export type ArchitecturalDimensionLayout = {
+    dimensionStart: FloorplanPoint;
+    dimensionEnd: FloorplanPoint;
+    dimensionLineStart: FloorplanPoint;
+    dimensionLineEnd: FloorplanPoint;
+    extensionStart: FloorplanPoint;
+    extensionEnd: FloorplanPoint;
+    extensionStartTip: FloorplanPoint;
+    extensionEndTip: FloorplanPoint;
+    tickHalfVector: FloorplanPoint;
+    labelPoint: FloorplanPoint;
+    labelAngleDeg: number;
+    labelPlacement: 'inside' | 'outside-end';
+    outsideStartLabelPoint?: FloorplanPoint;
+    outsideStartDimensionLineStart?: FloorplanPoint;
+};
+export declare function floorplanDimensionAnnotationPriority(offsetDistance: number): number;
+export declare function computeArchitecturalDimensionLayout(geometry: DimensionGeometry, sceneRotationDeg: number, annotationUnitsPerPoint?: number): ArchitecturalDimensionLayout | null;
+export declare function FloorplanDimensionRenderer({ geometry, sceneRotationDeg, stroke, annotationUnitsPerPoint, renderMode, }: {
+    geometry: DimensionGeometry;
+    sceneRotationDeg?: number;
+    stroke?: string;
+    annotationUnitsPerPoint?: number;
+    renderMode?: FloorplanDimensionRenderMode;
+}): React.ReactElement | null;
+export declare function FloorplanDimensionStringRenderer({ geometry, sceneRotationDeg, stroke, annotationUnitsPerPoint, renderMode, }: {
+    geometry: DimensionStringGeometry;
+    sceneRotationDeg?: number;
+    stroke?: string;
+    annotationUnitsPerPoint?: number;
+    renderMode?: FloorplanDimensionRenderMode;
+}): React.ReactElement | null;
+export {};
+//# sourceMappingURL=floorplan-dimension-renderer.d.ts.map

package/dist/floorplan-dimension-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-dimension-renderer.d.ts","sourceRoot":"","sources":["../src/floorplan-dimension-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAqB1E,KAAK,4BAA4B,GAAG,QAAQ,GAAG,KAAK,CAAA;AAEpD,KAAK,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAAA;AAC1E,KAAK,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,CAAC,CAAA;AAGvF,MAAM,MAAM,4BAA4B,GAAG;IACzC,cAAc,EAAE,cAAc,CAAA;IAC9B,YAAY,EAAE,cAAc,CAAA;IAC5B,kBAAkB,EAAE,cAAc,CAAA;IAClC,gBAAgB,EAAE,cAAc,CAAA;IAChC,cAAc,EAAE,cAAc,CAAA;IAC9B,YAAY,EAAE,cAAc,CAAA;IAC5B,iBAAiB,EAAE,cAAc,CAAA;IACjC,eAAe,EAAE,cAAc,CAAA;IAC/B,cAAc,EAAE,cAAc,CAAA;IAC9B,UAAU,EAAE,cAAc,CAAA;IAC1B,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,QAAQ,GAAG,aAAa,CAAA;IACxC,sBAAsB,CAAC,EAAE,cAAc,CAAA;IACvC,8BAA8B,CAAC,EAAE,cAAc,CAAA;CAChD,CAAA;AAED,wBAAgB,oCAAoC,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,iBAAiB,EAC3B,gBAAgB,EAAE,MAAM,EACxB,uBAAuB,CAAC,EAAE,MAAM,GAC/B,4BAA4B,GAAG,IAAI,CAuFrC;AAkBD,wBAAgB,0BAA0B,CAAC,EACzC,QAAQ,EACR,gBAAoB,EACpB,MAAqC,EACrC,uBAAuB,EACvB,UAAqB,GACtB,EAAE;IACD,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,UAAU,CAAC,EAAE,4BAA4B,CAAA;CAC1C,GAAG,KAAK,CAAC,YAAY,GAAG,IAAI,CAyH5B;AAED,wBAAgB,gCAAgC,CAAC,EAC/C,QAAQ,EACR,gBAAoB,EACpB,MAAqC,EACrC,uBAAuB,EACvB,UAAqB,GACtB,EAAE;IACD,QAAQ,EAAE,uBAAuB,CAAA;IACjC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,UAAU,CAAC,EAAE,4BAA4B,CAAA;CAC1C,GAAG,KAAK,CAAC,YAAY,GAAG,IAAI,CAoK5B"}

package/dist/floorplan-dimension-renderer.js

@@ -0,0 +1,245 @@
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { resolveFloorplanLabelAngle } from './floorplan-label-angle';
+const EXTENSION_START_GAP = 0.075;
+const TICK_HALF_LENGTH = 0.09;
+const LABEL_FONT_SIZE = 0.15;
+const LABEL_BASELINE_OFFSET = 0.12;
+const LABEL_CHARACTER_WIDTH_RATIO = 0.62;
+const LABEL_END_GAP = 0.075;
+const DOCUMENT_EXTENSION_START_GAP_PT = 3;
+const DOCUMENT_EXTENSION_OVERSHOOT_PT = 4;
+const DOCUMENT_TICK_HALF_LENGTH_PT = 4.5;
+const DOCUMENT_LABEL_FONT_SIZE_PT = 8;
+const DOCUMENT_LABEL_BASELINE_OFFSET_PT = 5;
+const DOCUMENT_LABEL_END_GAP_PT = 3;
+const LINE_STROKE_WIDTH_PX = 0.9;
+const TICK_STROKE_WIDTH_PX = 1.35;
+const PDF_LINE_STROKE_WIDTH_PT = 0.5;
+const PDF_TICK_STROKE_WIDTH_PT = 0.75;
+const SQRT_ONE_HALF = Math.SQRT1_2;
+export function floorplanDimensionAnnotationPriority(offsetDistance) {
+    return 100 + Math.round(Math.abs(offsetDistance) * 100);
+}
+export function computeArchitecturalDimensionLayout(geometry, sceneRotationDeg, annotationUnitsPerPoint) {
+    const extensionStartGap = annotationUnitsPerPoint
+        ? DOCUMENT_EXTENSION_START_GAP_PT * annotationUnitsPerPoint
+        : (geometry.extensionStartGap ?? EXTENSION_START_GAP);
+    const extensionOvershoot = annotationUnitsPerPoint
+        ? DOCUMENT_EXTENSION_OVERSHOOT_PT * annotationUnitsPerPoint
+        : geometry.extensionOvershoot;
+    const tickHalfLength = annotationUnitsPerPoint
+        ? DOCUMENT_TICK_HALF_LENGTH_PT * annotationUnitsPerPoint
+        : TICK_HALF_LENGTH;
+    const labelFontSize = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
+        : LABEL_FONT_SIZE;
+    const labelEndGap = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_END_GAP_PT * annotationUnitsPerPoint
+        : LABEL_END_GAP;
+    const offsetX = geometry.offsetNormal[0] * geometry.offsetDistance;
+    const offsetY = geometry.offsetNormal[1] * geometry.offsetDistance;
+    const dimensionStart = geometry.dimensionStart ?? [
+        geometry.start[0] + offsetX,
+        geometry.start[1] + offsetY,
+    ];
+    const dimensionEnd = geometry.dimensionEnd ?? [
+        geometry.end[0] + offsetX,
+        geometry.end[1] + offsetY,
+    ];
+    const dx = dimensionEnd[0] - dimensionStart[0];
+    const dy = dimensionEnd[1] - dimensionStart[1];
+    const length = Math.hypot(dx, dy);
+    if (length < 1e-6)
+        return null;
+    const dirX = dx / length;
+    const dirY = dy / length;
+    const startOffsetDistance = dot(subtract(dimensionStart, geometry.start), geometry.offsetNormal);
+    const endOffsetDistance = dot(subtract(dimensionEnd, geometry.end), geometry.offsetNormal);
+    const startExtensionGap = Math.min(extensionStartGap, Math.max(0, startOffsetDistance - 0.01));
+    const endExtensionGap = Math.min(extensionStartGap, Math.max(0, endOffsetDistance - 0.01));
+    // A 45-degree architectural slash. Every terminator within one string uses
+    // this same vector instead of rotating independently around its endpoint.
+    const tickHalfVector = [
+        (dirX + dirY) * tickHalfLength * SQRT_ONE_HALF,
+        (dirY - dirX) * tickHalfLength * SQRT_ONE_HALF,
+    ];
+    const labelWidth = Math.max(labelFontSize, geometry.text.length * labelFontSize * LABEL_CHARACTER_WIDTH_RATIO);
+    const labelPlacement = length >= labelWidth + labelEndGap * 2 ? 'inside' : 'outside-end';
+    const direction = [dirX, dirY];
+    const labelPoint = labelPlacement === 'inside'
+        ? [
+            (dimensionStart[0] + dimensionEnd[0]) / 2,
+            (dimensionStart[1] + dimensionEnd[1]) / 2,
+        ]
+        : addScaled(dimensionEnd, direction, labelEndGap + labelWidth / 2);
+    const dimensionLineEnd = labelPlacement === 'inside'
+        ? dimensionEnd
+        : addScaled(dimensionEnd, direction, labelEndGap * 2 + labelWidth);
+    const outsideStartLabelPoint = labelPlacement === 'outside-end'
+        ? addScaled(dimensionStart, direction, -(labelEndGap + labelWidth / 2))
+        : undefined;
+    const outsideStartDimensionLineStart = labelPlacement === 'outside-end'
+        ? addScaled(dimensionStart, direction, -(labelEndGap * 2 + labelWidth))
+        : undefined;
+    return {
+        dimensionStart,
+        dimensionEnd,
+        dimensionLineStart: dimensionStart,
+        dimensionLineEnd,
+        extensionStart: addScaled(geometry.start, geometry.offsetNormal, startExtensionGap),
+        extensionEnd: addScaled(geometry.end, geometry.offsetNormal, endExtensionGap),
+        extensionStartTip: addScaled(dimensionStart, geometry.offsetNormal, extensionOvershoot),
+        extensionEndTip: addScaled(dimensionEnd, geometry.offsetNormal, extensionOvershoot),
+        tickHalfVector,
+        labelPoint,
+        labelAngleDeg: resolveFloorplanLabelAngle(Math.atan2(dy, dx), sceneRotationDeg),
+        labelPlacement,
+        outsideStartLabelPoint,
+        outsideStartDimensionLineStart,
+    };
+}
+function subtract(left, right) {
+    return [left[0] - right[0], left[1] - right[1]];
+}
+function dot(left, right) {
+    return left[0] * right[0] + left[1] * right[1];
+}
+function addScaled(point, direction, distance) {
+    return [point[0] + direction[0] * distance, point[1] + direction[1] * distance];
+}
+export function FloorplanDimensionRenderer({ geometry, sceneRotationDeg = 0, stroke = geometry.stroke ?? '#334155', annotationUnitsPerPoint, renderMode = 'screen', }) {
+    const layout = computeArchitecturalDimensionLayout(geometry, sceneRotationDeg, annotationUnitsPerPoint);
+    if (!layout)
+        return null;
+    const labelFontSize = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
+        : LABEL_FONT_SIZE;
+    const labelBaselineOffset = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_BASELINE_OFFSET_PT * annotationUnitsPerPoint
+        : LABEL_BASELINE_OFFSET;
+    const labelY = geometry.textPosition === 'centered' ? labelFontSize * 0.35 : -labelBaselineOffset;
+    const lineProps = {
+        stroke,
+        strokeLinecap: 'butt',
+        strokeWidth: renderMode === 'pdf' ? PDF_LINE_STROKE_WIDTH_PT : LINE_STROKE_WIDTH_PX,
+        vectorEffect: 'non-scaling-stroke',
+    };
+    const tickStrokeWidth = renderMode === 'pdf' ? PDF_TICK_STROKE_WIDTH_PT : TICK_STROKE_WIDTH_PX;
+    const terminator = geometry.terminator ?? 'architectural-tick';
+    const labelTransform = `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]}) rotate(${layout.labelAngleDeg})`;
+    const outsideStartLocalShift = layout.outsideStartLabelPoint
+        ? rotateVector(subtract(layout.outsideStartLabelPoint, layout.labelPoint), (-layout.labelAngleDeg * Math.PI) / 180)
+        : undefined;
+    return (_jsxs("g", { "data-floorplan-dimension": "", pointerEvents: "none", children: [_jsx("line", { ...lineProps, x1: layout.extensionStart[0], x2: layout.extensionStartTip[0], y1: layout.extensionStart[1], y2: layout.extensionStartTip[1] }), _jsx("line", { ...lineProps, x1: layout.extensionEnd[0], x2: layout.extensionEndTip[0], y1: layout.extensionEnd[1], y2: layout.extensionEndTip[1] }), _jsx("line", { ...lineProps, "data-floorplan-dimension-default-x1": layout.dimensionLineStart[0], "data-floorplan-dimension-default-x2": layout.dimensionLineEnd[0], "data-floorplan-dimension-default-y1": layout.dimensionLineStart[1], "data-floorplan-dimension-default-y2": layout.dimensionLineEnd[1], "data-floorplan-dimension-line": "", "data-floorplan-dimension-outside-start-x1": layout.outsideStartDimensionLineStart?.[0], "data-floorplan-dimension-outside-start-x2": layout.dimensionEnd[0], "data-floorplan-dimension-outside-start-y1": layout.outsideStartDimensionLineStart?.[1], "data-floorplan-dimension-outside-start-y2": layout.dimensionEnd[1], x1: layout.dimensionLineStart[0], x2: layout.dimensionLineEnd[0], y1: layout.dimensionLineStart[1], y2: layout.dimensionLineEnd[1] }), renderTerminator(terminator, layout.dimensionStart, layout.dimensionEnd, layout, lineProps, tickStrokeWidth), renderTerminator(terminator, layout.dimensionEnd, layout.dimensionStart, layout, lineProps, tickStrokeWidth), layout.labelPlacement === 'outside-end' && annotationUnitsPerPoint !== undefined ? (_jsx("line", { ...lineProps, "data-floorplan-dimension-leader": "", visibility: "hidden", x1: layout.dimensionEnd[0], x2: layout.labelPoint[0], y1: layout.dimensionEnd[1], y2: layout.labelPoint[1] })) : null, _jsx("g", { "data-floorplan-annotation-angle-radians": Math.atan2(geometry.end[1] - geometry.start[1], geometry.end[0] - geometry.start[0]), "data-floorplan-annotation-default-transform": labelTransform, "data-floorplan-annotation-label": "", "data-floorplan-annotation-priority": floorplanDimensionAnnotationPriority(geometry.offsetDistance), "data-floorplan-annotation-transform-before-rotation": `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]})`, "data-floorplan-dimension-label-placement": layout.labelPlacement, "data-floorplan-dimension-outside-start-local-x": outsideStartLocalShift?.[0], "data-floorplan-dimension-outside-start-local-y": outsideStartLocalShift?.[1], "data-floorplan-dimension-start-x": layout.dimensionStart[0], "data-floorplan-dimension-start-y": layout.dimensionStart[1], "data-floorplan-dimension-end-x": layout.dimensionEnd[0], "data-floorplan-dimension-end-y": layout.dimensionEnd[1], transform: labelTransform, children: _jsx(DimensionLabel, { fontSize: labelFontSize, renderMode: renderMode, stroke: stroke, text: geometry.text, y: labelY }) })] }));
+}
+export function FloorplanDimensionStringRenderer({ geometry, sceneRotationDeg = 0, stroke = geometry.stroke ?? '#334155', annotationUnitsPerPoint, renderMode = 'screen', }) {
+    const segmentLayouts = geometry.segments.flatMap((segment, index) => {
+        const segmentGeometry = {
+            kind: 'dimension',
+            start: segment.start,
+            end: segment.end,
+            dimensionStart: segment.dimensionStart,
+            dimensionEnd: segment.dimensionEnd,
+            offsetNormal: geometry.offsetNormal,
+            offsetDistance: geometry.offsetDistance,
+            extensionOvershoot: geometry.extensionOvershoot,
+            extensionStartGap: geometry.extensionStartGap,
+            terminator: geometry.terminator,
+            textPosition: geometry.textPosition,
+            text: segment.text,
+            stroke: geometry.stroke,
+        };
+        const layout = computeArchitecturalDimensionLayout(segmentGeometry, sceneRotationDeg, annotationUnitsPerPoint);
+        return layout ? [{ index, layout, segment: segmentGeometry }] : [];
+    });
+    if (segmentLayouts.length === 0)
+        return null;
+    const labelFontSize = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
+        : LABEL_FONT_SIZE;
+    const labelBaselineOffset = annotationUnitsPerPoint
+        ? DOCUMENT_LABEL_BASELINE_OFFSET_PT * annotationUnitsPerPoint
+        : LABEL_BASELINE_OFFSET;
+    const labelY = geometry.textPosition === 'centered' ? labelFontSize * 0.35 : -labelBaselineOffset;
+    const lineProps = {
+        stroke,
+        strokeLinecap: 'butt',
+        strokeWidth: renderMode === 'pdf' ? PDF_LINE_STROKE_WIDTH_PT : LINE_STROKE_WIDTH_PX,
+        vectorEffect: 'non-scaling-stroke',
+    };
+    const tickStrokeWidth = renderMode === 'pdf' ? PDF_TICK_STROKE_WIDTH_PT : TICK_STROKE_WIDTH_PX;
+    const extensionLines = new Map();
+    const ticks = new Map();
+    for (const { layout } of segmentLayouts) {
+        extensionLines.set(pointKey(layout.dimensionStart), {
+            start: layout.extensionStart,
+            tip: layout.extensionStartTip,
+        });
+        extensionLines.set(pointKey(layout.dimensionEnd), {
+            start: layout.extensionEnd,
+            tip: layout.extensionEndTip,
+        });
+        ticks.set(pointKey(layout.dimensionStart), {
+            point: layout.dimensionStart,
+            toward: layout.dimensionEnd,
+            tickHalfVector: layout.tickHalfVector,
+        });
+        ticks.set(pointKey(layout.dimensionEnd), {
+            point: layout.dimensionEnd,
+            toward: layout.dimensionStart,
+            tickHalfVector: layout.tickHalfVector,
+        });
+    }
+    const terminator = geometry.terminator ?? 'architectural-tick';
+    return (_jsxs("g", { "data-floorplan-dimension-string": "", pointerEvents: "none", children: [[...extensionLines.values()].map((line, index) => (_createElement("line", { ...lineProps, key: `extension-${index}`, x1: line.start[0], x2: line.tip[0], y1: line.start[1], y2: line.tip[1] }))), segmentLayouts.map(({ index, layout }) => (_createElement("line", { ...lineProps, "data-floorplan-dimension-default-x1": layout.dimensionLineStart[0], "data-floorplan-dimension-default-x2": layout.dimensionLineEnd[0], "data-floorplan-dimension-default-y1": layout.dimensionLineStart[1], "data-floorplan-dimension-default-y2": layout.dimensionLineEnd[1], "data-floorplan-dimension-line": "", "data-floorplan-dimension-outside-start-x1": layout.outsideStartDimensionLineStart?.[0], "data-floorplan-dimension-outside-start-x2": layout.dimensionEnd[0], "data-floorplan-dimension-outside-start-y1": layout.outsideStartDimensionLineStart?.[1], "data-floorplan-dimension-outside-start-y2": layout.dimensionEnd[1], key: `dimension-line-${index}`, x1: layout.dimensionLineStart[0], x2: layout.dimensionLineEnd[0], y1: layout.dimensionLineStart[1], y2: layout.dimensionLineEnd[1] }))), [...ticks.values()].map(({ point, toward, tickHalfVector }, index) => renderTerminator(terminator, point, toward, { tickHalfVector }, lineProps, tickStrokeWidth, `tick-${index}`)), segmentLayouts.map(({ index, layout, segment }) => {
+                const labelTransform = `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]}) rotate(${layout.labelAngleDeg})`;
+                const outsideStartLocalShift = layout.outsideStartLabelPoint
+                    ? rotateVector(subtract(layout.outsideStartLabelPoint, layout.labelPoint), (-layout.labelAngleDeg * Math.PI) / 180)
+                    : undefined;
+                return (_jsxs("g", { children: [layout.labelPlacement === 'outside-end' && annotationUnitsPerPoint !== undefined ? (_jsx("line", { ...lineProps, "data-floorplan-dimension-leader": "", visibility: "hidden", x1: layout.dimensionEnd[0], x2: layout.labelPoint[0], y1: layout.dimensionEnd[1], y2: layout.labelPoint[1] })) : null, _jsx("g", { "data-floorplan-annotation-angle-radians": Math.atan2(segment.end[1] - segment.start[1], segment.end[0] - segment.start[0]), "data-floorplan-annotation-default-transform": labelTransform, "data-floorplan-annotation-label": "", "data-floorplan-annotation-priority": floorplanDimensionAnnotationPriority(geometry.offsetDistance), "data-floorplan-annotation-transform-before-rotation": `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]})`, "data-floorplan-dimension-label-placement": layout.labelPlacement, "data-floorplan-dimension-outside-start-local-x": outsideStartLocalShift?.[0], "data-floorplan-dimension-outside-start-local-y": outsideStartLocalShift?.[1], "data-floorplan-dimension-start-x": layout.dimensionStart[0], "data-floorplan-dimension-start-y": layout.dimensionStart[1], "data-floorplan-dimension-end-x": layout.dimensionEnd[0], "data-floorplan-dimension-end-y": layout.dimensionEnd[1], transform: labelTransform, children: _jsx(DimensionLabel, { fontSize: labelFontSize, renderMode: renderMode, stroke: stroke, text: segment.text, y: labelY }) })] }, `label-${index}`));
+            })] }));
+}
+function rotateVector(vector, radians) {
+    const cosine = Math.cos(radians);
+    const sine = Math.sin(radians);
+    return [vector[0] * cosine - vector[1] * sine, vector[0] * sine + vector[1] * cosine];
+}
+function DimensionLabel({ text, y, fontSize, stroke, renderMode, }) {
+    const width = Math.max(fontSize, text.length * fontSize * LABEL_CHARACTER_WIDTH_RATIO);
+    const plateWidth = width + fontSize * 0.5;
+    const plateHeight = fontSize * 1.2;
+    const plateY = y - fontSize * 0.82;
+    return (_jsxs(_Fragment, { children: [renderMode === 'pdf' ? (_jsx("rect", { "data-floorplan-dimension-label-plate": "", fill: "#ffffff", height: plateHeight, rx: fontSize * 0.12, ry: fontSize * 0.12, width: plateWidth, x: -plateWidth / 2, y: plateY })) : null, _jsx("text", { fill: stroke, fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace", fontSize: fontSize, fontWeight: 500, paintOrder: renderMode === 'pdf' ? undefined : 'stroke', stroke: renderMode === 'pdf' ? undefined : '#ffffff', strokeLinejoin: renderMode === 'pdf' ? undefined : 'round', strokeWidth: renderMode === 'pdf' ? undefined : 3, textAnchor: "middle", vectorEffect: renderMode === 'pdf' ? undefined : 'non-scaling-stroke', x: 0, y: y, children: text })] }));
+}
+function renderTerminator(terminator, point, toward, layout, lineProps, tickStrokeWidth, key) {
+    const direction = normalized(point, toward);
+    if (!direction)
+        return null;
+    const tickHalfLength = Math.hypot(layout.tickHalfVector[0], layout.tickHalfVector[1]);
+    if (terminator === 'dot') {
+        return (_jsx("circle", { fill: lineProps.stroke, r: tickHalfLength * 0.45, vectorEffect: "non-scaling-stroke", cx: point[0], cy: point[1] }, key));
+    }
+    if (terminator === 'filled-arrow' || terminator === 'open-arrow') {
+        const base = addScaled(point, direction, tickHalfLength * 1.7);
+        const normal = [-direction[1], direction[0]];
+        const wing = tickHalfLength * 0.65;
+        const left = [base[0] + normal[0] * wing, base[1] + normal[1] * wing];
+        const right = [base[0] - normal[0] * wing, base[1] - normal[1] * wing];
+        if (terminator === 'filled-arrow') {
+            return (_jsx("polygon", { fill: lineProps.stroke, points: `${point[0]},${point[1]} ${left[0]},${left[1]} ${right[0]},${right[1]}`, vectorEffect: "non-scaling-stroke" }, key));
+        }
+        return (_jsxs("g", { children: [_jsx("line", { ...lineProps, strokeWidth: tickStrokeWidth, x1: point[0], x2: left[0], y1: point[1], y2: left[1] }), _jsx("line", { ...lineProps, strokeWidth: tickStrokeWidth, x1: point[0], x2: right[0], y1: point[1], y2: right[1] })] }, key));
+    }
+    const [tickX, tickY] = layout.tickHalfVector;
+    return (_createElement("line", { ...lineProps, key: key, strokeWidth: tickStrokeWidth, x1: point[0] - tickX, x2: point[0] + tickX, y1: point[1] - tickY, y2: point[1] + tickY }));
+}
+function normalized(start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const magnitude = Math.hypot(dx, dy);
+    return magnitude <= 1e-6 ? null : [dx / magnitude, dy / magnitude];
+}
+function pointKey(point) {
+    return `${point[0].toFixed(6)},${point[1].toFixed(6)}`;
+}