@ifc-lite/viewer 1.9.0 → 1.11.0

package/src/store/basketVisibleSet.test.ts

@@ -0,0 +1,161 @@
+/* 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/. */
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import { useViewerStore } from './index.js';
+import {
+  getSmartBasketInputFromStore,
+  getBasketSelectionRefsFromStore,
+  getVisibleBasketEntityRefsFromStore,
+  isBasketIsolationActiveFromStore,
+  invalidateVisibleBasketCache,
+} from './basketVisibleSet.js';
+import { entityRefToString } from './types.js';
+
+describe('basketVisibleSet', () => {
+  beforeEach(() => {
+    invalidateVisibleBasketCache();
+    useViewerStore.getState().resetViewerState();
+  });
+
+  describe('source priority', () => {
+    it('returns selection refs when selectedEntitiesSet has items', () => {
+      useViewerStore.setState({
+        selectedEntitiesSet: new Set(['legacy:100', 'legacy:200']),
+      });
+
+      const result = getSmartBasketInputFromStore();
+      assert.strictEqual(result.source, 'selection');
+      assert.strictEqual(result.refs.length, 2);
+      assert.ok(result.refs.some((r) => entityRefToString(r) === 'legacy:100'));
+      assert.ok(result.refs.some((r) => entityRefToString(r) === 'legacy:200'));
+    });
+
+    it('returns hierarchy refs when hierarchyBasketSelection has items and no selection', () => {
+      useViewerStore.setState({
+        selectedEntitiesSet: new Set(),
+        selectedEntity: null,
+        selectedEntityIds: new Set(),
+        hierarchyBasketSelection: new Set(['legacy:300']),
+      });
+
+      const result = getSmartBasketInputFromStore();
+      assert.strictEqual(result.source, 'hierarchy');
+      assert.ok(result.refs.length >= 1);
+    });
+
+    it('returns visible refs when only geometry is available', () => {
+      useViewerStore.setState({
+        selectedEntitiesSet: new Set(),
+        selectedEntity: null,
+        selectedEntityIds: new Set(),
+        hierarchyBasketSelection: new Set(),
+        geometryResult: {
+          meshes: [
+            { expressId: 1, ifcType: 'IfcWall' },
+            { expressId: 2, ifcType: 'IfcSlab' },
+          ],
+        } as any,
+      });
+
+      const result = getSmartBasketInputFromStore();
+      assert.ok(result.source === 'visible' || result.source === 'empty');
+      if (result.source === 'visible') {
+        assert.ok(result.refs.length >= 1);
+      }
+    });
+
+    it('returns empty when no source has refs', () => {
+      useViewerStore.setState({
+        selectedEntitiesSet: new Set(),
+        selectedEntity: null,
+        selectedEntityIds: new Set(),
+        hierarchyBasketSelection: new Set(),
+        geometryResult: null,
+      });
+
+      const result = getSmartBasketInputFromStore();
+      assert.strictEqual(result.source, 'empty');
+      assert.strictEqual(result.refs.length, 0);
+    });
+  });
+
+  describe('isBasketIsolationActiveFromStore', () => {
+    it('returns true when isolated equals basket', () => {
+      useViewerStore.setState({
+        pinboardEntities: new Set(['legacy:100', 'legacy:200']),
+        isolatedEntities: new Set([100, 200]),
+        models: new Map(),
+      });
+
+      assert.strictEqual(isBasketIsolationActiveFromStore(), true);
+    });
+
+    it('returns false when pinboard is empty', () => {
+      useViewerStore.setState({
+        pinboardEntities: new Set(),
+        isolatedEntities: new Set([100]),
+      });
+
+      assert.strictEqual(isBasketIsolationActiveFromStore(), false);
+    });
+
+    it('returns false when isolated is null', () => {
+      useViewerStore.setState({
+        pinboardEntities: new Set(['legacy:100']),
+        isolatedEntities: null,
+      });
+
+      assert.strictEqual(isBasketIsolationActiveFromStore(), false);
+    });
+
+    it('returns false when isolated size differs from basket', () => {
+      useViewerStore.setState({
+        pinboardEntities: new Set(['legacy:100', 'legacy:200']),
+        isolatedEntities: new Set([100]),
+      });
+
+      assert.strictEqual(isBasketIsolationActiveFromStore(), false);
+    });
+  });
+
+  describe('visibility cache', () => {
+    it('invalidateVisibleBasketCache clears cache', () => {
+      useViewerStore.setState({
+        geometryResult: { meshes: [{ expressId: 1, ifcType: 'IfcWall' }] } as any,
+      });
+
+      const first = getVisibleBasketEntityRefsFromStore();
+      invalidateVisibleBasketCache();
+      const second = getVisibleBasketEntityRefsFromStore();
+
+      assert.deepStrictEqual(first, second);
+    });
+
+    it('returns consistent result on repeated calls with same state', () => {
+      useViewerStore.setState({
+        geometryResult: { meshes: [{ expressId: 1, ifcType: 'IfcWall' }] } as any,
+      });
+
+      const a = getVisibleBasketEntityRefsFromStore();
+      const b = getVisibleBasketEntityRefsFromStore();
+
+      assert.deepStrictEqual(a, b);
+    });
+  });
+
+  describe('federation: unresolved globalId in multi-model', () => {
+    it('getBasketSelectionRefsFromStore returns array when models exist', () => {
+      useViewerStore.setState({
+        selectedEntityIds: new Set([99999]),
+        selectedEntitiesSet: new Set(),
+        selectedEntity: null,
+      });
+
+      const refs = getBasketSelectionRefsFromStore();
+      assert.ok(Array.isArray(refs));
+    });
+  });
+});

package/src/store/basketVisibleSet.ts

@@ -0,0 +1,487 @@
+/* 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/. */
+
+import { IfcTypeEnum, type SpatialNode } from '@ifc-lite/data';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { EntityRef } from './types.js';
+import { entityRefToString, stringToEntityRef } from './types.js';
+import { useViewerStore } from './index.js';
+
+type ViewerStateSnapshot = ReturnType<typeof useViewerStore.getState>;
+
+type VisibleCandidate = {
+  globalId: number;
+  modelId: string;
+  expressId: number;
+  ifcType?: string;
+};
+
+type BasketVisibleStats = {
+  visibleCount: number;
+  addCount: number;
+  removeCount: number;
+  basketCount: number;
+};
+
+export type BasketInputSource = 'selection' | 'hierarchy' | 'visible' | 'empty';
+
+type CacheEntry = { key: string; refs: EntityRef[] };
+let _visibleCache: CacheEntry | null = null;
+
+function digestNumberSet(values: Iterable<number>): string {
+  let count = 0;
+  let xor = 0;
+  let sum = 0;
+  for (const v of values) {
+    const n = Number.isFinite(v) ? (v | 0) : 0;
+    count++;
+    xor ^= n;
+    sum = (sum + (n >>> 0)) >>> 0;
+  }
+  return `${count}:${xor >>> 0}:${sum >>> 0}`;
+}
+
+function digestModelEntityMap(map: Map<string, Set<number>>): string {
+  if (map.size === 0) return '0';
+  const parts: string[] = [];
+  for (const [modelId, ids] of map) {
+    parts.push(`${modelId}:${digestNumberSet(ids)}`);
+  }
+  parts.sort();
+  return parts.join('|');
+}
+
+function visibilityFingerprint(state: ViewerStateSnapshot): string {
+  const tv = state.typeVisibility;
+  return [
+    digestNumberSet(state.hiddenEntities),
+    state.isolatedEntities ? digestNumberSet(state.isolatedEntities) : 'none',
+    digestNumberSet(state.lensHiddenIds),
+    digestModelEntityMap(state.hiddenEntitiesByModel),
+    digestModelEntityMap(state.isolatedEntitiesByModel),
+    tv.spaces ? 1 : 0,
+    tv.openings ? 1 : 0,
+    tv.site ? 1 : 0,
+    state.models.size,
+    state.activeBasketViewId ?? 'none',
+  ].join(':');
+}
+
+export function invalidateVisibleBasketCache(): void {
+  _visibleCache = null;
+}
+
+const STOREY_TYPE = 'IfcBuildingStorey';
+const SPATIAL_CONTAINER_TYPES = new Set(['IfcProject', 'IfcSite', 'IfcBuilding']);
+
+function dedupeRefs(refs: EntityRef[]): EntityRef[] {
+  const out: EntityRef[] = [];
+  const seen = new Set<string>();
+  for (const ref of refs) {
+    const key = entityRefToString(ref);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(ref);
+  }
+  return out;
+}
+
+function matchesTypeVisibility(ifcType: string | undefined, typeVisibility: ViewerStateSnapshot['typeVisibility']): boolean {
+  if (ifcType === 'IfcSpace' && !typeVisibility.spaces) return false;
+  if (ifcType === 'IfcOpeningElement' && !typeVisibility.openings) return false;
+  if (ifcType === 'IfcSite' && !typeVisibility.site) return false;
+  return true;
+}
+
+function getDataStoreForModel(state: ViewerStateSnapshot, modelId: string): IfcDataStore | null {
+  if (modelId === 'legacy') {
+    return state.ifcDataStore;
+  }
+  return state.models.get(modelId)?.ifcDataStore ?? null;
+}
+
+function getEntityTypeName(state: ViewerStateSnapshot, ref: EntityRef): string {
+  const dataStore = getDataStoreForModel(state, ref.modelId);
+  if (!dataStore) return '';
+  return dataStore.entities.getTypeName(ref.expressId) || '';
+}
+
+function findSpatialNode(root: SpatialNode, expressId: number): SpatialNode | null {
+  const stack: SpatialNode[] = [root];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    if (current.expressId === expressId) {
+      return current;
+    }
+    for (const child of current.children || []) {
+      stack.push(child);
+    }
+  }
+  return null;
+}
+
+function getContainerElementIds(dataStore: IfcDataStore, containerExpressId: number): number[] {
+  const hierarchy = dataStore.spatialHierarchy;
+  if (!hierarchy?.project) return [];
+
+  const startNode = findSpatialNode(hierarchy.project, containerExpressId);
+  if (!startNode) return [];
+
+  const elementIds: number[] = [];
+  const seen = new Set<number>();
+  const stack: SpatialNode[] = [startNode];
+
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    if (current.type === IfcTypeEnum.IfcBuildingStorey) {
+      const storeyElements = hierarchy.byStorey.get(current.expressId) as number[] | undefined;
+      if (storeyElements) {
+        for (const id of storeyElements) {
+          if (seen.has(id)) continue;
+          seen.add(id);
+          elementIds.push(id);
+        }
+      }
+    }
+    for (const child of current.children || []) {
+      stack.push(child);
+    }
+  }
+
+  return elementIds;
+}
+
+function expandRefToElements(state: ViewerStateSnapshot, ref: EntityRef): EntityRef[] {
+  const dataStore = getDataStoreForModel(state, ref.modelId);
+  if (!dataStore) return [ref];
+
+  const entityType = dataStore.entities.getTypeName(ref.expressId) || '';
+  if (entityType === STOREY_TYPE) {
+    const localIds = dataStore.spatialHierarchy?.byStorey.get(ref.expressId) as number[] | undefined;
+    if (!localIds || localIds.length === 0) return [];
+    return localIds.map((expressId) => ({ modelId: ref.modelId, expressId }));
+  }
+
+  if (SPATIAL_CONTAINER_TYPES.has(entityType)) {
+    const localIds = getContainerElementIds(dataStore, ref.expressId);
+    if (localIds.length === 0) return [];
+    return localIds.map((expressId) => ({ modelId: ref.modelId, expressId }));
+  }
+
+  return [ref];
+}
+
+function toGlobalId(modelId: string, expressId: number, state: ViewerStateSnapshot): number {
+  if (modelId === 'legacy') return expressId;
+  const model = state.models.get(modelId);
+  return expressId + (model?.idOffset ?? 0);
+}
+
+function globalIdToRef(state: ViewerStateSnapshot, globalId: number): EntityRef | null {
+  const resolved = state.resolveGlobalIdFromModels(globalId);
+  if (resolved) {
+    return { modelId: resolved.modelId, expressId: resolved.expressId };
+  }
+
+  if (state.models.size > 0) return null;
+
+  if (state.ifcDataStore) {
+    return { modelId: 'legacy', expressId: globalId };
+  }
+
+  return null;
+}
+
+function basketToGlobalIds(state: ViewerStateSnapshot): Set<number> {
+  const ids = new Set<number>();
+  for (const str of state.pinboardEntities) {
+    const ref = stringToEntityRef(str);
+    ids.add(toGlobalId(ref.modelId, ref.expressId, state));
+  }
+  return ids;
+}
+
+function getSelectedStoreyElementRefs(state: ViewerStateSnapshot): EntityRef[] {
+  if (state.selectedStoreys.size === 0) return [];
+
+  const refs: EntityRef[] = [];
+
+  if (state.models.size > 0) {
+    for (const [modelId, model] of state.models) {
+      const hierarchy = model.ifcDataStore?.spatialHierarchy;
+      if (!hierarchy) continue;
+      const offset = model.idOffset ?? 0;
+      for (const storeyId of state.selectedStoreys) {
+        const storeyElementIds = hierarchy.byStorey.get(storeyId) || hierarchy.byStorey.get(storeyId - offset);
+        if (!storeyElementIds) continue;
+        for (const localId of storeyElementIds) {
+          refs.push({ modelId, expressId: localId });
+        }
+      }
+    }
+  } else if (state.ifcDataStore?.spatialHierarchy) {
+    for (const storeyId of state.selectedStoreys) {
+      const storeyElementIds = state.ifcDataStore.spatialHierarchy.byStorey.get(storeyId);
+      if (!storeyElementIds) continue;
+      for (const id of storeyElementIds) {
+        refs.push({ modelId: 'legacy', expressId: id });
+      }
+    }
+  }
+
+  return dedupeRefs(refs);
+}
+
+function getSelectionBaseRefs(state: ViewerStateSnapshot): EntityRef[] {
+  const refs: EntityRef[] = [];
+
+  if (state.selectedEntitiesSet.size > 0) {
+    for (const str of state.selectedEntitiesSet) {
+      refs.push(stringToEntityRef(str));
+    }
+    return refs;
+  }
+
+  if (state.selectedEntityIds.size > 0) {
+    for (const globalId of state.selectedEntityIds) {
+      const resolved = globalIdToRef(state, globalId);
+      if (resolved) refs.push(resolved);
+    }
+    return refs;
+  }
+
+  if (state.selectedEntities.length > 0) {
+    return [...state.selectedEntities];
+  }
+
+  if (state.selectedEntity) {
+    return [state.selectedEntity];
+  }
+
+  if (state.selectedEntityId !== null) {
+    const resolved = globalIdToRef(state, state.selectedEntityId);
+    if (resolved) refs.push(resolved);
+  }
+
+  return refs;
+}
+
+function getExpandedSelectionRefs(state: ViewerStateSnapshot): EntityRef[] {
+  const baseRefs = getSelectionBaseRefs(state);
+  if (baseRefs.length === 0) return [];
+  return dedupeRefs(baseRefs.flatMap((ref) => expandRefToElements(state, ref)));
+}
+
+function computeStoreyIsolation(state: ViewerStateSnapshot): Set<number> | null {
+  if (state.selectedStoreys.size === 0) return null;
+
+  const ids = new Set<number>();
+
+  if (state.models.size > 0) {
+    for (const [, model] of state.models) {
+      const hierarchy = model.ifcDataStore?.spatialHierarchy;
+      if (!hierarchy) continue;
+      const offset = model.idOffset ?? 0;
+      for (const storeyId of state.selectedStoreys) {
+        const storeyElementIds = hierarchy.byStorey.get(storeyId) || hierarchy.byStorey.get(storeyId - offset);
+        if (!storeyElementIds) continue;
+        for (const localId of storeyElementIds) {
+          ids.add(localId + offset);
+        }
+      }
+    }
+  } else if (state.ifcDataStore?.spatialHierarchy) {
+    for (const storeyId of state.selectedStoreys) {
+      const storeyElementIds = state.ifcDataStore.spatialHierarchy.byStorey.get(storeyId);
+      if (!storeyElementIds) continue;
+      for (const id of storeyElementIds) {
+        ids.add(id);
+      }
+    }
+  }
+
+  return ids.size > 0 ? ids : null;
+}
+
+function collectVisibleCandidates(state: ViewerStateSnapshot): VisibleCandidate[] {
+  const candidates: VisibleCandidate[] = [];
+
+  if (state.models.size > 0) {
+    for (const [modelId, model] of state.models) {
+      if (!model.visible) continue;
+      const offset = model.idOffset ?? 0;
+      for (const mesh of model.geometryResult.meshes) {
+        if (!matchesTypeVisibility(mesh.ifcType, state.typeVisibility)) continue;
+        const globalId = mesh.expressId;
+        candidates.push({
+          globalId,
+          modelId,
+          expressId: globalId - offset,
+          ifcType: mesh.ifcType,
+        });
+      }
+    }
+  } else if (state.geometryResult) {
+    for (const mesh of state.geometryResult.meshes) {
+      if (!matchesTypeVisibility(mesh.ifcType, state.typeVisibility)) continue;
+      candidates.push({
+        globalId: mesh.expressId,
+        modelId: 'legacy',
+        expressId: mesh.expressId,
+        ifcType: mesh.ifcType,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+function getVisibleGlobalIds(state: ViewerStateSnapshot): Set<number> {
+  const candidates = collectVisibleCandidates(state);
+
+  const globalHidden = new Set<number>(state.hiddenEntities);
+  for (const id of state.lensHiddenIds) {
+    globalHidden.add(id);
+  }
+
+  const globalIsolation = state.isolatedEntities ?? computeStoreyIsolation(state);
+
+  const visible = new Set<number>();
+  for (const candidate of candidates) {
+    if (globalIsolation !== null && !globalIsolation.has(candidate.globalId)) continue;
+    if (globalHidden.has(candidate.globalId)) continue;
+
+    const modelHidden = state.hiddenEntitiesByModel.get(candidate.modelId);
+    if (modelHidden?.has(candidate.expressId)) continue;
+
+    const modelIsolated = state.isolatedEntitiesByModel.get(candidate.modelId);
+    if (modelIsolated && !modelIsolated.has(candidate.expressId)) continue;
+
+    visible.add(candidate.globalId);
+  }
+
+  return visible;
+}
+
+export function getVisibleBasketEntityRefsFromStore(): EntityRef[] {
+  const state = useViewerStore.getState();
+  const key = visibilityFingerprint(state);
+  if (_visibleCache?.key === key) return _visibleCache.refs;
+
+  const visibleIds = getVisibleGlobalIds(state);
+  if (visibleIds.size === 0) {
+    _visibleCache = { key, refs: [] };
+    return [];
+  }
+
+  const refs: EntityRef[] = [];
+  for (const globalId of visibleIds) {
+    const resolved = state.resolveGlobalIdFromModels(globalId);
+    if (resolved) {
+      refs.push({ modelId: resolved.modelId, expressId: resolved.expressId });
+    } else {
+      refs.push({ modelId: 'legacy', expressId: globalId });
+    }
+  }
+  const result = dedupeRefs(refs);
+  _visibleCache = { key, refs: result };
+  return result;
+}
+
+/**
+ * Resolve active entity selection into basket refs.
+ * Explicit selected entities are preferred; if empty, selected storeys are expanded.
+ */
+export function getBasketSelectionRefsFromStore(): EntityRef[] {
+  const state = useViewerStore.getState();
+
+  const expandedSelection = getExpandedSelectionRefs(state);
+  if (expandedSelection.length > 0) {
+    return expandedSelection;
+  }
+
+  return getSelectedStoreyElementRefs(state);
+}
+
+/**
+ * Resolve hierarchy-derived basket source.
+ * Priority: explicit hierarchy source snapshot -> selected storeys -> selected hierarchy container/entity.
+ */
+export function getHierarchyBasketEntityRefsFromStore(): EntityRef[] {
+  const state = useViewerStore.getState();
+
+  if (state.hierarchyBasketSelection.size > 0) {
+    const hierarchyRefs = Array.from(state.hierarchyBasketSelection).map((key) => stringToEntityRef(key));
+    const expandedHierarchy = dedupeRefs(hierarchyRefs.flatMap((ref) => expandRefToElements(state, ref)));
+    if (expandedHierarchy.length > 0) {
+      return expandedHierarchy;
+    }
+  }
+
+  const storeyRefs = getSelectedStoreyElementRefs(state);
+  if (storeyRefs.length > 0) {
+    return storeyRefs;
+  }
+
+  const selectionRefs = getExpandedSelectionRefs(state);
+  if (selectionRefs.length > 0) {
+    const hasContainer = selectionRefs.some((ref) => {
+      const typeName = getEntityTypeName(state, ref);
+      return typeName === STOREY_TYPE || SPATIAL_CONTAINER_TYPES.has(typeName);
+    });
+    if (hasContainer || getSelectionBaseRefs(state).length > 0) {
+      return selectionRefs;
+    }
+  }
+
+  return [];
+}
+
+export function getSmartBasketInputFromStore(): { refs: EntityRef[]; source: BasketInputSource } {
+  const selectionRefs = getBasketSelectionRefsFromStore();
+  if (selectionRefs.length > 0) {
+    return { refs: selectionRefs, source: 'selection' };
+  }
+
+  const hierarchyRefs = getHierarchyBasketEntityRefsFromStore();
+  if (hierarchyRefs.length > 0) {
+    return { refs: hierarchyRefs, source: 'hierarchy' };
+  }
+
+  const visibleRefs = getVisibleBasketEntityRefsFromStore();
+  if (visibleRefs.length > 0) {
+    return { refs: visibleRefs, source: 'visible' };
+  }
+
+  return { refs: [], source: 'empty' };
+}
+
+export function isBasketIsolationActiveFromStore(): boolean {
+  const state = useViewerStore.getState();
+  if (state.pinboardEntities.size === 0 || state.isolatedEntities === null) return false;
+
+  const basketIds = basketToGlobalIds(state);
+  if (basketIds.size !== state.isolatedEntities.size) return false;
+  for (const id of basketIds) {
+    if (!state.isolatedEntities.has(id)) return false;
+  }
+  return true;
+}
+
+export function getVisibleBasketStatsFromStore(): BasketVisibleStats {
+  const state = useViewerStore.getState();
+  const visibleRefs = getVisibleBasketEntityRefsFromStore();
+  const visibleKeys = new Set<string>(visibleRefs.map(entityRefToString));
+  let removeCount = 0;
+  for (const key of state.pinboardEntities) {
+    if (visibleKeys.has(key)) removeCount++;
+  }
+
+  return {
+    visibleCount: visibleKeys.size,
+    addCount: Math.max(0, visibleKeys.size - removeCount),
+    removeCount,
+    basketCount: state.pinboardEntities.size,
+  };
+}

package/src/store/constants.ts

@@ -66,6 +66,26 @@ export const UI_DEFAULTS = {
   THEME: getInitialTheme(),
   /** Default hover tooltips state */
   HOVER_TOOLTIPS_ENABLED: false,
+  /** Global visual enhancement kill switch */
+  VISUAL_ENHANCEMENTS_ENABLED: true,
+  /** Edge contrast enhancement default */
+  EDGE_CONTRAST_ENABLED: true,
+  /** Edge contrast intensity */
+  EDGE_CONTRAST_INTENSITY: 1.2,
+  /** Contact shading quality preset */
+  CONTACT_SHADING_QUALITY: 'low' as const,
+  /** Contact shading intensity */
+  CONTACT_SHADING_INTENSITY: 0.35,
+  /** Contact shading radius in pixels */
+  CONTACT_SHADING_RADIUS: 1.5,
+  /** Separation-line overlay default */
+  SEPARATION_LINES_ENABLED: true,
+  /** Separation-line quality preset */
+  SEPARATION_LINES_QUALITY: 'low' as const,
+  /** Separation-line intensity */
+  SEPARATION_LINES_INTENSITY: 0.38,
+  /** Separation-line radius in pixels */
+  SEPARATION_LINES_RADIUS: 1.0,
 } as const;
 
 // ============================================================================

package/src/store/homeView.ts

@@ -0,0 +1,21 @@
+/* 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/. */
+
+import { useViewerStore } from './index.js';
+
+export function resetVisibilityForHomeFromStore(): void {
+  const state = useViewerStore.getState();
+  state.showAllInAllModels();
+  state.clearStoreySelection();
+  state.clearHierarchyBasketSelection();
+  state.clearEntitySelection();
+  state.clearBasket();
+  useViewerStore.setState({ activeBasketViewId: null });
+}
+
+export function goHomeFromStore(): void {
+  resetVisibilityForHomeFromStore();
+  const state = useViewerStore.getState();
+  state.cameraCallbacks.home?.();
+}