@ifc-lite/viewer 1.22.0 → 1.23.0

package/src/components/viewer/properties/PrecisionGridBadge.tsx

@@ -0,0 +1,125 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Small badge in the GeoreferencingPanel header that tells the user
+ * whether their CRS is using a precision NTv2/GeoTIFF datum-shift grid
+ * (sub-decimeter accuracy) or the +towgs84 fallback (up to ~120 m error
+ * for Bessel-based national grids like RD/NL, OSGB/UK, MGI/AT).
+ *
+ * Re-checks on a short interval so it flips from "loading" → "loaded"
+ * after the grid finishes downloading without forcing the parent to
+ * re-render.
+ */
+
+import { useEffect, useState } from 'react';
+import { CheckCircle2, AlertTriangle, Loader2 } from 'lucide-react';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
+import {
+  PRECISION_GRIDS,
+  hasFailedPrecisionGrid,
+  hasLoadedPrecisionGrid,
+} from '@/lib/geo/precision-grids';
+
+interface PrecisionGridBadgeProps {
+  crsName: string | undefined;
+}
+
+function extractEpsgCode(crsName: string | undefined): string | null {
+  if (!crsName) return null;
+  const match = crsName.match(/EPSG[:\s]*(\d+)/i);
+  return match ? match[1] : null;
+}
+
+type BadgeState = 'loading' | 'loaded' | 'failed';
+
+export function PrecisionGridBadge({ crsName }: PrecisionGridBadgeProps) {
+  const code = extractEpsgCode(crsName);
+  const spec = code ? PRECISION_GRIDS[code] : undefined;
+  const [state, setState] = useState<BadgeState>(() => {
+    if (!spec) return 'loading';
+    if (hasLoadedPrecisionGrid(code!)) return 'loaded';
+    if (hasFailedPrecisionGrid(code!)) return 'failed';
+    return 'loading';
+  });
+
+  useEffect(() => {
+    if (!spec || state !== 'loading') return;
+    // Poll every 250ms until the grid loader settles (success or failure).
+    // Cheap — PRECISION_GRIDS lookup is O(1) and most CRSs never trigger
+    // this path. Stops as soon as the grid resolves or the component
+    // unmounts.
+    const id = setInterval(() => {
+      if (hasLoadedPrecisionGrid(code!)) {
+        setState('loaded');
+      } else if (hasFailedPrecisionGrid(code!)) {
+        setState('failed');
+      }
+    }, 250);
+    return () => clearInterval(id);
+  }, [spec, state, code]);
+
+  // CRS without a registered precision grid — accuracy depends entirely on
+  // whether its +towgs84 is good (ETRS89/WGS84-aligned CRSs: yes; old
+  // Bessel/Airy national grids: no). Don't show a badge for these.
+  if (!spec) return null;
+
+  if (state === 'loaded') {
+    return (
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <span className="inline-flex items-center gap-1 px-1.5 py-0.5 text-[9px] font-medium border border-emerald-300/60 dark:border-emerald-700/60 bg-emerald-50 dark:bg-emerald-950/40 text-emerald-700 dark:text-emerald-300 shrink-0">
+            <CheckCircle2 className="h-2.5 w-2.5" />
+            grid
+          </span>
+        </TooltipTrigger>
+        <TooltipContent side="bottom" className="text-xs max-w-xs">
+          <div>Precision NTv2/GeoTIFF grid loaded for {spec.region}.</div>
+          <div className="mt-1 text-[10px] opacity-80">
+            Sub-decimeter datum-shift accuracy via{' '}
+            <code className="font-mono">{spec.filename}</code>.
+          </div>
+        </TooltipContent>
+      </Tooltip>
+    );
+  }
+
+  if (state === 'failed') {
+    return (
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <span className="inline-flex items-center gap-1 px-1.5 py-0.5 text-[9px] font-medium border border-red-300/60 dark:border-red-700/60 bg-red-50 dark:bg-red-950/40 text-red-700 dark:text-red-300 shrink-0">
+            <AlertTriangle className="h-2.5 w-2.5" />
+            grid failed
+          </span>
+        </TooltipTrigger>
+        <TooltipContent side="bottom" className="text-xs max-w-xs">
+          <div>Precision grid fetch failed for {spec.region}.</div>
+          <div className="mt-1 text-[10px] opacity-80">
+            Falling back to +towgs84 approximation. Check network access to{' '}
+            <code className="font-mono">cdn.proj.org</code>.
+          </div>
+        </TooltipContent>
+      </Tooltip>
+    );
+  }
+
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <span className="inline-flex items-center gap-1 px-1.5 py-0.5 text-[9px] font-medium border border-amber-300/60 dark:border-amber-700/60 bg-amber-50 dark:bg-amber-950/40 text-amber-700 dark:text-amber-300 shrink-0">
+          <Loader2 className="h-2.5 w-2.5 animate-spin" />
+          loading grid
+        </span>
+      </TooltipTrigger>
+      <TooltipContent side="bottom" className="text-xs max-w-xs">
+        <div>Fetching precision grid for {spec.region}…</div>
+        <div className="mt-1 text-[10px] opacity-80">
+          Until it arrives, placement uses the +towgs84 approximation (off by
+          up to ~120 m for this CRS).
+        </div>
+      </TooltipContent>
+    </Tooltip>
+  );
+}

package/src/components/viewer/properties/raw-step-format.ts

@@ -22,6 +22,7 @@
  */
 
 import type { IfcAttributeValue } from '@ifc-lite/mutations';
+import { safeUtf8Decode } from '@ifc-lite/data';
 
 /**
  * Tokenize the inside of a STEP entity body (`,`-separated arguments)
@@ -86,9 +87,10 @@ export function extractRawStepTokens(
   byteLength: number,
 ): string[] | null {
   if (byteLength <= 0) return null;
-  const text = new TextDecoder().decode(
-    buffer.subarray(byteOffset, byteOffset + byteLength),
-  );
+  // safeUtf8Decode handles SAB-backed source buffers (the parser
+  // keeps `dataStore.source` SAB-backed for zero-copy worker sharing,
+  // and Firefox/Chrome reject `TextDecoder.decode()` on SAB views).
+  const text = safeUtf8Decode(buffer, byteOffset, byteOffset + byteLength);
   // Match #N=TYPE( ... ) — the trailing `;` is optional in case the
   // ref slice doesn't include it.
   const match = text.match(/^#\d+\s*=\s*[A-Z0-9_]+\(([\s\S]*)\)\s*;?\s*$/i);

package/src/components/viewer/selectionHandlers.ts

@@ -11,6 +11,7 @@
 import type { MouseHandlerContext } from './mouseHandlerTypes.js';
 import { useViewerStore } from '@/store';
 import { fromGlobalIdFromModels, toGlobalIdFromModels } from '@/store/globalId';
+import { pointInPolygon } from '@/lib/polygon-clip';
 import { toast } from '@/components/ui/toast';
 
 /**
@@ -84,6 +85,115 @@ export async function handleSelectionClick(ctx: MouseHandlerContext, e: MouseEve
   // corner→opposite for slab rectangle, N+Enter for slab polygon, single
   // for columns). Uses magnetic snap so points lock to vertices/edges
   // when the cursor is near them — same UX as the measure tool.
+  // Split tool — click on a wall / beam / column / member to cut
+  // it at the cursor's projected position. Hover preview lives on
+  // the store (splitHoverPoint / splitHoverDistance) and
+  // SplitOverlay renders the SVG guide; this handler commits the
+  // click by dispatching to the right action for the latched
+  // target's element type.
+  if (tool === 'split') {
+    const state = useViewerStore.getState();
+    const targetModelId = state.splitTargetModelId;
+    const targetExpressId = state.splitTargetExpressId;
+    if (targetModelId === null || targetExpressId === null) {
+      // Click missed any splittable element — no-op so the cursor
+      // doesn't fight the user. The overlay's hint stays visible.
+      return;
+    }
+
+    // Slab two-click flow takes precedence when we're mid-anchor.
+    // The second click commits the cut line from anchor → cursor.
+    // Raycast onto the SOURCE SLAB'S floor (not the global active
+    // storey) so federated / non-active-storey splits land at the
+    // right elevation.
+    if (state.splitMode === 'first-anchor' && state.slabCutAnchor) {
+      const slabFloorY = resolveSlabFloorY(targetModelId, targetExpressId);
+      const cutPoint = raycastStoreyFloor(ctx, x, y, slabFloorY ?? undefined);
+      if (!cutPoint) {
+        toast.error("Couldn't read cut point");
+        return;
+      }
+      const cursorIfc = rendererPointToIfcStoreyLocal(cutPoint);
+      const result = state.splitSlabByLine(
+        targetModelId,
+        targetExpressId,
+        state.slabCutAnchor,
+        [cursorIfc[0], cursorIfc[1]],
+      );
+      if (!result.ok) {
+        toast.error(`Couldn't split slab: ${result.reason}`);
+        return;
+      }
+      state.clearSplitHover();
+      // Move selection to whichever half contains the click. Both
+      // halves are valid polygons; the click landed at `cursorIfc`.
+      const rightFp = state.readSlabFootprint(targetModelId, result.right.expressId);
+      const inRight = rightFp
+        ? pointInPolygon(rightFp.footprint, [cursorIfc[0], cursorIfc[1]])
+        : false;
+      state.setSelectedEntityId(inRight ? result.right.globalId : result.left.globalId);
+      toast.success('Slab split — Ctrl+Z to undo');
+      return;
+    }
+
+    // Single-click element split (wall / beam / column / member).
+    // Wall first because most edits land on walls; if that returns
+    // null we try the linear-element path.
+    const distance = state.splitHoverDistance;
+    if (distance !== null && distance > 0) {
+      const wallTry = state.splitWallAtDistance(targetModelId, targetExpressId, distance);
+      if (wallTry.ok) {
+        state.clearSplitHover();
+        state.setSelectedEntityId(wallTry.right.globalId);
+        // Mention opening reassignment in the toast only when it
+        // happened — silence is preferable to "0 openings moved"
+        // for a wall with no doors / windows.
+        const op = wallTry.openings;
+        const opSummary =
+          op.toLeft + op.toRight > 0
+            ? ` (${op.toLeft + op.toRight} opening${op.toLeft + op.toRight === 1 ? '' : 's'} reassigned)`
+            : '';
+        toast.success(`Wall split${opSummary} — Ctrl+Z to undo`);
+        return;
+      }
+      const linearTry = state.splitLinearElementAtDistance(
+        targetModelId,
+        targetExpressId,
+        distance,
+      );
+      if (linearTry.ok) {
+        state.clearSplitHover();
+        state.setSelectedEntityId(linearTry.right.globalId);
+        toast.success('Element split — Ctrl+Z to undo');
+        return;
+      }
+    }
+
+    // Fall through to the slab path: first click latches the
+    // anchor, second click (handled above) commits. Anchor lands
+    // on the source slab's storey floor (not the global active
+    // storey) — `slabFootprint.storeyElevation` is already the
+    // exact value we need, so pass it through directly.
+    const slabFootprint = state.readSlabFootprint(targetModelId, targetExpressId);
+    if (slabFootprint) {
+      const anchorPoint = raycastStoreyFloor(ctx, x, y, slabFootprint.storeyElevation);
+      if (!anchorPoint) {
+        toast.error("Couldn't read anchor point");
+        return;
+      }
+      const anchorIfc = rendererPointToIfcStoreyLocal(anchorPoint);
+      state.setSlabCutAnchor(
+        [anchorIfc[0], anchorIfc[1]],
+        slabFootprint.footprint,
+        slabFootprint.storeyElevation,
+      );
+      return;
+    }
+
+    toast.error("Couldn't split: not a splittable element");
+    return;
+  }
+
   if (tool === 'addElement') {
     const currentLock = ctx.edgeLockStateRef.current;
     const result = renderer.raycastSceneMagnetic(x, y, {
@@ -109,7 +219,20 @@ export async function handleSelectionClick(ctx: MouseHandlerContext, e: MouseEve
       ?? result.intersection?.point
       ?? raycastStoreyFloor(ctx, x, y);
     if (!point) return;
-    await handleAddElementDrop(point);
+    // Smart-placement: if the click landed on (or snapped to) an
+    // existing entity, infer the target storey from THAT entity's
+    // spatial-hierarchy entry rather than the AddElement panel's
+    // dropdown. Lets the user click on a wall on storey 3 to add
+    // a beam there without first changing the storey selector.
+    // Only kicks in when we actually have an entity under the
+    // cursor — empty-space clicks fall back to the panel value.
+    const hitExpressId = result.snapTarget?.expressId
+      ?? result.intersection?.expressId
+      ?? null;
+    const inferredStorey = hitExpressId !== null
+      ? inferStoreyForGlobalId(hitExpressId)
+      : null;
+    await handleAddElementDrop(point, inferredStorey ?? undefined);
     return;
   }
 
@@ -172,6 +295,27 @@ export async function handleSelectionClick(ctx: MouseHandlerContext, e: MouseEve
   }
 }
 
+/**
+ * Resolve the storey + model for a hit globalId so the AddElement
+ * click handler can place the new entity in the SAME storey as the
+ * existing element under the cursor. Returns null when the hit
+ * doesn't resolve to any model's spatial-hierarchy entry — caller
+ * falls back to the AddElement panel's storey selector.
+ *
+ * Federation-aware via `fromGlobalIdFromModels`.
+ */
+function inferStoreyForGlobalId(
+  globalId: number,
+): { modelId: string; storeyId: number } | null {
+  const state = useViewerStore.getState();
+  const local = fromGlobalIdFromModels(state.models, globalId);
+  if (!local) return null;
+  const ds = state.models.get(local.modelId)?.ifcDataStore;
+  const storeyId = ds?.spatialHierarchy?.elementToStorey.get(local.expressId);
+  if (storeyId === undefined) return null;
+  return { modelId: local.modelId, storeyId };
+}
+
 /**
  * Find the first IfcBuildingStorey entity in the active model. Used as a
  * fallback when the user hasn't picked a target storey in the panel.
@@ -210,20 +354,34 @@ export function rendererPointToIfcStoreyLocal(point: { x: number; y: number; z:
  * Storey-floor ray-plane intersection — used as a fallback when the
  * scene raycast misses every mesh (so the user can place new elements
  * in empty space, not just on existing surfaces). The floor sits at
- * renderer Y = storey elevation; if no storey is selected we use 0
- * (the renderer's default ground plane).
+ * renderer Y = storey elevation.
+ *
+ * `storeyOverride` lets the caller supply an explicit floor Y
+ * (renderer frame). Used by the Split tool so a slab on storey 3
+ * doesn't accidentally project clicks onto storey 0's floor when
+ * the addElement / active-model state points elsewhere. Falls back
+ * to `resolveStoreyFloorY()` (active-model lookup) when omitted.
  */
 function raycastStoreyFloor(
   ctx: MouseHandlerContext,
   x: number,
   y: number,
+  storeyOverride?: number,
 ): { x: number; y: number; z: number } | null {
   const camera = ctx.renderer.getCamera();
   const canvas = ctx.renderer.getCanvas();
   if (!camera || !canvas) return null;
-  const ray = camera.unprojectToRay(x, y, canvas.clientWidth, canvas.clientHeight);
+  // x/y arrive in CSS space (handleSelectionClick subtracts the
+  // bounding-rect origin). `unprojectToRay` expects drawing-buffer
+  // coords, which differ from CSS by DPR. Convert both the cursor
+  // and the canvas size so the ray is computed in the same space
+  // `projectToScreen` writes to — otherwise pick drifts at DPR ≠ 1.
+  const rect = canvas.getBoundingClientRect();
+  const sx = rect.width > 0 ? (x / rect.width) * canvas.width : x;
+  const sy = rect.height > 0 ? (y / rect.height) * canvas.height : y;
+  const ray = camera.unprojectToRay(sx, sy, canvas.width, canvas.height);
   if (!ray) return null;
-  const planeY = resolveStoreyFloorY();
+  const planeY = storeyOverride ?? resolveStoreyFloorY();
   // Looking down typically means D.y < 0; reject parallel / near-parallel
   // cases so we don't hand back a wildly extrapolated intersection.
   const dy = ray.direction.y;
@@ -237,6 +395,23 @@ function raycastStoreyFloor(
   };
 }
 
+/**
+ * Helper: resolve a slab's storey elevation in renderer-frame Y so
+ * callers can pass it to `raycastStoreyFloor`. Read from the
+ * model's spatialHierarchy (matches the rest of the split flow's
+ * elevation lookups). Returns null when the slab isn't contained
+ * in a storey we can resolve.
+ */
+function resolveSlabFloorY(modelId: string, expressId: number): number | null {
+  const state = useViewerStore.getState();
+  const ds = state.models.get(modelId)?.ifcDataStore;
+  if (!ds) return null;
+  const storeyId = ds.spatialHierarchy?.elementToStorey.get(expressId);
+  if (storeyId === undefined) return null;
+  const elev = ds.spatialHierarchy?.storeyElevations?.get(storeyId);
+  return typeof elev === 'number' ? elev : null;
+}
+
 /**
  * Resolve the renderer Y of the currently selected (or first
  * available) storey's floor. Falls back to 0 when nothing is loaded.
@@ -316,10 +491,123 @@ export function handleAddElementHover(ctx: MouseHandlerContext, x: number, y: nu
 }
 
 /**
- * Resolve the active model + storey + a snap-aware world point. Surfaces
- * the same toast errors all add-element entry points share.
+ * Live hover preview for the Split tool. SCOPED TO THE CURRENT
+ * SPLIT TARGET — the slice's `splitTargetModelId` /
+ * `splitTargetExpressId` are set when the user enters Split mode
+ * (via Geometry-card Split button or K shortcut), and they never
+ * change as the cursor moves over other elements. Hovering over a
+ * different wall does NOT switch target; the user must exit Split
+ * (Esc), re-select, and re-enter.
+ *
+ * This is the v2 model — the previous "free-roam, hover anything,
+ * latch new target each frame" approach surfaced way too many
+ * actionable elements at once and made it unclear what would be
+ * cut. Selection-bound matches the rest of the edit-mode UX
+ * (gizmo, geometry card, etc.).
+ *
+ * The cursor still drives the cut POINT — we ray-cast to get a
+ * world point, project that onto the target's axis (linear) or
+ * use cursor XY (slab), and push the result into the slice for
+ * the SplitOverlay to render.
  */
-function resolveAddElementContext(): { modelId: string; storeyId: number } | null {
+export function handleSplitHover(ctx: MouseHandlerContext, x: number, y: number): boolean {
+  const { renderer } = ctx;
+  if (!ctx.measureRaycastPendingRef.current) {
+    ctx.measureRaycastPendingRef.current = true;
+    ctx.measureRaycastFrameRef.current = requestAnimationFrame(() => {
+      ctx.measureRaycastPendingRef.current = false;
+      ctx.measureRaycastFrameRef.current = null;
+
+      const store = useViewerStore.getState();
+      const targetModelId = store.splitTargetModelId;
+      const targetExpressId = store.splitTargetExpressId;
+      if (targetModelId === null || targetExpressId === null) {
+        // Split engaged with no target — clear any stale hover.
+        if (store.splitMode === 'aiming') store.clearSplitHover();
+        return;
+      }
+
+      // Ray-cast to get a world point under the cursor. We don't
+      // care which entity it hit — we use the world point and
+      // project it onto the TARGET's axis. Falls back to the
+      // storey floor so the user can aim at empty space and still
+      // get a sensible cut.
+      const result = renderer.raycastScene(x, y, {
+        hiddenIds: ctx.hiddenEntitiesRef.current,
+        isolatedIds: ctx.isolatedEntitiesRef.current,
+      });
+      // Fallback raycast uses the TARGET's storey floor (not the
+      // global active storey) so the cursor projection stays in
+      // the same Y plane as the element being split.
+      const targetFloorY = resolveSlabFloorY(targetModelId, targetExpressId) ?? undefined;
+      const worldPoint = result?.intersection?.point
+        ?? raycastStoreyFloor(ctx, x, y, targetFloorY);
+      if (!worldPoint) {
+        if (store.splitMode === 'aiming') store.clearSplitHover();
+        return;
+      }
+      const cursorIfc = rendererPointToIfcStoreyLocal(worldPoint);
+
+      // Project onto the target. Try wall (1D), then linear (1D),
+      // then slab (2D — uses the cursor XY directly as a candidate
+      // cut endpoint).
+      const projection =
+        store.readWallSplitProjection(targetModelId, targetExpressId, cursorIfc) ??
+        store.readLinearElementSplitProjection(targetModelId, targetExpressId, cursorIfc);
+      if (projection) {
+        const model = store.models.get(targetModelId);
+        const storeyId = model?.ifcDataStore?.spatialHierarchy?.elementToStorey.get(targetExpressId);
+        const elevation =
+          (storeyId !== undefined
+            ? model?.ifcDataStore?.spatialHierarchy?.storeyElevations?.get(storeyId)
+            : undefined) ?? 0;
+        const [px, py, pz] = projection.cutPoint;
+        const cutRendererFrame: [number, number, number] = [px, pz + elevation, -py];
+        store.setSplitHover(
+          cutRendererFrame,
+          projection.distance,
+          projection.length,
+          projection.cutPoint,
+          projection.axis,
+        );
+        return;
+      }
+      // Slab path — the overlay outlines the polygon + ghost cut
+      // line; the cursor's IFC XY is the candidate endpoint.
+      const slabFootprint = store.readSlabFootprint(targetModelId, targetExpressId);
+      if (slabFootprint) {
+        const [cx, cy] = cursorIfc;
+        const cursorRendererFrame: [number, number, number] = [
+          cx,
+          slabFootprint.storeyElevation,
+          -cy,
+        ];
+        store.setSplitHover(cursorRendererFrame, 0, 0, [cx, cy, 0], null);
+        return;
+      }
+      // Target isn't a splittable shape (rare — gets latched by
+      // the K shortcut / Split button which already checks). Clear.
+      if (store.splitMode === 'aiming') store.clearSplitHover();
+    });
+  }
+  return true;
+}
+
+/**
+ * Resolve the active model + storey + a snap-aware world point.
+ * Surfaces the same toast errors all add-element entry points share.
+ *
+ * `override` lets the caller force a specific (model, storey) pair —
+ * used by smart placement so clicking on an existing element places
+ * the new entity in that element's storey/model rather than the
+ * AddElement panel's currently-selected one. Falls back through the
+ * panel's selector (`addElementStoreyId`) and then the first storey
+ * of the active model when no override is supplied.
+ */
+function resolveAddElementContext(
+  override?: { modelId: string; storeyId: number },
+): { modelId: string; storeyId: number } | null {
+  if (override) return override;
   const state = useViewerStore.getState();
   const modelId = state.addElementModelId ?? resolveActiveModelId();
   if (!modelId) {
@@ -361,8 +649,11 @@ function finishAddElement(
  *   - slab (polygon): N clicks accumulate; Enter / double-click closes
  *     (handled in the keyboard layer; this function only appends)
  */
-async function handleAddElementDrop(point: { x: number; y: number; z: number }): Promise<void> {
-  const ctx = resolveAddElementContext();
+async function handleAddElementDrop(
+  point: { x: number; y: number; z: number },
+  storeyOverride?: { modelId: string; storeyId: number },
+): Promise<void> {
+  const ctx = resolveAddElementContext(storeyOverride);
   if (!ctx) return;
   const { modelId, storeyId } = ctx;