@ubuilder-ai/workspace 0.0.1

package/dist/floorplan-navigation-types.d.ts

@@ -0,0 +1,10 @@
+export type FloorplanNavigationSource = '2d' | '3d';
+export type FloorplanNavigationPose = {
+    source: FloorplanNavigationSource;
+    revision: number;
+    target: [number, number, number];
+    azimuth: number;
+    viewWidth: number;
+};
+export type FloorplanNavigationPoseInput = Omit<FloorplanNavigationPose, 'revision'>;
+//# sourceMappingURL=floorplan-navigation-types.d.ts.map

package/dist/floorplan-navigation-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-navigation-types.d.ts","sourceRoot":"","sources":["../src/floorplan-navigation-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GAAG,IAAI,GAAG,IAAI,CAAA;AAEnD,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,yBAAyB,CAAA;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,4BAA4B,GAAG,IAAI,CAAC,uBAAuB,EAAE,UAAU,CAAC,CAAA"}

package/dist/floorplan-navigation-types.js

@@ -0,0 +1 @@
+export {};

package/dist/floorplan-registry-projection.d.ts

@@ -0,0 +1,84 @@
+import type { AnyNode, AnyNodeDefinition, AnyNodeId, FloorplanGeometry, FloorplanPalette, GeometryContext } from '@ubuilder-ai/core';
+import { type FloorplanMetricNotation, type FloorplanRenderPurpose, type FloorplanWallDimensionReference } from '@ubuilder-ai/floorplan-contract';
+export type FloorplanDefinitionResolver = (kind: string) => AnyNodeDefinition | undefined;
+export type FloorplanProjectionContext = {
+    children: AnyNode[];
+    siblings: AnyNode[];
+    parent: AnyNode | null;
+};
+export type FloorplanRegistryProjectionEntry = {
+    id: AnyNodeId;
+    node: AnyNode;
+    context?: FloorplanProjectionContext;
+};
+export type FloorplanRegistryProjection = {
+    entries: readonly FloorplanRegistryProjectionEntry[];
+    levelNodeIdsByType: ReadonlyMap<string, readonly AnyNodeId[]>;
+};
+export type ProjectFloorplanRegistryOptions = {
+    nodes: Readonly<Record<string, AnyNode>>;
+    activeLevelId: AnyNodeId;
+    getDefinition: FloorplanDefinitionResolver;
+    isKindEnabled: (kind: string) => boolean;
+    includeBuildingScoped: boolean;
+};
+/**
+ * Stable z-order sort. SVG renders in document order — later siblings
+ * paint on top of earlier ones — so anything that should sit under other
+ * floor-plan geometry has to declare a lower `floorplanOrder`. Within a
+ * layer bucket the original projection order remains stable.
+ */
+export declare function orderFloorplanProjectionEntries<T extends {
+    node: AnyNode;
+}>(entries: readonly T[], getDefinition: FloorplanDefinitionResolver): T[];
+export declare function projectFloorplanRegistry({ nodes, activeLevelId, getDefinition, isKindEnabled, includeBuildingScoped, }: ProjectFloorplanRegistryOptions): FloorplanRegistryProjection;
+export type FloorplanGeometryContextViewState = {
+    selected: boolean;
+    unit: 'metric' | 'imperial';
+    metricNotation: FloorplanMetricNotation;
+    purpose?: FloorplanRenderPurpose;
+    wallDimensionReference?: FloorplanWallDimensionReference;
+    highlighted: boolean;
+    hovered: boolean;
+    moving: boolean;
+    palette: FloorplanPalette | undefined;
+};
+export type CreateFloorplanGeometryContextOptions = {
+    node: AnyNode;
+    nodes: Readonly<Record<string, AnyNode>>;
+    viewState: FloorplanGeometryContextViewState;
+    context?: FloorplanProjectionContext;
+    levelData?: unknown;
+    runtimeState?: unknown;
+    resolve?: GeometryContext['resolve'];
+};
+export declare function createFloorplanGeometryContext({ node, nodes, viewState, context, levelData, runtimeState, resolve: resolveOverride, }: CreateFloorplanGeometryContextOptions): GeometryContext;
+export declare function computeFloorplanLevelData({ definition, nodeIds, nodes, }: {
+    definition: AnyNodeDefinition | undefined;
+    nodeIds: readonly AnyNodeId[] | undefined;
+    nodes: Readonly<Record<string, AnyNode>>;
+}): unknown;
+/**
+ * Walk a `FloorplanGeometry` tree and split it into two trees: one with
+ * only "base" primitives (polygons, paths, fills, strokes) and one with
+ * only "overlay" primitives (handles, labels — see `OVERLAY_KINDS`).
+ *
+ * Groups recurse: a `kind: 'group'` is split into a base group and an
+ * overlay group, both carrying the same `transform` so nested rotations
+ * / translations apply in both passes. Empty groups collapse to `null`
+ * so the caller can skip emitting an `<g>` when there's nothing to draw.
+ */
+export declare function splitFloorplanOverlay(geometry: FloorplanGeometry): {
+    base: FloorplanGeometry | null;
+    overlay: FloorplanGeometry | null;
+};
+export declare function buildFloorplanGeometryPartition({ definition, node, context, transformGeometry, }: {
+    definition: AnyNodeDefinition | undefined;
+    node: AnyNode;
+    context: GeometryContext;
+    transformGeometry?: (geometry: FloorplanGeometry) => FloorplanGeometry | null;
+}): {
+    base: FloorplanGeometry | null;
+    overlay: FloorplanGeometry | null;
+};
+//# sourceMappingURL=floorplan-registry-projection.d.ts.map

package/dist/floorplan-registry-projection.d.ts.map

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

package/dist/floorplan-registry-projection.js

@@ -0,0 +1,260 @@
+import { createFloorplanContextExtensions, } from '@ubuilder-ai/floorplan-contract';
+import { isFloorplanAnnotationObstacleGeometry } from './floorplan-annotation-obstacles';
+/**
+ * Stable z-order sort. SVG renders in document order — later siblings
+ * paint on top of earlier ones — so anything that should sit under other
+ * floor-plan geometry has to declare a lower `floorplanOrder`. Within a
+ * layer bucket the original projection order remains stable.
+ */
+export function orderFloorplanProjectionEntries(entries, getDefinition) {
+    return entries
+        .map((entry, index) => ({ entry, index }))
+        .sort((left, right) => {
+        const leftOrder = getDefinition(left.entry.node.type)?.floorplanOrder ?? 2;
+        const rightOrder = getDefinition(right.entry.node.type)?.floorplanOrder ?? 2;
+        return leftOrder - rightOrder || left.index - right.index;
+    })
+        .map(({ entry }) => entry);
+}
+function childIdsOf(node) {
+    const children = node.children;
+    return Array.isArray(children) ? children : [];
+}
+function resolveLevelContainerId(activeLevelId, nodes, getDefinition) {
+    const level = nodes[activeLevelId];
+    if (!level)
+        return null;
+    const parentId = level.parentId;
+    if (parentId) {
+        const parent = nodes[parentId];
+        if (parent && getDefinition(parent.type)?.capabilities.floorplanLevelContainer) {
+            return parentId;
+        }
+    }
+    for (const candidate of Object.values(nodes)) {
+        if (!getDefinition(candidate.type)?.capabilities.floorplanLevelContainer)
+            continue;
+        if (childIdsOf(candidate).includes(activeLevelId))
+            return candidate.id;
+    }
+    return null;
+}
+export function projectFloorplanRegistry({ nodes, activeLevelId, getDefinition, isKindEnabled, includeBuildingScoped, }) {
+    if (!nodes[activeLevelId]) {
+        return { entries: [], levelNodeIdsByType: new Map() };
+    }
+    const levelNodeIdsByType = new Map();
+    const levelDataVisited = new Set();
+    const collectLevelDataIds = (id) => {
+        if (levelDataVisited.has(id))
+            return;
+        levelDataVisited.add(id);
+        const node = nodes[id];
+        if (!node || !isKindEnabled(node.type))
+            return;
+        const definition = getDefinition(node.type);
+        if (definition?.computeFloorplanLevelData) {
+            const ids = levelNodeIdsByType.get(node.type);
+            if (ids)
+                ids.push(id);
+            else
+                levelNodeIdsByType.set(node.type, [id]);
+        }
+        for (const childId of childIdsOf(node))
+            collectLevelDataIds(childId);
+    };
+    collectLevelDataIds(activeLevelId);
+    const entries = [];
+    const pushEntry = (id, node, context) => {
+        if (!isKindEnabled(node.type))
+            return;
+        entries.push(context ? { id, node, context } : { id, node });
+    };
+    const entryVisited = new Set();
+    const visit = (id) => {
+        if (entryVisited.has(id))
+            return;
+        entryVisited.add(id);
+        const node = nodes[id];
+        if (!node)
+            return;
+        pushEntry(id, node);
+        for (const childId of childIdsOf(node))
+            visit(childId);
+    };
+    visit(activeLevelId);
+    const activeLevel = nodes[activeLevelId];
+    const collectedIds = new Set(entries.map((entry) => entry.id));
+    for (const node of Object.values(nodes)) {
+        const id = node.id;
+        if (collectedIds.has(id) || !isKindEnabled(node.type))
+            continue;
+        const definition = getDefinition(node.type);
+        const linkedLevelIds = definition?.floorplanLinkedLevelIds;
+        if (!definition?.floorplan || !linkedLevelIds?.(node).includes(activeLevelId))
+            continue;
+        pushEntry(id, node, {
+            children: childIdsOf(node)
+                .map((childId) => nodes[childId])
+                .filter((child) => child !== undefined),
+            siblings: [],
+            parent: activeLevel,
+        });
+        collectedIds.add(id);
+    }
+    if (includeBuildingScoped) {
+        const levelContainerId = resolveLevelContainerId(activeLevelId, nodes, getDefinition);
+        if (levelContainerId) {
+            for (const node of Object.values(nodes)) {
+                const id = node.id;
+                if (collectedIds.has(id) || !isKindEnabled(node.type))
+                    continue;
+                const definition = getDefinition(node.type);
+                if (definition?.floorplanScope !== 'building')
+                    continue;
+                if (node.parentId !== levelContainerId)
+                    continue;
+                pushEntry(id, node, { children: [], siblings: [], parent: activeLevel });
+                collectedIds.add(id);
+            }
+        }
+    }
+    return {
+        entries,
+        levelNodeIdsByType,
+    };
+}
+export function createFloorplanGeometryContext({ node, nodes, viewState, context, levelData, runtimeState, resolve: resolveOverride, }) {
+    const resolve = resolveOverride ?? ((id) => nodes[id]);
+    let children;
+    let siblings;
+    let parent;
+    if (context) {
+        children = context.children;
+        siblings = context.siblings;
+        parent = context.parent;
+    }
+    else {
+        children = childIdsOf(node)
+            .map((childId) => nodes[childId])
+            .filter((child) => child !== undefined);
+        const parentId = node.parentId;
+        parent = parentId ? (nodes[parentId] ?? null) : null;
+        siblings = [];
+        if (parent) {
+            const parentChildren = parent.children;
+            if (Array.isArray(parentChildren)) {
+                const parentChildIds = parentChildren;
+                for (const siblingId of parentChildIds) {
+                    if (siblingId === node.id)
+                        continue;
+                    const sibling = nodes[siblingId];
+                    if (sibling?.type === node.type)
+                        siblings.push(sibling);
+                }
+            }
+            else {
+                siblings = Object.values(nodes).filter((sibling) => sibling !== node && sibling.type === node.type && sibling.parentId === parentId);
+            }
+        }
+    }
+    return {
+        resolve,
+        children,
+        siblings,
+        parent,
+        levelData,
+        extensions: createFloorplanContextExtensions({
+            metricNotation: viewState.metricNotation,
+            purpose: viewState.purpose ?? 'edit',
+            runtimeState,
+            wallDimensionReference: viewState.wallDimensionReference,
+        }),
+        viewState: viewState.palette
+            ? {
+                selected: viewState.selected,
+                unit: viewState.unit,
+                highlighted: viewState.highlighted,
+                hovered: viewState.hovered,
+                moving: viewState.moving,
+                palette: viewState.palette,
+            }
+            : undefined,
+    };
+}
+export function computeFloorplanLevelData({ definition, nodeIds, nodes, }) {
+    const compute = definition?.computeFloorplanLevelData;
+    const kind = definition?.kind;
+    if (!compute || !kind || !nodeIds?.length)
+        return undefined;
+    const siblings = nodeIds
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === kind);
+    return compute({ siblings, nodes: nodes });
+}
+/**
+ * Geometry kinds that always render in the overlay pass — interactive
+ * handles and node labels. These need to sit above every kind's base
+ * geometry regardless of the owning node's z-bucket so that:
+ *   - polygon edit handles on a selected slab don't get hidden by the
+ *     walls / items resting on top of the slab,
+ *   - a zone's name stays legible above the slab covering the zone, and
+ *   - measurement labels never get clipped by structural fills.
+ */
+const OVERLAY_KINDS = new Set([
+    'text',
+    'endpoint-handle',
+    'midpoint-handle',
+    'edge-handle',
+    'move-handle',
+    'move-arrow',
+    'rotate-arrow',
+    'dimension',
+    'dimension-string',
+    'dimension-label',
+    'equal-spacing-badge',
+]);
+/**
+ * Walk a `FloorplanGeometry` tree and split it into two trees: one with
+ * only "base" primitives (polygons, paths, fills, strokes) and one with
+ * only "overlay" primitives (handles, labels — see `OVERLAY_KINDS`).
+ *
+ * Groups recurse: a `kind: 'group'` is split into a base group and an
+ * overlay group, both carrying the same `transform` so nested rotations
+ * / translations apply in both passes. Empty groups collapse to `null`
+ * so the caller can skip emitting an `<g>` when there's nothing to draw.
+ */
+export function splitFloorplanOverlay(geometry) {
+    if (isFloorplanAnnotationObstacleGeometry(geometry)) {
+        return { base: null, overlay: geometry };
+    }
+    if (OVERLAY_KINDS.has(geometry.kind)) {
+        return { base: null, overlay: geometry };
+    }
+    if (geometry.kind === 'group') {
+        const baseChildren = [];
+        const overlayChildren = [];
+        for (const child of geometry.children) {
+            const split = splitFloorplanOverlay(child);
+            if (split.base)
+                baseChildren.push(split.base);
+            if (split.overlay)
+                overlayChildren.push(split.overlay);
+        }
+        return {
+            base: baseChildren.length > 0
+                ? { kind: 'group', children: baseChildren, transform: geometry.transform }
+                : null,
+            overlay: overlayChildren.length > 0
+                ? { kind: 'group', children: overlayChildren, transform: geometry.transform }
+                : null,
+        };
+    }
+    return { base: geometry, overlay: null };
+}
+export function buildFloorplanGeometryPartition({ definition, node, context, transformGeometry, }) {
+    const builder = definition?.floorplan;
+    const geometry = builder?.(node, context) ?? null;
+    const transformed = geometry && transformGeometry ? transformGeometry(geometry) : geometry;
+    return transformed ? splitFloorplanOverlay(transformed) : { base: null, overlay: null };
+}

package/dist/floorplan-render-context.d.ts

@@ -0,0 +1,56 @@
+import type { FloorplanPalette } from '@ubuilder-ai/core';
+import { type ReactNode } from 'react';
+/**
+ * Per-frame render context shared between a host floorplan surface
+ * and its registry-driven scene renderer.
+ *
+ * The host is the authoritative owner of the floor-plan SVG —
+ * it computes `unitsPerPixel` from the viewBox / surface size, mounts the
+ * pan/zoom `<g>`, and knows the active theme. The scene renderer is mounted
+ * inside the same `<g>`, so anything it draws shares the same coordinate
+ * system; this context plumbs through the bits it can't recompute on its
+ * own without re-implementing the legacy's resize / theme logic.
+ *
+ */
+export type FloorplanRenderContextValue = {
+    /** SVG units per screen pixel — used to keep handle radii consistent at any zoom. */
+    unitsPerPixel: number;
+    /** Themed palette mirroring the host `FloorplanPalette` accent slots. */
+    palette: FloorplanPalette;
+    /** SVG `<pattern>` id mounted in `<defs>` by the host for hatch fills. */
+    hatchPatternId: string;
+    /**
+     * Rotation (degrees) applied to the registry layer's parent `<g>` by the
+     * host surface — 90° by default, adjusted by building rotation. Renderers
+     * that emit text labels use this to keep their final on-screen orientation
+     * readable instead of mirroring whatever the parent rotation is.
+     */
+    sceneRotationDeg: number;
+};
+export type FloorplanStaticRenderContextValue = Omit<FloorplanRenderContextValue, 'sceneRotationDeg' | 'unitsPerPixel'> & {
+    getSceneRotationDeg: () => number;
+    getUnitsPerPixel: () => number;
+    subscribeUnitsPerPixel: (listener: () => void) => () => void;
+};
+export type FloorplanRenderScaleReference = {
+    read: () => number;
+    subscribe: (listener: () => void) => () => void;
+    update: (unitsPerPixel: number) => void;
+};
+export declare function createFloorplanRenderScaleReference(initialUnitsPerPixel: number): FloorplanRenderScaleReference;
+export declare function FloorplanRenderProvider({ children, unitsPerPixel, palette, hatchPatternId, sceneRotationDeg, getSceneRotationDeg, }: FloorplanRenderContextValue & {
+    children: ReactNode;
+    getSceneRotationDeg: () => number;
+}): import("react").JSX.Element;
+/**
+ * Read the active render context. Returns `null` when called outside a
+ * provider — consumers treat this as "render statically, skip
+ * theme-aware chrome and interactive handles". This makes the layer
+ * usable in isolation tests + future editor shells without bringing the
+ * whole host surface along.
+ */
+export declare function useFloorplanRender(): FloorplanRenderContextValue | null;
+export declare function useFloorplanStaticRender(): FloorplanStaticRenderContextValue | null;
+export declare function useFloorplanStaticUnitsPerPixel(): number;
+export declare function useFloorplanSceneRotation(): number;
+//# sourceMappingURL=floorplan-render-context.d.ts.map

package/dist/floorplan-render-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-render-context.d.ts","sourceRoot":"","sources":["../src/floorplan-render-context.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACzD,OAAO,EAEL,KAAK,SAAS,EAMf,MAAM,OAAO,CAAA;AAEd;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,qFAAqF;IACrF,aAAa,EAAE,MAAM,CAAA;IACrB,yEAAyE;IACzE,OAAO,EAAE,gBAAgB,CAAA;IACzB,0EAA0E;IAC1E,cAAc,EAAE,MAAM,CAAA;IACtB;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAClD,2BAA2B,EAC3B,kBAAkB,GAAG,eAAe,CACrC,GAAG;IACF,mBAAmB,EAAE,MAAM,MAAM,CAAA;IACjC,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,sBAAsB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;CAC7D,CAAA;AAMD,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,MAAM,CAAA;IAClB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;IAC/C,MAAM,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,CAAA;CACxC,CAAA;AAED,wBAAgB,mCAAmC,CACjD,oBAAoB,EAAE,MAAM,GAC3B,6BAA6B,CAe/B;AAED,wBAAgB,uBAAuB,CAAC,EACtC,QAAQ,EACR,aAAa,EACb,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,mBAAmB,GACpB,EAAE,2BAA2B,GAAG;IAC/B,QAAQ,EAAE,SAAS,CAAA;IACnB,mBAAmB,EAAE,MAAM,MAAM,CAAA;CAClC,+BA6BA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,2BAA2B,GAAG,IAAI,CAgBvE;AAED,wBAAgB,wBAAwB,IAAI,iCAAiC,GAAG,IAAI,CAEnF;AAKD,wBAAgB,+BAA+B,IAAI,MAAM,CAOxD;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD"}

package/dist/floorplan-render-context.js

@@ -0,0 +1,75 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useLayoutEffect, useMemo, useRef, useSyncExternalStore, } from 'react';
+const FloorplanStaticRenderContext = createContext(null);
+const FloorplanSceneRotationContext = createContext(0);
+const FloorplanUnitsPerPixelContext = createContext(1);
+export function createFloorplanRenderScaleReference(initialUnitsPerPixel) {
+    let unitsPerPixel = initialUnitsPerPixel;
+    const listeners = new Set();
+    return {
+        read: () => unitsPerPixel,
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        update: (nextUnitsPerPixel) => {
+            if (Object.is(unitsPerPixel, nextUnitsPerPixel))
+                return;
+            unitsPerPixel = nextUnitsPerPixel;
+            for (const listener of listeners)
+                listener();
+        },
+    };
+}
+export function FloorplanRenderProvider({ children, unitsPerPixel, palette, hatchPatternId, sceneRotationDeg, getSceneRotationDeg, }) {
+    const renderScaleReference = useRef(null);
+    if (!renderScaleReference.current) {
+        renderScaleReference.current = createFloorplanRenderScaleReference(unitsPerPixel);
+    }
+    const getUnitsPerPixel = renderScaleReference.current.read;
+    const subscribeUnitsPerPixel = renderScaleReference.current.subscribe;
+    useLayoutEffect(() => {
+        renderScaleReference.current?.update(unitsPerPixel);
+    }, [unitsPerPixel]);
+    const staticValue = useMemo(() => ({
+        palette,
+        hatchPatternId,
+        getSceneRotationDeg,
+        getUnitsPerPixel,
+        subscribeUnitsPerPixel,
+    }), [palette, hatchPatternId, getSceneRotationDeg, getUnitsPerPixel, subscribeUnitsPerPixel]);
+    return (_jsx(FloorplanStaticRenderContext.Provider, { value: staticValue, children: _jsx(FloorplanUnitsPerPixelContext.Provider, { value: unitsPerPixel, children: _jsx(FloorplanSceneRotationContext.Provider, { value: sceneRotationDeg, children: children }) }) }));
+}
+/**
+ * Read the active render context. Returns `null` when called outside a
+ * provider — consumers treat this as "render statically, skip
+ * theme-aware chrome and interactive handles". This makes the layer
+ * usable in isolation tests + future editor shells without bringing the
+ * whole host surface along.
+ */
+export function useFloorplanRender() {
+    const staticValue = useContext(FloorplanStaticRenderContext);
+    const sceneRotationDeg = useContext(FloorplanSceneRotationContext);
+    const unitsPerPixel = useContext(FloorplanUnitsPerPixelContext);
+    return useMemo(() => staticValue
+        ? {
+            unitsPerPixel,
+            palette: staticValue.palette,
+            hatchPatternId: staticValue.hatchPatternId,
+            sceneRotationDeg,
+        }
+        : null, [sceneRotationDeg, staticValue, unitsPerPixel]);
+}
+export function useFloorplanStaticRender() {
+    return useContext(FloorplanStaticRenderContext);
+}
+const subscribeToNoFloorplanScale = () => () => { };
+const readDefaultFloorplanScale = () => 1;
+export function useFloorplanStaticUnitsPerPixel() {
+    const staticValue = useContext(FloorplanStaticRenderContext);
+    return useSyncExternalStore(staticValue?.subscribeUnitsPerPixel ?? subscribeToNoFloorplanScale, staticValue?.getUnitsPerPixel ?? readDefaultFloorplanScale, staticValue?.getUnitsPerPixel ?? readDefaultFloorplanScale);
+}
+export function useFloorplanSceneRotation() {
+    return useContext(FloorplanSceneRotationContext);
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export * from './floorplan-annotation-obstacles';
+export { cameraPoseToFloorplanNavigationPose, createFloorplanCameraNavigationChannel, createFloorplanCameraSyncBridge, type FloorplanCameraNavigationChannel, type FloorplanCameraSyncBridge, floorplanNavigationPoseToCameraPose, floorplanNavigationPoseToInspectionCameraPose, } from './floorplan-camera-sync';
+export { type FloorplanPoint, floorplanLocalToWorldPoint, worldToFloorplanLocalPoint, } from './floorplan-coordinates';
+export * from './floorplan-dimension-renderer';
+export * from './floorplan-geometry-renderer';
+export * from './floorplan-label-angle';
+export { type FloorplanNavigationController, FloorplanNavigationShell, type FloorplanNavigationShellProps, type FloorplanViewport, rotateFloorplanPoint, type UseFloorplanNavigationOptions, useFloorplanNavigation, } from './floorplan-navigation-shell';
+export type { FloorplanNavigationPose, FloorplanNavigationPoseInput, FloorplanNavigationSource, } from './floorplan-navigation-types';
+export * from './floorplan-registry-projection';
+export * from './floorplan-render-context';
+export * from './marquee-geometry';
+export * from './spatial-workspace-camera-action-control';
+export * from './spatial-workspace-display-control';
+export * from './spatial-workspace-gis-control';
+export * from './spatial-workspace-level-selector';
+export * from './spatial-workspace-level-wall-control';
+export * from './spatial-workspace-mode';
+export * from './spatial-workspace-styles';
+export * from './spatial-workspace-view-mode-control';
+export { type SpatialWorkspaceRenderContext, type SpatialWorkspaceViewMode, SpatialWorkspaceViewport, type SpatialWorkspaceViewportProps, } from './spatial-workspace-viewport';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAA;AAChD,OAAO,EACL,mCAAmC,EACnC,sCAAsC,EACtC,+BAA+B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,yBAAyB,EAC9B,mCAAmC,EACnC,6CAA6C,GAC9C,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,KAAK,cAAc,EACnB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,yBAAyB,CAAA;AAChC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,yBAAyB,CAAA;AACvC,OAAO,EACL,KAAK,6BAA6B,EAClC,wBAAwB,EACxB,KAAK,6BAA6B,EAClC,KAAK,iBAAiB,EACtB,oBAAoB,EACpB,KAAK,6BAA6B,EAClC,sBAAsB,GACvB,MAAM,8BAA8B,CAAA;AACrC,YAAY,EACV,uBAAuB,EACvB,4BAA4B,EAC5B,yBAAyB,GAC1B,MAAM,8BAA8B,CAAA;AACrC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,2CAA2C,CAAA;AACzD,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,wCAAwC,CAAA;AACtD,cAAc,0BAA0B,CAAA;AACxC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,uCAAuC,CAAA;AACrD,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAC7B,wBAAwB,EACxB,KAAK,6BAA6B,GACnC,MAAM,8BAA8B,CAAA"}

package/dist/index.js

@@ -0,0 +1,19 @@
+export * from './floorplan-annotation-obstacles';
+export { cameraPoseToFloorplanNavigationPose, createFloorplanCameraNavigationChannel, createFloorplanCameraSyncBridge, floorplanNavigationPoseToCameraPose, floorplanNavigationPoseToInspectionCameraPose, } from './floorplan-camera-sync';
+export { floorplanLocalToWorldPoint, worldToFloorplanLocalPoint, } from './floorplan-coordinates';
+export * from './floorplan-dimension-renderer';
+export * from './floorplan-geometry-renderer';
+export * from './floorplan-label-angle';
+export { FloorplanNavigationShell, rotateFloorplanPoint, useFloorplanNavigation, } from './floorplan-navigation-shell';
+export * from './floorplan-registry-projection';
+export * from './floorplan-render-context';
+export * from './marquee-geometry';
+export * from './spatial-workspace-camera-action-control';
+export * from './spatial-workspace-display-control';
+export * from './spatial-workspace-gis-control';
+export * from './spatial-workspace-level-selector';
+export * from './spatial-workspace-level-wall-control';
+export * from './spatial-workspace-mode';
+export * from './spatial-workspace-styles';
+export * from './spatial-workspace-view-mode-control';
+export { SpatialWorkspaceViewport, } from './spatial-workspace-viewport';

package/dist/marquee-geometry.d.ts

@@ -0,0 +1,22 @@
+export type ScreenRect = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export type Point2 = [number, number];
+/** Andrew monotone-chain convex hull. Returns CCW hull without the closing
+ *  point; degenerate inputs (0–2 points, collinear sets) pass through. */
+export declare function convexHull2D(points: readonly Point2[]): Point2[];
+/** Segment vs polygon (general, possibly concave): endpoint containment or
+ *  any edge crossing. */
+export declare function segmentIntersectsPolygon(a: Point2, b: Point2, polygon: readonly Point2[]): boolean;
+/** Polygon vs polygon (general): containment either way or any edge crossing. */
+export declare function polygonsIntersect(a: readonly Point2[], b: readonly Point2[]): boolean;
+/**
+ * Does the axis-aligned marquee rect intersect the (convex) hull polygon?
+ * Covers all cases: hull vertex inside the rect, rect fully inside the hull,
+ * and pure edge crossings.
+ */
+export declare function rectIntersectsHull(rect: ScreenRect, hull: readonly Point2[]): boolean;
+//# sourceMappingURL=marquee-geometry.d.ts.map

package/dist/marquee-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marquee-geometry.d.ts","sourceRoot":"","sources":["../src/marquee-geometry.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAMrC;0EAC0E;AAC1E,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAsBhE;AAgDD;yBACyB;AACzB,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,OAAO,CAQT;AAED,iFAAiF;AACjF,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAYrF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CA2BrF"}