@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/hooks/useSearchIndex.ts

@@ -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/. */
+
+/**
+ * useSearchIndex — lazy builder for the Tier-1 search index.
+ *
+ * Mount once near the root of the viewer shell (currently `SearchInline`,
+ * since it's always rendered once the toolbar is up). The hook watches
+ * the federated `models` map; for each model with a populated
+ * `ifcDataStore` that doesn't yet have a Tier-1 record, it spawns a
+ * chunked build. Models that disappear get their index record dropped.
+ *
+ * Load-perf guarantee: the build NEVER runs during the actual IFC load
+ * because `ifcDataStore` is non-null only after the parser reports the
+ * model is ready (`onSpatialReady` + geometry). The build itself yields
+ * to the event loop every `DEFAULT_CHUNK_SIZE` rows so a 4M-entity
+ * index doesn't hog the main thread.
+ */
+
+import { useEffect, useRef } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+import { useViewerStore } from '@/store';
+import { buildTier1Index } from '@/lib/search/tier1-index';
+
+export function useSearchIndex(): void {
+  const {
+    models,
+    searchIndexes,
+    setSearchIndexRecord,
+    removeSearchIndexRecord,
+    searchFilterSchema,
+    removeFilterSchema,
+  } = useViewerStore(
+    useShallow((s) => ({
+      models: s.models,
+      searchIndexes: s.searchIndexes,
+      setSearchIndexRecord: s.setSearchIndexRecord,
+      removeSearchIndexRecord: s.removeSearchIndexRecord,
+      searchFilterSchema: s.searchFilterSchema,
+      removeFilterSchema: s.removeFilterSchema,
+    })),
+  );
+
+  // One AbortController per in-flight build. Lets us cancel cleanly when a
+  // model is removed mid-build or when the component unmounts.
+  const controllersRef = useRef<Map<string, AbortController>>(new Map());
+
+  useEffect(() => {
+    const controllers = controllersRef.current;
+
+    // Drop records / abort builds for models that no longer exist.
+    for (const modelId of Array.from(searchIndexes.keys())) {
+      if (!models.has(modelId)) {
+        controllers.get(modelId)?.abort();
+        controllers.delete(modelId);
+        removeSearchIndexRecord(modelId);
+      }
+    }
+
+    // Drop the filter-schema cache for departed models too. Stale entries
+    // would surface in the chip dropdowns the next time a model with the
+    // same id loaded (e.g. user reopens a different file as model_0).
+    for (const modelId of Array.from(searchFilterSchema.keys())) {
+      if (!models.has(modelId)) removeFilterSchema(modelId);
+    }
+
+    // Kick off builds for models that are loaded but not yet indexed.
+    for (const [modelId, model] of models) {
+      if (!model.ifcDataStore) continue;
+      const existing = searchIndexes.get(modelId);
+      if (existing && existing.status !== 'pending') continue;
+      if (controllers.has(modelId)) continue;
+
+      const controller = new AbortController();
+      controllers.set(modelId, controller);
+
+      setSearchIndexRecord(modelId, { status: 'building', progress: 0 });
+
+      // Fire-and-forget — the build is cancellable via the controller, and
+      // the completion handlers update the store without needing a ref.
+      void buildTier1Index(modelId, model.ifcDataStore, {
+        signal: controller.signal,
+        onProgress: (done, total) => {
+          if (controller.signal.aborted) return;
+          const progress = total > 0 ? done / total : 1;
+          setSearchIndexRecord(modelId, { status: 'building', progress });
+        },
+      })
+        .then((index) => {
+          if (controller.signal.aborted) return;
+          controllers.delete(modelId);
+          setSearchIndexRecord(modelId, { status: 'ready', index, progress: 1 });
+        })
+        .catch((err: unknown) => {
+          controllers.delete(modelId);
+          if (err instanceof DOMException && err.name === 'AbortError') return;
+          const message = err instanceof Error ? err.message : String(err);
+          // Don't set a 'ready' record — Tier-0 fallback stays live.
+          console.warn(`[useSearchIndex] build failed for ${modelId}:`, message);
+          setSearchIndexRecord(modelId, { status: 'error', error: message });
+        });
+    }
+
+    // On unmount OR next effect pass, abort everything. The effect re-runs
+    // only when `models` / `searchIndexes` changes, so steady-state
+    // incurs no abort — the `controllers.has(modelId)` guard above makes
+    // re-entry idempotent.
+    return () => {
+      // Intentionally NOT aborting everything on every re-render — only
+      // models that went missing got aborted above. The real cleanup is
+      // the component-unmount pass below.
+    };
+  }, [models, searchIndexes, setSearchIndexRecord, removeSearchIndexRecord, searchFilterSchema, removeFilterSchema]);
+
+  // Abort any in-flight builds when the consumer unmounts. Separate effect
+  // so it only fires on unmount (no deps).
+  useEffect(() => {
+    const controllers = controllersRef.current;
+    return () => {
+      for (const c of controllers.values()) c.abort();
+      controllers.clear();
+    };
+  }, []);
+}

package/src/hooks/useViewControls.ts

@@ -43,6 +43,7 @@ function useViewControls({
   const [viewTransform, setViewTransform] = useState({ x: 0, y: 0, scale: 1 });
   const [needsFit, setNeedsFit] = useState(true); // Force fit on first open and axis change
   const prevAxisRef = useRef(sectionPlane.axis); // Track axis changes
+  const prevFlippedRef = useRef(sectionPlane.flipped); // Track flip changes
 
   // Wheel zoom handler
   useEffect(() => {
@@ -158,14 +159,21 @@ function useViewControls({
   // Track axis changes for forced fit-to-view
   const lastFitAxisRef = useRef(sectionPlane.axis);
 
-  // Set needsFit when axis changes
+  // Set needsFit when axis OR flip changes. Flip mirrors the projection's U
+  // axis (see `projectTo2D` in @ifc-lite/drawing-2d), so the polygon bounds
+  // jump from positive X into negative X (or vice versa). Without re-fitting
+  // the new bounds end up off-screen and the user sees "empty 2D panel after
+  // I pressed Flip" — that was the bug behind the recent screenshot report.
   useEffect(() => {
-    if (sectionPlane.axis !== prevAxisRef.current) {
+    const axisChanged = sectionPlane.axis !== prevAxisRef.current;
+    const flipChanged = sectionPlane.flipped !== prevFlippedRef.current;
+    if (axisChanged || flipChanged) {
       prevAxisRef.current = sectionPlane.axis;
-      setNeedsFit(true); // Force fit when axis changes
-      cachedSheetTransformRef.current = null; // Clear cached transform for new axis
+      prevFlippedRef.current = sectionPlane.flipped;
+      setNeedsFit(true);
+      cachedSheetTransformRef.current = null;
     }
-  }, [sectionPlane.axis]);
+  }, [sectionPlane.axis, sectionPlane.flipped]);
 
   // Track previous sheet mode to detect toggle
   const prevSheetEnabledRef = useRef(sheetEnabled);