@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/lib/search/saved-filters.ts

@@ -0,0 +1,154 @@
+/* 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/. */
+
+/**
+ * Saved filter presets — localStorage-backed catalog of named
+ * `FilterRule[]` snapshots. Mirrors the `filter_presets` table from
+ * the Tauri-side `filter.rs` engine: each preset stores a name, the
+ * rule list, and the AND/OR combinator. Presets are surfaced in the
+ * builder toolbar as a dropdown; clicking one replaces the current
+ * filter state.
+ *
+ * Pure module — safe to import from tests (stubs storage when
+ * `window.localStorage` is unavailable). Names are trimmed and
+ * deduplicated by case-insensitive match, so re-saving a preset under
+ * the same name overwrites it (matching the Rust ON CONFLICT behaviour).
+ */
+
+import {
+  parseFilterRules,
+  type Combinator,
+  type FilterRule,
+} from './filter-rules.js';
+
+const STORAGE_KEY = 'ifc-lite:search:saved-filters';
+const MAX_ENTRIES = 50;
+const MAX_NAME_LEN = 80;
+
+export interface SavedFilterPreset {
+  name: string;
+  combinator: Combinator;
+  rules: FilterRule[];
+  /** Wall-clock ms when this preset was last written. */
+  updatedAt: number;
+}
+
+interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+function safeStorage(): StorageLike | null {
+  try {
+    const ls = (globalThis as typeof globalThis & { localStorage?: StorageLike }).localStorage;
+    if (!ls) return null;
+    const probe = `${STORAGE_KEY}:__probe__`;
+    ls.setItem(probe, '1');
+    ls.removeItem(probe);
+    return ls;
+  } catch {
+    return null;
+  }
+}
+
+function readRaw(): SavedFilterPreset[] {
+  const ls = safeStorage();
+  if (!ls) return [];
+  const raw = ls.getItem(STORAGE_KEY);
+  if (!raw) return [];
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    const out: SavedFilterPreset[] = [];
+    for (const item of parsed) {
+      if (typeof item !== 'object' || item === null) continue;
+      const o = item as Record<string, unknown>;
+      const name = typeof o.name === 'string' ? o.name.trim() : '';
+      if (!name || name.length > MAX_NAME_LEN) continue;
+      const combinator: Combinator = o.combinator === 'OR' ? 'OR' : 'AND';
+      const rules = parseFilterRules(o.rules);
+      const updatedAt = typeof o.updatedAt === 'number' ? o.updatedAt : Date.now();
+      out.push({ name, combinator, rules, updatedAt });
+    }
+    return out;
+  } catch {
+    ls.removeItem(STORAGE_KEY);
+    return [];
+  }
+}
+
+function writeRaw(list: SavedFilterPreset[]): void {
+  const ls = safeStorage();
+  if (!ls) return;
+  try {
+    ls.setItem(STORAGE_KEY, JSON.stringify(list));
+  } catch {
+    // Quota exceeded — swallow; the next save attempt may succeed.
+  }
+}
+
+/** All saved presets, sorted by name (A→Z) for stable UI ordering. */
+export function loadSavedFilters(): SavedFilterPreset[] {
+  const list = readRaw();
+  list.sort((a, b) => a.name.localeCompare(b.name));
+  return list;
+}
+
+/**
+ * Insert or update a preset by case-insensitive name match. Returns the
+ * resulting full catalog (sorted) so callers can refresh UI without a
+ * second read.
+ */
+export function saveFilter(
+  name: string,
+  combinator: Combinator,
+  rules: readonly FilterRule[],
+): SavedFilterPreset[] {
+  const trimmed = name.trim();
+  if (!trimmed || trimmed.length > MAX_NAME_LEN) return loadSavedFilters();
+
+  const existing = readRaw();
+  const idx = existing.findIndex((p) => p.name.toLowerCase() === trimmed.toLowerCase());
+  const preset: SavedFilterPreset = {
+    name: trimmed,
+    combinator,
+    // Defensive copy so callers can mutate their own array without
+    // corrupting the saved list (they share references via parseFilterRules
+    // on read, but write should snapshot).
+    rules: rules.map((r) => ({ ...r }) as FilterRule),
+    updatedAt: Date.now(),
+  };
+  if (idx >= 0) existing[idx] = preset;
+  else existing.unshift(preset);
+
+  // Cap on size — newest survive when capacity overflows.
+  const sortedByRecency = existing
+    .slice()
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+    .slice(0, MAX_ENTRIES);
+  writeRaw(sortedByRecency);
+
+  return loadSavedFilters();
+}
+
+/** Delete a preset by exact (case-insensitive) name. Returns the new list. */
+export function deleteSavedFilter(name: string): SavedFilterPreset[] {
+  const trimmed = name.trim().toLowerCase();
+  if (!trimmed) return loadSavedFilters();
+  const existing = readRaw();
+  const next = existing.filter((p) => p.name.toLowerCase() !== trimmed);
+  if (next.length === existing.length) return loadSavedFilters();
+  writeRaw(next);
+  return loadSavedFilters();
+}
+
+/** Wipe the entire catalog. */
+export function clearSavedFilters(): void {
+  const ls = safeStorage();
+  if (!ls) return;
+  ls.removeItem(STORAGE_KEY);
+}
+
+export const __internal = { STORAGE_KEY, MAX_ENTRIES, MAX_NAME_LEN };

package/src/lib/search/tier0-scan.test.ts

@@ -0,0 +1,196 @@
+/* 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 } from 'node:test';
+import assert from 'node:assert';
+import { StringTable, EntityTableBuilder } from '@ifc-lite/data';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import { runTier0Scan, type ScanModel } from './tier0-scan.js';
+
+/**
+ * Build a minimal IfcDataStore-shaped object whose `entities` table is real
+ * (via @ifc-lite/data EntityTableBuilder) and whose remaining slots are the
+ * smallest stubs the scanner accepts. Tier-0 only touches `entities` +
+ * `strings`; everything else can be empty.
+ */
+function buildStore(rows: Array<{
+  expressId: number;
+  type: string;
+  globalId: string;
+  name: string;
+  description?: string;
+  objectType?: string;
+}>): IfcDataStore {
+  const strings = new StringTable();
+  const builder = new EntityTableBuilder(rows.length, strings);
+  for (const r of rows) {
+    builder.add(
+      r.expressId,
+      r.type,
+      r.globalId,
+      r.name,
+      r.description ?? '',
+      r.objectType ?? '',
+      false,
+      false,
+    );
+  }
+  const entities = builder.build();
+
+  const store = {
+    fileSize: 0,
+    schemaVersion: 'IFC4',
+    entityCount: rows.length,
+    parseTime: 0,
+    source: new Uint8Array(0),
+    entityIndex: { byId: { ranges: new Uint32Array(0), index: new Map() }, byType: new Map() },
+    strings,
+    entities,
+    properties: { count: 0 },
+    quantities: { count: 0 },
+    relationships: { count: 0 },
+  } as unknown as IfcDataStore;
+
+  return store;
+}
+
+function modelOf(id: string, store: IfcDataStore): ScanModel {
+  return { id, ifcDataStore: store };
+}
+
+describe('runTier0Scan', () => {
+  const baseRows = [
+    { expressId: 10, type: 'IFCWALL', globalId: '1abcdefghijklmnopqrstu', name: 'Wall-EXT-001' },
+    { expressId: 20, type: 'IFCWALL', globalId: '2abcdefghijklmnopqrstu', name: 'Wall-INT-002' },
+    { expressId: 30, type: 'IFCDOOR', globalId: '3abcdefghijklmnopqrstu', name: 'Door-A-201' },
+    { expressId: 40, type: 'IFCWINDOW', globalId: '4abcdefghijklmnopqrstu', name: 'WIN-North-1', description: 'fire-rated' },
+    { expressId: 50, type: 'IFCSLAB', globalId: '5abcdefghijklmnopqrstu', name: '', objectType: 'SLAB-FLOOR' },
+  ];
+
+  it('returns nothing for empty/whitespace queries', () => {
+    const store = buildStore(baseRows);
+    assert.deepStrictEqual(runTier0Scan([modelOf('m', store)], ''), []);
+    assert.deepStrictEqual(runTier0Scan([modelOf('m', store)], '   '), []);
+  });
+
+  it('handles models with no IfcDataStore', () => {
+    const results = runTier0Scan([{ id: 'm', ifcDataStore: null }], 'wall');
+    assert.deepStrictEqual(results, []);
+  });
+
+  it('matches by name substring (case-insensitive)', () => {
+    const store = buildStore(baseRows);
+    const results = runTier0Scan([modelOf('m', store)], 'wall');
+    const ids = results.map((r) => r.expressId).sort((a, b) => a - b);
+    assert.deepStrictEqual(ids, [10, 20]);
+    for (const r of results) {
+      assert.strictEqual(r.matchField, 'name');
+    }
+  });
+
+  it('exact GUID match wins (highest score, GUID fast path)', () => {
+    const store = buildStore(baseRows);
+    const results = runTier0Scan([modelOf('m', store)], '3abcdefghijklmnopqrstu');
+    assert.ok(results.length >= 1);
+    assert.strictEqual(results[0].expressId, 30);
+    assert.strictEqual(results[0].matchField, 'globalId');
+    // GUID exact (1000) should outrank everything else.
+    assert.ok(results[0].score >= 1000);
+  });
+
+  it('GUID fast path does not double-emit a row that the linear scan also returns', () => {
+    const store = buildStore(baseRows);
+    const results = runTier0Scan([modelOf('m', store)], '3abcdefghijklmnopqrstu');
+    const seen = new Set<string>();
+    for (const r of results) {
+      const key = `${r.modelId}:${r.expressId}`;
+      assert.ok(!seen.has(key), `duplicate row for ${key}`);
+      seen.add(key);
+    }
+  });
+
+  it('matches by IFC type prefix and exact', () => {
+    const store = buildStore(baseRows);
+    const exact = runTier0Scan([modelOf('m', store)], 'ifcwall');
+    // Two walls match by type.
+    assert.strictEqual(exact.filter((r) => r.matchField === 'type').length, 2);
+
+    const prefix = runTier0Scan([modelOf('m', store)], 'ifcwin');
+    const winner = prefix.find((r) => r.expressId === 40);
+    assert.ok(winner);
+    assert.strictEqual(winner!.matchField, 'type');
+  });
+
+  it('keeps the MAX score across fields (a substring name hit can be outranked by a type-exact hit)', () => {
+    // The entity's name contains "wall" (NAME_SUBSTR=40) AND its type
+    // is exactly "IfcWall" (TYPE_EXACT=80). The match should win on
+    // type, not be capped at name. Without this, multi-model results
+    // where one model used Tier-1 (max-across-fields) and another
+    // used Tier-0 (short-circuit) would rank the same logical match
+    // differently — breaking the comparable-ordering guarantee.
+    const store = buildStore([
+      { expressId: 10, type: 'IFCWALL', globalId: '1abcdefghijklmnopqrstu', name: 'metal-wall-cladding' },
+    ]);
+    const out = runTier0Scan([modelOf('m', store)], 'ifcwall');
+    assert.strictEqual(out.length, 1);
+    assert.strictEqual(out[0].matchField, 'type', 'type should outrank a substring name hit');
+    // 80 (TYPE_EXACT) ≫ 40 (NAME_SUBSTR).
+    assert.strictEqual(out[0].score, 80);
+  });
+
+  it('matches by description and objectType when name/type miss', () => {
+    const store = buildStore(baseRows);
+
+    const desc = runTier0Scan([modelOf('m', store)], 'fire-rated');
+    assert.strictEqual(desc.length, 1);
+    assert.strictEqual(desc[0].expressId, 40);
+    assert.strictEqual(desc[0].matchField, 'description');
+
+    const obj = runTier0Scan([modelOf('m', store)], 'slab-floor');
+    assert.strictEqual(obj.length, 1);
+    assert.strictEqual(obj[0].expressId, 50);
+    assert.strictEqual(obj[0].matchField, 'objectType');
+  });
+
+  it('respects the result limit and orders by descending score', () => {
+    const many = Array.from({ length: 20 }, (_, i) => ({
+      expressId: 100 + i,
+      type: 'IFCWALL',
+      globalId: `g${String(i).padStart(21, 'x')}`,
+      name: i === 0 ? 'wall' : `wall-${i}`,
+    }));
+    const store = buildStore(many);
+    const results = runTier0Scan([modelOf('m', store)], 'wall', { limit: 5 });
+    assert.strictEqual(results.length, 5);
+    // Exact-match row 'wall' must come first (NAME_EXACT > NAME_PREFIX).
+    assert.strictEqual(results[0].name, 'wall');
+    for (let i = 1; i < results.length; i++) {
+      assert.ok(results[i - 1].score >= results[i].score, 'score must be non-increasing');
+    }
+  });
+
+  it('searches across multiple federated models and tags results with modelId', () => {
+    const a = buildStore([
+      { expressId: 1, type: 'IFCWALL', globalId: 'aaaaaaaaaaaaaaaaaaaaaa', name: 'Lobby-Wall' },
+    ]);
+    const b = buildStore([
+      { expressId: 2, type: 'IFCWALL', globalId: 'bbbbbbbbbbbbbbbbbbbbbb', name: 'Tower-Wall' },
+    ]);
+    const results = runTier0Scan([modelOf('A', a), modelOf('B', b)], 'wall');
+    const tagged = results.map((r) => `${r.modelId}:${r.expressId}`).sort();
+    assert.deepStrictEqual(tagged, ['A:1', 'B:2']);
+  });
+
+  it('skips rows where every searchable string slot is empty (perf shortcut)', () => {
+    // Row 60 has no name/globalId/description/objectType — must NOT appear
+    // in any text search (and must not crash the scanner).
+    const rows = [
+      ...baseRows,
+      { expressId: 60, type: 'IFCWALL', globalId: '', name: '' },
+    ];
+    const store = buildStore(rows);
+    const results = runTier0Scan([modelOf('m', store)], 'wall');
+    assert.ok(!results.some((r) => r.expressId === 60));
+  });
+});

package/src/lib/search/tier0-scan.ts

@@ -0,0 +1,237 @@
+/* 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/. */
+
+/**
+ * Tier-0 search scan: linear pass over EntityTable columns that are
+ * ALREADY POPULATED during normal IFC parsing. Adds zero work to the
+ * load hot path — `name` and `globalId` are batch-extracted by the
+ * parser for geometry entities + types via `batchExtractGlobalIdAndName`,
+ * and we read them straight out of the columnar TypedArrays.
+ *
+ * Crucially: this never calls `extractEntityAttributesOnDemand` (see
+ * AGENTS.md §2). Empty-string rows are skipped via O(1) checks against
+ * the StringTable index 0 (which is the canonical empty string).
+ *
+ * Tier-1 (worker-built inverted index) and Tier-3 (DuckDB SQL) layer
+ * on top of the same `SearchResult` shape in later phases.
+ */
+
+import type { IfcDataStore } from '@ifc-lite/parser';
+
+/** A federated model carries its IFC store + an offset into the global ID space. */
+export interface ScanModel {
+  id: string;
+  ifcDataStore: IfcDataStore | null;
+}
+
+export type MatchField = 'globalId' | 'name' | 'type' | 'description' | 'objectType';
+
+export interface SearchResult {
+  modelId: string;
+  /** Local express ID inside the source model — federation conversion happens in the UI layer. */
+  expressId: number;
+  typeName: string;
+  name: string;
+  globalId: string;
+  description: string;
+  objectType: string;
+  /** Field that produced the highest score for this entity. */
+  matchField: MatchField;
+  score: number;
+}
+
+export interface ScanOptions {
+  /** Maximum results returned (sorted by descending score). Default 50. */
+  limit?: number;
+  /** If set, abort after this many entities scanned per model (perf safety). */
+  maxScanPerModel?: number;
+}
+
+const DEFAULT_LIMIT = 50;
+
+/** Scoring weights — higher = better. Stable enough that downstream UI can compare. */
+const SCORE = {
+  GUID_EXACT: 1000,
+  NAME_EXACT: 500,
+  NAME_PREFIX: 100,
+  TYPE_EXACT: 80,
+  TYPE_PREFIX: 60,
+  NAME_SUBSTR: 40,
+  OBJECTTYPE_SUBSTR: 20,
+  DESCRIPTION_SUBSTR: 10,
+} as const;
+
+/**
+ * Run a Tier-0 search across one or more models.
+ *
+ * Returns up to `limit` results sorted by descending score, then by
+ * (modelId, expressId) for stable ordering. Empty/whitespace queries
+ * return an empty array — the caller should not even open the popover.
+ */
+export function runTier0Scan(
+  models: readonly ScanModel[],
+  query: string,
+  options: ScanOptions = {},
+): SearchResult[] {
+  const trimmed = query.trim();
+  if (trimmed.length < 1) return [];
+
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  const needle = trimmed.toLowerCase();
+
+  // GUID exact-match fast path — IFC GlobalIds are 22-char base64-like strings.
+  // We test the trimmed (case-sensitive) form because GUIDs are case-sensitive.
+  const looksLikeGuid = trimmed.length === 22 && /^[A-Za-z0-9_$]{22}$/.test(trimmed);
+
+  const collected: SearchResult[] = [];
+
+  for (const model of models) {
+    const store = model.ifcDataStore;
+    if (!store) continue;
+    const table = store.entities;
+    if (!table || table.count === 0) continue;
+
+    // GUID fast path: O(1) lookup, push and continue (still scan others
+    // for additional substring matches, but skip the row-level pass for
+    // this particular GUID).
+    if (looksLikeGuid) {
+      const exactExpressId = table.getExpressIdByGlobalId(trimmed);
+      if (exactExpressId > 0) {
+        collected.push({
+          modelId: model.id,
+          expressId: exactExpressId,
+          typeName: table.getTypeName(exactExpressId),
+          name: table.getName(exactExpressId),
+          globalId: trimmed,
+          description: table.getDescription(exactExpressId),
+          objectType: table.getObjectType(exactExpressId),
+          matchField: 'globalId',
+          score: SCORE.GUID_EXACT,
+        });
+      }
+    }
+
+    scanModel(model.id, store, needle, options.maxScanPerModel, collected);
+  }
+
+  // Stable sort: score desc, then modelId asc, then expressId asc.
+  collected.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (a.modelId !== b.modelId) return a.modelId < b.modelId ? -1 : 1;
+    return a.expressId - b.expressId;
+  });
+
+  // Dedupe — the GUID fast path may have added a row that the linear pass
+  // also matched. Keep the highest-scoring instance per (modelId, expressId).
+  const seen = new Set<string>();
+  const out: SearchResult[] = [];
+  for (const r of collected) {
+    const key = `${r.modelId}:${r.expressId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(r);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function scanModel(
+  modelId: string,
+  store: IfcDataStore,
+  needle: string,
+  maxScan: number | undefined,
+  out: SearchResult[],
+): void {
+  const table = store.entities;
+  const strings = store.strings;
+  const count = table.count;
+  const cap = maxScan != null ? Math.min(count, maxScan) : count;
+
+  // Direct typed-array references — avoids per-row method-call overhead.
+  const expressId = table.expressId;
+  const nameIdx = table.name;
+  const globalIdIdx = table.globalId;
+  const descriptionIdx = table.description;
+  const objectTypeIdx = table.objectType;
+
+  for (let i = 0; i < cap; i++) {
+    // Fast skip: rows where every searchable string slot is the empty
+    // string (StringTable index 0) — common for non-geometry entities
+    // that the parser never batch-extracted. This keeps 4M-entity scans
+    // O(populated rows) in practice.
+    const nIdx = nameIdx[i];
+    const gIdx = globalIdIdx[i];
+    const dIdx = descriptionIdx[i];
+    const oIdx = objectTypeIdx[i];
+    if (nIdx === 0 && gIdx === 0 && dIdx === 0 && oIdx === 0) continue;
+
+    const name = nIdx !== 0 ? strings.get(nIdx) : '';
+    const globalId = gIdx !== 0 ? strings.get(gIdx) : '';
+
+    // Score every applicable field and keep the max — Tier-1's
+    // `scoreEntry` does the same, and the result-merge code in the UI
+    // depends on Tier-0 / Tier-1 producing comparable orderings. The
+    // previous short-circuit (skip type once name produced any score)
+    // ranked an entity that hits NAME_SUBSTR (40) below an entity that
+    // would have hit TYPE_EXACT (80) on its name field, so the same
+    // logical match scored differently across paths.
+    let score = 0;
+    let matchField: MatchField = 'name';
+    const bump = (s: number, mf: MatchField): void => {
+      if (s > score) {
+        score = s;
+        matchField = mf;
+      }
+    };
+
+    if (name) {
+      const nameLower = name.toLowerCase();
+      if (nameLower === needle) bump(SCORE.NAME_EXACT, 'name');
+      else if (nameLower.startsWith(needle)) bump(SCORE.NAME_PREFIX, 'name');
+      else if (nameLower.includes(needle)) bump(SCORE.NAME_SUBSTR, 'name');
+    }
+
+    {
+      // Type lookup uses the resolved type-name accessor (handles enum
+      // → PascalCase conversion). Cheap but a method call, so it stays
+      // inside the per-row loop only because it can outrank NAME_SUBSTR.
+      const typeName = table.getTypeName(expressId[i]);
+      const typeLower = typeName.toLowerCase();
+      if (typeLower === needle) bump(SCORE.TYPE_EXACT, 'type');
+      else if (typeLower.startsWith(needle)) bump(SCORE.TYPE_PREFIX, 'type');
+    }
+
+    let objectType = '';
+    if (oIdx !== 0) {
+      objectType = strings.get(oIdx);
+      if (objectType.toLowerCase().includes(needle)) {
+        bump(SCORE.OBJECTTYPE_SUBSTR, 'objectType');
+      }
+    }
+
+    let description = '';
+    if (dIdx !== 0) {
+      description = strings.get(dIdx);
+      if (description.toLowerCase().includes(needle)) {
+        bump(SCORE.DESCRIPTION_SUBSTR, 'description');
+      }
+    }
+
+    if (score === 0) continue;
+
+    // Resolve remaining display fields lazily so non-matches stay cheap.
+    const id = expressId[i];
+    out.push({
+      modelId,
+      expressId: id,
+      typeName: table.getTypeName(id),
+      name,
+      globalId,
+      description: description || (dIdx !== 0 ? strings.get(dIdx) : ''),
+      objectType: objectType || (oIdx !== 0 ? strings.get(oIdx) : ''),
+      matchField,
+      score,
+    });
+  }
+}