@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/lib/search/filter-rules.test.ts

@@ -0,0 +1,119 @@
+/* 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 {
+  setOpMatches,
+  stringOpMatches,
+  numericOpMatches,
+  valueOpMatches,
+  combineRuleResults,
+  isFilterRule,
+  parseFilterRules,
+  Rule,
+} from './filter-rules.js';
+
+describe('setOpMatches', () => {
+  it('matches case-insensitively for "in"', () => {
+    assert.strictEqual(setOpMatches('in', 'IfcWall', ['ifcwall', 'IfcDoor']), true);
+    assert.strictEqual(setOpMatches('in', 'IfcSlab', ['IfcWall', 'IfcDoor']), false);
+  });
+  it('inverts for "notIn"', () => {
+    assert.strictEqual(setOpMatches('notIn', 'IfcSlab', ['IfcWall']), true);
+    assert.strictEqual(setOpMatches('notIn', 'IfcWall', ['IfcWall']), false);
+  });
+  it('treats an empty values list as no match for "in"', () => {
+    assert.strictEqual(setOpMatches('in', 'IfcWall', []), false);
+    assert.strictEqual(setOpMatches('notIn', 'IfcWall', []), true);
+  });
+});
+
+describe('stringOpMatches', () => {
+  it('eq / ne are case-insensitive', () => {
+    assert.strictEqual(stringOpMatches('eq', 'Foo', 'FOO'), true);
+    assert.strictEqual(stringOpMatches('ne', 'Foo', 'bar'), true);
+    assert.strictEqual(stringOpMatches('ne', 'Foo', 'foo'), false);
+  });
+  it('contains / notContains ignore case', () => {
+    assert.strictEqual(stringOpMatches('contains', 'Wall-EXT', 'ext'), true);
+    assert.strictEqual(stringOpMatches('notContains', 'Wall-EXT', 'int'), true);
+  });
+  it('startsWith ignores case', () => {
+    assert.strictEqual(stringOpMatches('startsWith', 'IfcWallStandardCase', 'ifcwall'), true);
+    assert.strictEqual(stringOpMatches('startsWith', 'IfcWall', 'wall'), false);
+  });
+});
+
+describe('numericOpMatches', () => {
+  it('eq uses 1e-9 epsilon (matches Rust impl)', () => {
+    assert.strictEqual(numericOpMatches('eq', 1.0 + 1e-12, 1.0), true);
+    assert.strictEqual(numericOpMatches('eq', 1.0 + 1e-7, 1.0), false);
+  });
+  it('gt/gte/lt/lte are exact', () => {
+    assert.strictEqual(numericOpMatches('gt', 5, 5), false);
+    assert.strictEqual(numericOpMatches('gte', 5, 5), true);
+    assert.strictEqual(numericOpMatches('lt', 5, 5), false);
+    assert.strictEqual(numericOpMatches('lte', 5, 5), true);
+  });
+});
+
+describe('valueOpMatches', () => {
+  it('isSet / isNotSet check string presence', () => {
+    assert.strictEqual(valueOpMatches('isSet', 'foo', ''), true);
+    assert.strictEqual(valueOpMatches('isSet', '', ''), false);
+    assert.strictEqual(valueOpMatches('isNotSet', '', ''), true);
+  });
+  it('eq / ne / contains pass through case-insensitive', () => {
+    assert.strictEqual(valueOpMatches('eq', 'Concrete', 'concrete'), true);
+    assert.strictEqual(valueOpMatches('contains', 'C30/37', '30'), true);
+    assert.strictEqual(valueOpMatches('notContains', 'C30/37', '50'), true);
+  });
+  it('numeric ops parse both sides as floats; NaN parses fail closed', () => {
+    assert.strictEqual(valueOpMatches('gt', '12.5', '10'), true);
+    assert.strictEqual(valueOpMatches('lt', '12.5', '10'), false);
+    assert.strictEqual(valueOpMatches('gt', 'abc', '10'), false);
+    assert.strictEqual(valueOpMatches('gt', '12', 'abc'), false);
+  });
+});
+
+describe('combineRuleResults', () => {
+  it('AND requires all true', () => {
+    assert.strictEqual(combineRuleResults('AND', [true, true]), true);
+    assert.strictEqual(combineRuleResults('AND', [true, false]), false);
+  });
+  it('OR requires any true', () => {
+    assert.strictEqual(combineRuleResults('OR', [false, true]), true);
+    assert.strictEqual(combineRuleResults('OR', [false, false]), false);
+  });
+  it('returns false on an empty list (no rule = no match)', () => {
+    assert.strictEqual(combineRuleResults('AND', []), false);
+    assert.strictEqual(combineRuleResults('OR', []), false);
+  });
+});
+
+describe('isFilterRule / parseFilterRules', () => {
+  it('accepts every known kind', () => {
+    assert.strictEqual(isFilterRule(Rule.storey(['L1'])), true);
+    assert.strictEqual(isFilterRule(Rule.ifcType(['IfcWall'])), true);
+    assert.strictEqual(isFilterRule(Rule.predefinedType(['SOLID'])), true);
+    assert.strictEqual(isFilterRule(Rule.name('contains', 'wall')), true);
+    assert.strictEqual(isFilterRule(Rule.property('Pset_X', 'P', 'eq', 'v')), true);
+    assert.strictEqual(isFilterRule(Rule.quantity('Qto_X', 'Q', 'gt', 1)), true);
+  });
+  it('rejects unknown kinds and non-objects', () => {
+    assert.strictEqual(isFilterRule({ kind: 'bogus' }), false);
+    assert.strictEqual(isFilterRule(null), false);
+    assert.strictEqual(isFilterRule('storey'), false);
+  });
+  it('parseFilterRules drops invalid entries', () => {
+    const parsed = parseFilterRules([
+      { kind: 'ifcType', values: ['IfcWall'], op: 'in' },
+      { kind: 'unknown' },
+      'nope',
+    ]);
+    assert.strictEqual(parsed.length, 1);
+    assert.strictEqual(parsed[0].kind, 'ifcType');
+  });
+});

package/src/lib/search/filter-rules.ts

@@ -0,0 +1,198 @@
+/* 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/. */
+
+/**
+ * Unified filter rule taxonomy.
+ *
+ * Ported from the Tauri-side `filter.rs` engine and consumed by the
+ * in-memory path-B runtime evaluator (`filter-evaluate.ts`). The
+ * discriminated-union shape lets the chip UI serialise any rule as a
+ * JSON object with a `"kind"` discriminator, mirroring serde's tagged
+ * enum encoding. We use `kind` rather than `type` because `type`
+ * collides with the IFC `type` attribute name on element rows.
+ */
+
+// ── Operator enums ────────────────────────────────────────────────────────────
+
+/** Set-membership: storey, ifcType, predefinedType. */
+export type SetOp = 'in' | 'notIn';
+
+/** String comparisons (Name rule). */
+export type StringOp = 'eq' | 'ne' | 'contains' | 'notContains' | 'startsWith';
+
+/** Numeric comparisons (Quantity rule). */
+export type NumericOp = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
+
+/** Mixed string+numeric+presence ops for Property values. */
+export type ValueOp =
+  | 'eq'
+  | 'ne'
+  | 'gt'
+  | 'gte'
+  | 'lt'
+  | 'lte'
+  | 'contains'
+  | 'notContains'
+  | 'isSet'
+  | 'isNotSet';
+
+/** Top-level rule combinator. */
+export type Combinator = 'AND' | 'OR';
+
+// ── Rule discriminated union ──────────────────────────────────────────────────
+
+export interface StoreyRule {
+  kind: 'storey';
+  values: string[];
+  op: SetOp;
+}
+
+export interface IfcTypeRule {
+  kind: 'ifcType';
+  values: string[];
+  op: SetOp;
+}
+
+export interface PredefinedTypeRule {
+  kind: 'predefinedType';
+  values: string[];
+  op: SetOp;
+}
+
+export interface NameRule {
+  kind: 'name';
+  op: StringOp;
+  value: string;
+}
+
+export interface PropertyRule {
+  kind: 'property';
+  setName: string;
+  propertyName: string;
+  op: ValueOp;
+  /** Raw user input. Numeric ops parse as f64; isSet/isNotSet ignore. */
+  value: string;
+}
+
+export interface QuantityRule {
+  kind: 'quantity';
+  setName: string;
+  quantityName: string;
+  op: NumericOp;
+  value: number;
+}
+
+export type FilterRule =
+  | StoreyRule
+  | IfcTypeRule
+  | PredefinedTypeRule
+  | NameRule
+  | PropertyRule
+  | QuantityRule;
+
+// ── Pure op helpers (ported verbatim from filter.rs) ──────────────────────────
+
+export function setOpMatches(op: SetOp, candidate: string, values: readonly string[]): boolean {
+  const hit = values.some((v) => v.toLowerCase() === candidate.toLowerCase());
+  return op === 'in' ? hit : !hit;
+}
+
+export function stringOpMatches(op: StringOp, candidate: string, value: string): boolean {
+  const a = candidate.toLowerCase();
+  const b = value.toLowerCase();
+  switch (op) {
+    case 'eq':          return a === b;
+    case 'ne':          return a !== b;
+    case 'contains':    return a.includes(b);
+    case 'notContains': return !a.includes(b);
+    case 'startsWith':  return a.startsWith(b);
+  }
+}
+
+export function numericOpMatches(op: NumericOp, candidate: number, value: number): boolean {
+  // The Rust side uses 1e-9 as the epsilon for eq/ne. Match it here for
+  // IDS-style parity — IFC quantities are stored as IFC4 IfcReal so the
+  // tolerance is large enough to absorb f32→f64 rounding from the parser.
+  const EPS = 1e-9;
+  switch (op) {
+    case 'eq':  return Math.abs(candidate - value) < EPS;
+    case 'ne':  return Math.abs(candidate - value) >= EPS;
+    case 'gt':  return candidate > value;
+    case 'gte': return candidate >= value;
+    case 'lt':  return candidate < value;
+    case 'lte': return candidate <= value;
+  }
+}
+
+/**
+ * Evaluate a Property ValueOp against the candidate's raw stringified
+ * value. `isSet`/`isNotSet` are presence checks and the property layer
+ * (filter-evaluate.ts) decides them before calling here — but we still
+ * accept them so the function is total.
+ */
+export function valueOpMatches(op: ValueOp, psetVal: string, ruleVal: string): boolean {
+  switch (op) {
+    case 'isSet':       return psetVal.length > 0;
+    case 'isNotSet':    return psetVal.length === 0;
+    case 'eq':          return psetVal.toLowerCase() === ruleVal.toLowerCase();
+    case 'ne':          return psetVal.toLowerCase() !== ruleVal.toLowerCase();
+    case 'contains':    return psetVal.toLowerCase().includes(ruleVal.toLowerCase());
+    case 'notContains': return !psetVal.toLowerCase().includes(ruleVal.toLowerCase());
+    case 'gt':
+    case 'gte':
+    case 'lt':
+    case 'lte': {
+      const cv = Number.parseFloat(psetVal);
+      const rv = Number.parseFloat(ruleVal);
+      if (!Number.isFinite(cv) || !Number.isFinite(rv)) return false;
+      return numericOpMatches(op, cv, rv);
+    }
+  }
+}
+
+// ── Combinator helpers ────────────────────────────────────────────────────────
+
+/** Combine an array of per-rule booleans according to AND/OR semantics. */
+export function combineRuleResults(combinator: Combinator, results: readonly boolean[]): boolean {
+  if (results.length === 0) return false;
+  return combinator === 'AND' ? results.every((r) => r) : results.some((r) => r);
+}
+
+// ── Convenience constructors ──────────────────────────────────────────────────
+//
+// The chip UI builds rules via `set*` slice actions (see searchSlice.ts);
+// these helpers exist primarily for tests and for code paths that synthesize
+// rules from a different representation (URL state, presets).
+
+export const Rule = {
+  storey: (values: string[], op: SetOp = 'in'): StoreyRule => ({ kind: 'storey', values, op }),
+  ifcType: (values: string[], op: SetOp = 'in'): IfcTypeRule => ({ kind: 'ifcType', values, op }),
+  predefinedType: (values: string[], op: SetOp = 'in'): PredefinedTypeRule =>
+    ({ kind: 'predefinedType', values, op }),
+  name: (op: StringOp, value: string): NameRule => ({ kind: 'name', op, value }),
+  property: (setName: string, propertyName: string, op: ValueOp, value: string): PropertyRule =>
+    ({ kind: 'property', setName, propertyName, op, value }),
+  quantity: (setName: string, quantityName: string, op: NumericOp, value: number): QuantityRule =>
+    ({ kind: 'quantity', setName, quantityName, op, value }),
+} as const;
+
+// ── JSON guards ──────────────────────────────────────────────────────────────
+
+export function isFilterRule(value: unknown): value is FilterRule {
+  if (typeof value !== 'object' || value === null) return false;
+  const kind = (value as { kind?: unknown }).kind;
+  return (
+    kind === 'storey' ||
+    kind === 'ifcType' ||
+    kind === 'predefinedType' ||
+    kind === 'name' ||
+    kind === 'property' ||
+    kind === 'quantity'
+  );
+}
+
+export function parseFilterRules(raw: unknown): FilterRule[] {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(isFilterRule);
+}

package/src/lib/search/filter-schema.test.ts

@@ -0,0 +1,233 @@
+/* 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,
+  PropertyTableBuilder,
+  QuantityTableBuilder,
+  PropertyValueType,
+  QuantityType,
+  IfcTypeEnum,
+} from '@ifc-lite/data';
+import type { SpatialHierarchy } from '@ifc-lite/data';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import { discoverFilterSchema, discoverPropertyAndQuantitySchema } from './filter-schema.js';
+
+interface EntityRow {
+  expressId: number;
+  type: string;
+  globalId: string;
+  name: string;
+}
+
+/**
+ * Build an in-memory IfcDataStore that exercises the schema discovery
+ * fallbacks: empty `source` so the on-demand extractors short-circuit
+ * to the pre-computed PropertyTable / QuantityTable lookup.
+ */
+function buildStore(args: {
+  entities: EntityRow[];
+  storeys?: Array<{ id: number; name: string; elevation?: number }>;
+  elementToStorey?: Array<[number, number]>;
+  psetRows?: Array<{ entityId: number; psetName: string; propName: string }>;
+  qtoRows?: Array<{ entityId: number; qsetName: string; quantityName: string }>;
+}): IfcDataStore {
+  const strings = new StringTable();
+  const builder = new EntityTableBuilder(args.entities.length, strings);
+  for (const r of args.entities) {
+    builder.add(r.expressId, r.type, r.globalId, r.name, '', '', false, false);
+  }
+  const entities = builder.build();
+
+  const propertyBuilder = new PropertyTableBuilder(strings);
+  for (const r of args.psetRows ?? []) {
+    propertyBuilder.add({
+      entityId: r.entityId,
+      psetName: r.psetName,
+      psetGlobalId: '',
+      propName: r.propName,
+      propType: PropertyValueType.String,
+      value: '',
+    });
+  }
+  const properties = propertyBuilder.build();
+
+  const quantityBuilder = new QuantityTableBuilder(strings);
+  for (const r of args.qtoRows ?? []) {
+    quantityBuilder.add({
+      entityId: r.entityId,
+      qsetName: r.qsetName,
+      quantityName: r.quantityName,
+      quantityType: QuantityType.Length,
+      value: 0,
+    });
+  }
+  const quantities = quantityBuilder.build();
+
+  const byType = new Map<string, number[]>();
+  for (const r of args.entities) {
+    const upper = r.type.toUpperCase();
+    let bucket = byType.get(upper);
+    if (!bucket) { bucket = []; byType.set(upper, bucket); }
+    bucket.push(r.expressId);
+  }
+
+  let spatialHierarchy: SpatialHierarchy | undefined;
+  if (args.storeys && args.storeys.length > 0) {
+    const byStorey = new Map<number, number[]>();
+    const storeyElevations = new Map<number, number>();
+    const elementToStorey = new Map<number, number>(args.elementToStorey ?? []);
+    for (const s of args.storeys) {
+      byStorey.set(s.id, []);
+      if (s.elevation !== undefined) storeyElevations.set(s.id, s.elevation);
+    }
+    spatialHierarchy = {
+      project: { expressId: 1, type: IfcTypeEnum.IfcProject, name: '', children: [], elements: [] },
+      byStorey,
+      byBuilding: new Map(),
+      bySite: new Map(),
+      bySpace: new Map(),
+      storeyElevations,
+      storeyHeights: new Map(),
+      elementToStorey,
+      getStoreyElements: () => [],
+      getStoreyByElevation: () => null,
+      getContainingSpace: () => null,
+      getPath: () => [],
+    };
+  }
+
+  // Build expressId → entityId-list map for properties / quantities so
+  // the on-demand maps have the right shape.
+  const onDemandPropertyMap = new Map<number, number[]>();
+  for (const r of args.psetRows ?? []) {
+    const list = onDemandPropertyMap.get(r.entityId) ?? [];
+    list.push(r.entityId); // dummy pset id; the value is unused on the
+                            // PropertyTable fallback path because source=''
+    onDemandPropertyMap.set(r.entityId, list);
+  }
+  const onDemandQuantityMap = new Map<number, number[]>();
+  for (const r of args.qtoRows ?? []) {
+    const list = onDemandQuantityMap.get(r.entityId) ?? [];
+    list.push(r.entityId);
+    onDemandQuantityMap.set(r.entityId, list);
+  }
+
+  return {
+    fileSize: 0,
+    schemaVersion: 'IFC4',
+    entityCount: args.entities.length,
+    parseTime: 0,
+    source: new Uint8Array(0),
+    entityIndex: { byId: { ranges: new Uint32Array(0), index: new Map() }, byType },
+    strings,
+    entities,
+    properties,
+    quantities,
+    relationships: { count: 0 } as unknown as IfcDataStore['relationships'],
+    spatialHierarchy,
+    onDemandPropertyMap,
+    onDemandQuantityMap,
+  } as unknown as IfcDataStore;
+}
+
+describe('discoverFilterSchema — basic pass', () => {
+  it('returns an empty schema when no models / no spatial hierarchy', () => {
+    const store = buildStore({ entities: [] });
+    const schema = discoverFilterSchema(store);
+    assert.deepStrictEqual(schema.storeys, []);
+    assert.deepStrictEqual(schema.ifcTypes, []);
+  });
+
+  it('collects unique IFC types in canonical PascalCase, sorted', () => {
+    const store = buildStore({
+      entities: [
+        { expressId: 1, type: 'IFCWALL',   globalId: '', name: '' },
+        { expressId: 2, type: 'IFCWALL',   globalId: '', name: '' },
+        { expressId: 3, type: 'IFCDOOR',   globalId: '', name: '' },
+        { expressId: 4, type: 'IFCWINDOW', globalId: '', name: '' },
+      ],
+    });
+    const schema = discoverFilterSchema(store);
+    assert.deepStrictEqual(schema.ifcTypes, ['IfcDoor', 'IfcWall', 'IfcWindow']);
+  });
+
+  it('collects storeys with elevations sorted by name, deduped', () => {
+    const store = buildStore({
+      entities: [
+        { expressId: 100, type: 'IFCBUILDINGSTOREY', globalId: '', name: 'Level 1' },
+        { expressId: 101, type: 'IFCBUILDINGSTOREY', globalId: '', name: 'Level 2' },
+        { expressId: 102, type: 'IFCBUILDINGSTOREY', globalId: '', name: 'Level 1' /* duplicate name */ },
+      ],
+      storeys: [
+        { id: 100, name: 'Level 1', elevation: 0.0 },
+        { id: 101, name: 'Level 2', elevation: 3.0 },
+        { id: 102, name: 'Level 1', elevation: 0.0 },
+      ],
+    });
+    const schema = discoverFilterSchema(store);
+    // Two unique names; "Level 1" is kept once.
+    assert.strictEqual(schema.storeys.length, 2);
+    assert.deepStrictEqual(schema.storeys.map(([n]) => n), ['Level 1', 'Level 2']);
+  });
+
+  it('treats missing elevation as null', () => {
+    const store = buildStore({
+      entities: [{ expressId: 10, type: 'IFCBUILDINGSTOREY', globalId: '', name: 'Roof' }],
+      storeys: [{ id: 10, name: 'Roof' /* no elevation */ }],
+    });
+    const schema = discoverFilterSchema(store);
+    assert.deepStrictEqual(schema.storeys, [['Roof', null]]);
+  });
+});
+
+describe('discoverPropertyAndQuantitySchema — fallback pass via PropertyTable', () => {
+  it('returns empty schema when no on-demand maps', () => {
+    const store = buildStore({ entities: [{ expressId: 1, type: 'IFCWALL', globalId: '', name: '' }] });
+    // Strip the on-demand maps for the test.
+    delete (store as { onDemandPropertyMap?: unknown }).onDemandPropertyMap;
+    delete (store as { onDemandQuantityMap?: unknown }).onDemandQuantityMap;
+    const schema = discoverPropertyAndQuantitySchema(store);
+    assert.deepStrictEqual(schema.psets, []);
+    assert.deepStrictEqual(schema.qtos, []);
+  });
+
+  it('harvests pset → property names from the on-demand iteration', () => {
+    const store = buildStore({
+      entities: [
+        { expressId: 1, type: 'IFCWALL', globalId: '', name: '' },
+        { expressId: 2, type: 'IFCDOOR', globalId: '', name: '' },
+      ],
+      psetRows: [
+        { entityId: 1, psetName: 'Pset_WallCommon', propName: 'IsExternal' },
+        { entityId: 1, psetName: 'Pset_WallCommon', propName: 'LoadBearing' },
+        { entityId: 2, psetName: 'Pset_DoorCommon', propName: 'FireRating' },
+      ],
+    });
+    const schema = discoverPropertyAndQuantitySchema(store);
+    assert.deepStrictEqual(schema.psets.map(([n]) => n).sort(), ['Pset_DoorCommon', 'Pset_WallCommon']);
+    const wall = schema.psets.find(([n]) => n === 'Pset_WallCommon');
+    assert.deepStrictEqual(wall?.[1].sort(), ['IsExternal', 'LoadBearing']);
+  });
+
+  it('harvests qto → quantity names with empty unit', () => {
+    const store = buildStore({
+      entities: [{ expressId: 1, type: 'IFCWALL', globalId: '', name: '' }],
+      qtoRows: [
+        { entityId: 1, qsetName: 'Qto_WallBaseQuantities', quantityName: 'NetSideArea' },
+        { entityId: 1, qsetName: 'Qto_WallBaseQuantities', quantityName: 'GrossVolume' },
+      ],
+    });
+    const schema = discoverPropertyAndQuantitySchema(store);
+    assert.strictEqual(schema.qtos.length, 1);
+    const [qsetName, quantities] = schema.qtos[0];
+    assert.strictEqual(qsetName, 'Qto_WallBaseQuantities');
+    assert.deepStrictEqual(quantities.map(([n]) => n).sort(), ['GrossVolume', 'NetSideArea']);
+    // Unit is "" until on-demand extractors materialise it.
+    assert.ok(quantities.every(([, unit]) => unit === ''));
+  });
+});