@ifc-lite/rules 0.2.0

package/dist/filter/filter-match.js

@@ -0,0 +1,302 @@
+/* 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 { flattenMaterials } from '@ifc-lite/ids';
+import { collectSpatialAncestors } from '@ifc-lite/data';
+import { valueOpMatches, numericOpMatches, matchStringAnyNone } from './filter-ops.js';
+import { lensMaterialNames } from './lens-material-names.js';
+import { parsePropertyValue } from '@ifc-lite/encoding';
+import { compileNameMatcher, isNamePattern } from '@ifc-lite/lists';
+/**
+ * Compare a rule's property-set / property name against a row's.
+ *
+ * `kind` is the rule saying what it holds (see {@link TextKind}). A `'regex'`
+ * name is a SOURCE and the whole string is the pattern, which is what makes
+ * the selector syntax's `/Pset_.*Common/.FireRating` reach `Pset_WallCommon`
+ * and `Pset_SlabCommon` in one rule; a `'literal'` name is compared as text
+ * even when it is spelled with slashes, which is what the grammar's quoting
+ * means and the only reason `"/Wall/".FireRating` can be asked for at all.
+ *
+ * A name with no declared kind was typed into a chip field, where the
+ * Lists-panel `/…/` convention (#1591) is the user's only way to say
+ * "pattern"; anything else there is the historical case-insensitive equality.
+ *
+ * `compileNameMatcher` throws when the regex body is syntactically valid but
+ * rejected by `@ifc-lite/regex-guard` as unsafe (catastrophic-backtracking
+ * shaped, or over the length cap) — see `filter-ops.ts`'s `regexOpMatches`
+ * docstring for the full contract. This function does not catch that; it
+ * propagates to `filter-evaluate.ts`'s caller, which must.
+ */
+export function nameMatches(rulePattern, rowName, kind) {
+    if (kind === 'regex')
+        return compileNameMatcher(`/${rulePattern}/`)(rowName);
+    if (kind === undefined && isNamePattern(rulePattern))
+        return compileNameMatcher(rulePattern)(rowName);
+    return rowName.toLowerCase() === rulePattern.toLowerCase();
+}
+export function flattenPsets(psets) {
+    const out = [];
+    for (const set of psets) {
+        for (const p of set.properties) {
+            out.push({
+                setName: set.name,
+                propertyName: p.name,
+                // Stringify everything — `valueOpMatches` re-parses numeric ops
+                // from this representation. Booleans render as "True"/"False" —
+                // the SAME capitalised display string the property table and the
+                // list engine (`@ifc-lite/encoding`'s `parsePropertyValue`) show —
+                // so a value picked from a chip/dropdown suggestion always matches
+                // what the user sees rendered elsewhere. `valueOpMatches`'s eq/ne
+                // are case-insensitive, so this doesn't change matching outcomes
+                // for either the search chips or free-typed "true"/"false".
+                value: stringifyValue(p.value),
+            });
+        }
+    }
+    return out;
+}
+export function flattenQtys(qtos) {
+    const out = [];
+    for (const set of qtos) {
+        for (const q of set.quantities) {
+            out.push({ setName: set.name, quantityName: q.name, value: q.value });
+        }
+    }
+    return out;
+}
+export function stringifyValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    // Match `parsePropertyValue`'s boolean rendering ("True"/"False") — the
+    // SAME function the property table and the list engine's display use —
+    // so discovered dropdown suggestions equal what's actually shown/matched
+    // elsewhere (#IsExternal true/false mismatch report).
+    if (typeof value === 'boolean')
+        return parsePropertyValue(value).displayValue;
+    if (typeof value === 'number')
+        return String(value);
+    return String(value);
+}
+export function matchPropertyRule(rule, rows) {
+    // isSet / isNotSet are presence checks against (setName, propertyName).
+    if (rule.op === 'isSet' || rule.op === 'isNotSet') {
+        const present = rows.some((r) => nameMatches(rule.setName, r.setName, rule.setNameKind) &&
+            nameMatches(rule.propertyName, r.propertyName, rule.propertyNameKind));
+        return rule.op === 'isSet' ? present : !present;
+    }
+    return rows.some((r) => nameMatches(rule.setName, r.setName, rule.setNameKind) &&
+        nameMatches(rule.propertyName, r.propertyName, rule.propertyNameKind) &&
+        valueOpMatches(rule.op, r.value, rule.value, rule.valueKind));
+}
+/**
+ * Match an `attribute` rule (Description, ObjectType, Tag, LongName, any
+ * other schema-named attribute) against one entity's extracted attributes.
+ * Attribute NAME matching is case-insensitive, same as the IDS attribute
+ * facet this reuses the extraction from; the VALUE comparison reuses
+ * `valueOpMatches`, the same comparator `matchPropertyRule` uses, so a
+ * numeric attribute value compares the same way a numeric property does.
+ */
+export function matchAttributeRule(rule, attrs) {
+    const wanted = rule.name.toLowerCase();
+    const found = attrs.find((a) => a.name.toLowerCase() === wanted);
+    const stringified = found === undefined ? undefined : stringifyValue(found.value);
+    if (rule.op === 'isSet' || rule.op === 'isNotSet') {
+        const present = (stringified ?? '').length > 0;
+        return rule.op === 'isSet' ? present : !present;
+    }
+    if (stringified === undefined)
+        return false;
+    return valueOpMatches(rule.op, stringified, rule.value, rule.valueKind);
+}
+export function matchQuantityRule(rule, rows) {
+    return rows.some((r) => nameMatches(rule.setName, r.setName, rule.setNameKind) &&
+        nameMatches(rule.quantityName, r.quantityName, rule.quantityNameKind) &&
+        numericOpMatches(rule.op, r.value, rule.value));
+}
+// ── Storey lookup fallback ────────────────────────────────────────────────────
+/**
+ * Storey id an element belongs to: its own direct containment
+ * (`elementToStorey`, set for an element the storey directly contains plus
+ * its `IfcRelAggregates`-aggregated parts) OR — one hop through a
+ * containing `IfcSpace`/`IfcSpatialZone` — the storey THAT space belongs
+ * to. A space is itself mapped to its storey in `elementToStorey`
+ * (`SpatialHierarchyBuilder` walks a storey's own spatial children), so
+ * this is a composition of two maps that already exist plus
+ * `getContainingSpace` (`@ifc-lite/data`'s `spatialLookups`), not a new
+ * traversal. The single home for "which storey" so the per-entity
+ * evaluator (`defaultStoreyName`/`storeyMatchesRefs`) and the bulk index
+ * prefilter (`unionByStorey`) cannot answer it two different ways.
+ *
+ * Reaches exactly one level down from the storey: an element inside a
+ * space nested inside another space (rather than directly under the
+ * storey) is not resolved — see `docs/guide/selector-syntax.md`.
+ */
+function storeyIdOf(hierarchy, expressId) {
+    const direct = hierarchy.elementToStorey.get(expressId);
+    if (direct !== undefined)
+        return direct;
+    // `getContainingSpace` is part of the `spatialLookups()` contract every
+    // real hierarchy carries, but several tests in this suite build a
+    // hand-rolled partial `spatialHierarchy` mock (`byStorey`/`elementToStorey`
+    // only) to exercise the ref/name-matching paths in isolation — guard
+    // rather than assume every field is present.
+    const spaceId = hierarchy.getContainingSpace?.(expressId);
+    if (spaceId == null)
+        return undefined;
+    return hierarchy.elementToStorey.get(spaceId);
+}
+/** Every element `bySpace` lists for a space belonging to `storeyId` — the
+ *  bulk-prefilter twin of {@link storeyIdOf}'s one-hop space widening.
+ *  `bySpace` is absent on the same partial test mocks {@link storeyIdOf}
+ *  guards against. */
+function spaceElementsOfStorey(hierarchy, storeyId) {
+    const out = [];
+    if (!hierarchy.bySpace)
+        return out;
+    for (const [spaceId, elements] of hierarchy.bySpace) {
+        if (hierarchy.elementToStorey.get(spaceId) !== storeyId)
+            continue;
+        for (const id of elements)
+            out.push(id);
+    }
+    return out;
+}
+export function defaultStoreyName(store, expressId) {
+    const hierarchy = store.spatialHierarchy;
+    if (!hierarchy)
+        return '';
+    const storeyId = storeyIdOf(hierarchy, expressId);
+    if (!storeyId)
+        return '';
+    return store.entities.getName(storeyId);
+}
+/** Does `expressId` (in `modelId`) sit in a storey ref'd by `rule.refs`?
+ *  `IfcBuildingStorey.Name` isn't unique, so once a `StoreyRule` carries
+ *  an exact (modelId, expressId) ref (mirrored from a HierarchyPanel
+ *  click), matching bypasses Name entirely. Reaches through a containing
+ *  space via {@link storeyIdOf}, same as the Name-matched path. */
+export function storeyMatchesRefs(store, expressId, modelId, rule) {
+    const hierarchy = store.spatialHierarchy;
+    const storeyId = hierarchy ? storeyIdOf(hierarchy, expressId) : undefined;
+    return storeyId != null && !!rule.refs?.some((r) => r.modelId === modelId && r.expressId === storeyId);
+}
+/** Index-prefilter twin of {@link storeyMatchesRefs}/Name matching: the
+ *  bucket of elements a `storey op:'in'` rule narrows to for `modelId`.
+ *  Includes each matched storey's directly-contained elements AND every
+ *  element `bySpace` lists for a space belonging to that storey, so this
+ *  prefilter can never exclude a candidate the (also widened) per-entity
+ *  check in `filter-evaluate.ts` would go on to match. */
+export function unionByStorey(store, rule, modelId) {
+    const hierarchy = store.spatialHierarchy;
+    if (!hierarchy)
+        return null;
+    const out = [];
+    if (rule.refs) {
+        for (const ref of rule.refs) {
+            if (ref.modelId !== modelId)
+                continue;
+            const elements = hierarchy.byStorey.get(ref.expressId);
+            if (elements)
+                for (const id of elements)
+                    out.push(id);
+            for (const id of spaceElementsOfStorey(hierarchy, ref.expressId))
+                out.push(id);
+        }
+        return out.length > 0 ? out : null;
+    }
+    const wanted = new Set(rule.values.map((n) => n.toLowerCase()));
+    for (const storeyId of hierarchy.byStorey.keys()) {
+        const name = store.entities.getName(storeyId);
+        if (!wanted.has(name.toLowerCase()))
+            continue;
+        const elements = hierarchy.byStorey.get(storeyId);
+        if (elements)
+            for (const id of elements)
+                out.push(id);
+        for (const id of spaceElementsOfStorey(hierarchy, storeyId))
+            out.push(id);
+    }
+    return out.length > 0 ? out : null;
+}
+// ── Material / classification / elevation resolution ─────────────────────────
+/** Collect the *individual* material names an element exposes - each layer /
+ *  constituent / profile material, or the single plain material - for the
+ *  multi-valued `material` rule matcher and the material dropdown. Shares the
+ *  #1366 lens collector, so filtering by material groups by the real materials
+ *  rather than the layer-set / Revit family+type name that masked them. (#1462) */
+export function materialNamesOf(info) {
+    return lensMaterialNames(info);
+}
+/** `materialNamesOf` plus every material Category (`material=` matches
+ *  Name OR Category, #4094) — categories come from `flattenMaterials`
+ *  (`@ifc-lite/ids`'s material-facet flattener), reused rather than a
+ *  second layer/profile/constituent walk; only its `.category` field is
+ *  used, since its `.name` field also surfaces a layer's own label, which
+ *  `materialNamesOf` deliberately excludes (#1462). */
+export function materialMatchCandidates(info) {
+    const categories = flattenMaterials(info)
+        .map((m) => m.category)
+        .filter((c) => !!c);
+    return [...new Set([...materialNamesOf(info), ...categories])];
+}
+/**
+ * Match a classification rule against an element's classification refs.
+ * `system` (when set) scopes to one system; value ops match a ref's code
+ * (identification) OR name. Pushes both through even when `undefined`
+ * (absent) rather than filtering on truthy — `matchStringAnyNone` decides
+ * absent-vs-empty explicitly (#4930).
+ */
+export function matchClassificationRule(rule, refs) {
+    const sys = rule.system?.trim().toLowerCase();
+    const scoped = sys
+        ? refs.filter((r) => (r.system ?? '').toLowerCase() === sys)
+        : refs;
+    if (rule.op === 'isSet')
+        return scoped.length > 0;
+    if (rule.op === 'isNotSet')
+        return scoped.length === 0;
+    // Value ops — match against identification (code) and name of each ref.
+    // `unresolved` (server-parsed, no source bytes — #3948) means UNKNOWN, not
+    // ABSENT: excluded from candidates entirely, same as before #4930, so it
+    // can't flip a negative op false->true. Only a RESOLVED ref's genuinely
+    // `$` identification/name contributes a real `undefined` candidate.
+    const candidates = [];
+    for (const r of scoped) {
+        if (r.unresolved)
+            continue;
+        candidates.push(r.identification);
+        candidates.push(r.name);
+    }
+    // rule.op is now eq | ne | contains | notContains — a StringOp subset.
+    return matchStringAnyNone(rule.op, candidates, rule.value, rule.valueKind);
+}
+/** Element elevation in metres, derived from its building storey's
+ *  elevation. Returns null when the element isn't placed in the spatial
+ *  hierarchy (so an elevation rule simply doesn't match it). */
+export function elevationOf(store, expressId) {
+    const hierarchy = store.spatialHierarchy;
+    if (!hierarchy)
+        return null;
+    const storeyId = hierarchy.elementToStorey.get(expressId);
+    if (!storeyId)
+        return null;
+    const elev = hierarchy.storeyElevations.get(storeyId);
+    return typeof elev === 'number' ? elev : null;
+}
+// ── Parent (spatial ancestor) resolution ──────────────────────────────────────
+/**
+ * `parent=Foo` (#4903) — does ANY ancestor of `expressId`, walking upward
+ * through spatial containment and aggregation to any depth via
+ * `collectSpatialAncestors` (`@ifc-lite/data`, the single shared resolver),
+ * have a Name the rule's op matches? Reuses `matchStringAnyNone`, the same
+ * multi-valued convention `material`/`classification` rules use: an element
+ * with NO ancestors — or none whose Name matches — satisfies neither a
+ * positive nor a negative op (#4659). `getNameOrUndefined`, not `getName`,
+ * so an ancestor with no Name at all is a real absent candidate (#4930).
+ */
+export function matchParentRule(rule, store, expressId) {
+    const ancestorNames = collectSpatialAncestors(store.relationships, expressId)
+        .map((id) => store.entities.getNameOrUndefined(id));
+    return matchStringAnyNone(rule.op, ancestorNames, rule.value, rule.valueKind);
+}
+//# sourceMappingURL=filter-match.js.map

package/dist/filter/filter-match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-match.js","sourceRoot":"","sources":["../../src/filter/filter-match.ts"],"names":[],"mappings":"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"}

package/dist/filter/filter-ops.d.ts

@@ -0,0 +1,90 @@
+import type { NumericOp, SetOp, StringOp, TextKind, ValueOp } from './filter-rules.js';
+/**
+ * Trailing options accepted by every op-matching function below (#5138 PR 3).
+ * Omitted entirely = today's behaviour EXACTLY: search, saved filters and
+ * clash presets never pass this, so they fold case unconditionally (like
+ * `fold()` always did before this flag existed) and compare numbers with the
+ * historical absolute `1e-9` epsilon. Only the information-validation engine
+ * passes it, with `caseSensitive: rule.caseSensitive ?? true` (IDS parity,
+ * bSI #346) and `tolerance: rule.tolerance ?? 1e-6` (relative, bSI #418).
+ */
+export interface OpMatchOptions {
+    caseSensitive?: boolean;
+    tolerance?: number;
+}
+/**
+ * Regex matching for the `matches` / `notMatches` ops, shared by every rule
+ * kind that owns them.
+ *
+ * `kind` is the producer speaking (see {@link TextKind}). A declared operand is
+ * a regular-expression SOURCE and the WHOLE string is the pattern, slashes
+ * included — that is what makes the selector `Name=/\/tmp\//` look for `/tmp/`
+ * rather than `tmp`. An operand with no declared kind is free text under the
+ * Lists-panel convention (#1591): a `/body/flags` literal is a pattern, flags
+ * and all, and anything else is a bare source. That is the spelling the chip
+ * editors ask for, and there the slashes ARE the user's only way to say
+ * "pattern", so reading them is the grammar rather than a guess.
+ *
+ * Case-SENSITIVE, unlike every other op here: the selector grammar's `/…/` is
+ * a Python regular expression, and those do not fold case. Write JavaScript's
+ * equivalent of `(?i)` by adding an `i` flag to a full literal (`/wand/i`).
+ *
+ * An empty operand never matches; a MALFORMED literal (bad regex syntax)
+ * never matches either (`compileNameMatcher` logs it and falls back to an
+ * exact compare against the literal text, which no property value equals).
+ *
+ * An UNSAFE pattern — syntactically valid but rejected by
+ * `@ifc-lite/regex-guard` as catastrophic-backtracking-shaped or over the
+ * length cap — is different: `compileNameMatcher` THROWS a plain `Error`
+ * naming the pattern and reason, once, on the first row that reaches it.
+ * This function does not catch that throw; it propagates out of
+ * `stringOpMatches` / `matchStringAnyNone` / `valueOpMatches` and out of
+ * `filter-evaluate.ts`'s per-entity loop. Every current caller of the
+ * evaluator (`SearchModal.filter.tsx`'s `runFilter`, `resolveClashSetFilter`,
+ * `query-adapter.ts`'s `entitiesMatchingActiveFilter`) already wraps its call
+ * in a try/catch that turns this into a visible, recoverable error rather
+ * than an unhandled exception — see those call sites for how each one
+ * surfaces it. A new caller of `evaluateFilterRules` /
+ * `evaluateFilterRulesFederated` MUST do the same.
+ */
+export declare function regexOpMatches(candidate: string, value: string, kind: TextKind | undefined): boolean;
+export declare function setOpMatches(op: SetOp, candidate: string, values: readonly string[], opts?: OpMatchOptions): boolean;
+/**
+ * `globalId` rule matching — exact, case-SENSITIVE, unlike every other
+ * `SetOp` dimension in this module. A GlobalId is a 22-character base64
+ * string (IFC's compressed GUID encoding), where upper/lower case is part of
+ * the identity: folding case would let two DIFFERENT elements' GlobalIds
+ * collide on an `in` match.
+ */
+export declare function globalIdOpMatches(op: SetOp, candidate: string, values: readonly string[]): boolean;
+/**
+ * `candidate: string | undefined` — `undefined` means ABSENT (#4930), a real
+ * input, decided explicitly here: a positive op never matches it, its
+ * negation always does.
+ */
+export declare function stringOpMatches(op: StringOp, candidate: string | undefined, value: string, valueKind?: TextKind, opts?: OpMatchOptions): boolean;
+/**
+ * Match a StringOp against a *set* of candidates (materials, ancestors,
+ * classification refs). Positive ops match if ANY satisfies them; negative
+ * ops match only if NONE violates them; a `string | undefined` candidate is
+ * handled per-entry by `stringOpMatches` (#4930). An empty LIST stays
+ * distinct: "no candidates at all" never matches, negative ops included.
+ */
+export declare function matchStringAnyNone(op: StringOp, candidates: readonly (string | undefined)[], value: string, valueKind?: TextKind, opts?: OpMatchOptions): boolean;
+/**
+ * `opts.tolerance` (relative, bSI #418 — e.g. `1e-6`) replaces the absolute
+ * `1e-9` epsilon below for `eq`/`ne` and widens `gte`/`lte` to accept a value
+ * within tolerance of the boundary; `gt`/`lt` stay strict (a tolerant strict
+ * inequality would let a value equal to the boundary pass both `gt` and its
+ * own negation's neighbour). Omitted `opts`/`tolerance` = today's absolute-
+ * epsilon behaviour, unchanged.
+ */
+export declare function numericOpMatches(op: NumericOp, candidate: number, value: number, opts?: OpMatchOptions): boolean;
+/**
+ * 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 declare function valueOpMatches(op: ValueOp, psetVal: string, ruleVal: string, valueKind?: TextKind, opts?: OpMatchOptions): boolean;
+//# sourceMappingURL=filter-ops.d.ts.map

package/dist/filter/filter-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-ops.d.ts","sourceRoot":"","sources":["../../src/filter/filter-ops.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEvF;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,CAIpG;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,KAAK,EACT,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,IAAI,CAAC,EAAE,cAAc,GACpB,OAAO,CAIT;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAGlG;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,QAAQ,EACpB,IAAI,CAAC,EAAE,cAAc,GACpB,OAAO,CAyBT;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,EAC3C,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,QAAQ,EACpB,IAAI,CAAC,EAAE,cAAc,GACpB,OAAO,CAeT;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAyBhH;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,OAAO,EACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,QAAQ,EACpB,IAAI,CAAC,EAAE,cAAc,GACpB,OAAO,CAoBT"}

package/dist/filter/filter-ops.js

@@ -0,0 +1,202 @@
+/* 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/. */
+/**
+ * Pure operator matching for the filter rule taxonomy (ported verbatim from
+ * the Tauri-side `filter.rs` engine).
+ *
+ * Split out of `filter-rules.ts` at the op seam so both stay under the module
+ * size cap: that file owns the rule SHAPES, their constructors and the JSON
+ * guards, this one owns what an operator MEANS. Nothing here reads a rule —
+ * each function takes an operator, a candidate and the rule's operand, which
+ * is what makes them testable without a model.
+ */
+import { compileNameMatcher, isNamePattern } from '@ifc-lite/lists';
+/**
+ * Fold a candidate that may be undefined at runtime — crash-safety only
+ * (#1195) — to lower-case UNLESS `caseSensitive` is `true`. Does NOT decide
+ * what "no value" means to an operator: `undefined` (absent) vs `''`
+ * (explicitly empty) is a real distinction a caller must resolve before
+ * calling this — see `stringOpMatches` (#4930). `caseSensitive` omitted (the
+ * only path before #5138 PR 3) always folds, so this is byte-for-byte the
+ * historical `lower()` for every existing caller.
+ */
+function fold(s, caseSensitive) {
+    const v = s ?? '';
+    return caseSensitive ? v : v.toLowerCase();
+}
+/**
+ * Regex matching for the `matches` / `notMatches` ops, shared by every rule
+ * kind that owns them.
+ *
+ * `kind` is the producer speaking (see {@link TextKind}). A declared operand is
+ * a regular-expression SOURCE and the WHOLE string is the pattern, slashes
+ * included — that is what makes the selector `Name=/\/tmp\//` look for `/tmp/`
+ * rather than `tmp`. An operand with no declared kind is free text under the
+ * Lists-panel convention (#1591): a `/body/flags` literal is a pattern, flags
+ * and all, and anything else is a bare source. That is the spelling the chip
+ * editors ask for, and there the slashes ARE the user's only way to say
+ * "pattern", so reading them is the grammar rather than a guess.
+ *
+ * Case-SENSITIVE, unlike every other op here: the selector grammar's `/…/` is
+ * a Python regular expression, and those do not fold case. Write JavaScript's
+ * equivalent of `(?i)` by adding an `i` flag to a full literal (`/wand/i`).
+ *
+ * An empty operand never matches; a MALFORMED literal (bad regex syntax)
+ * never matches either (`compileNameMatcher` logs it and falls back to an
+ * exact compare against the literal text, which no property value equals).
+ *
+ * An UNSAFE pattern — syntactically valid but rejected by
+ * `@ifc-lite/regex-guard` as catastrophic-backtracking-shaped or over the
+ * length cap — is different: `compileNameMatcher` THROWS a plain `Error`
+ * naming the pattern and reason, once, on the first row that reaches it.
+ * This function does not catch that throw; it propagates out of
+ * `stringOpMatches` / `matchStringAnyNone` / `valueOpMatches` and out of
+ * `filter-evaluate.ts`'s per-entity loop. Every current caller of the
+ * evaluator (`SearchModal.filter.tsx`'s `runFilter`, `resolveClashSetFilter`,
+ * `query-adapter.ts`'s `entitiesMatchingActiveFilter`) already wraps its call
+ * in a try/catch that turns this into a visible, recoverable error rather
+ * than an unhandled exception — see those call sites for how each one
+ * surfaces it. A new caller of `evaluateFilterRules` /
+ * `evaluateFilterRulesFederated` MUST do the same.
+ */
+export function regexOpMatches(candidate, value, kind) {
+    if (value.length === 0)
+        return false;
+    const literal = kind === undefined && isNamePattern(value) ? value : `/${value}/`;
+    return compileNameMatcher(literal)(candidate ?? '');
+}
+export function setOpMatches(op, candidate, values, opts) {
+    const c = fold(candidate, opts?.caseSensitive);
+    const hit = values.some((v) => fold(v, opts?.caseSensitive) === c);
+    return op === 'in' ? hit : !hit;
+}
+/**
+ * `globalId` rule matching — exact, case-SENSITIVE, unlike every other
+ * `SetOp` dimension in this module. A GlobalId is a 22-character base64
+ * string (IFC's compressed GUID encoding), where upper/lower case is part of
+ * the identity: folding case would let two DIFFERENT elements' GlobalIds
+ * collide on an `in` match.
+ */
+export function globalIdOpMatches(op, candidate, values) {
+    const hit = values.includes(candidate);
+    return op === 'in' ? hit : !hit;
+}
+/**
+ * `candidate: string | undefined` — `undefined` means ABSENT (#4930), a real
+ * input, decided explicitly here: a positive op never matches it, its
+ * negation always does.
+ */
+export function stringOpMatches(op, candidate, value, valueKind, opts) {
+    if (candidate === undefined) {
+        switch (op) {
+            case 'eq':
+            case 'contains':
+            case 'startsWith':
+            case 'matches':
+                return false;
+            case 'ne':
+            case 'notContains':
+            case 'notMatches':
+                return true;
+        }
+    }
+    const a = fold(candidate, opts?.caseSensitive);
+    const b = fold(value, opts?.caseSensitive);
+    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);
+        case 'matches': return regexOpMatches(candidate, value, valueKind);
+        case 'notMatches': return !regexOpMatches(candidate, value, valueKind);
+    }
+}
+/**
+ * Match a StringOp against a *set* of candidates (materials, ancestors,
+ * classification refs). Positive ops match if ANY satisfies them; negative
+ * ops match only if NONE violates them; a `string | undefined` candidate is
+ * handled per-entry by `stringOpMatches` (#4930). An empty LIST stays
+ * distinct: "no candidates at all" never matches, negative ops included.
+ */
+export function matchStringAnyNone(op, candidates, value, valueKind, opts) {
+    if (candidates.length === 0)
+        return false;
+    switch (op) {
+        case 'eq':
+        case 'contains':
+        case 'startsWith':
+        case 'matches':
+            return candidates.some((c) => stringOpMatches(op, c, value, valueKind, opts));
+        case 'ne':
+            return candidates.every((c) => stringOpMatches('eq', c, value, undefined, opts) === false);
+        case 'notContains':
+            return candidates.every((c) => stringOpMatches('contains', c, value, undefined, opts) === false);
+        case 'notMatches':
+            return candidates.every((c) => stringOpMatches('matches', c, value, valueKind, opts) === false);
+    }
+}
+/**
+ * `opts.tolerance` (relative, bSI #418 — e.g. `1e-6`) replaces the absolute
+ * `1e-9` epsilon below for `eq`/`ne` and widens `gte`/`lte` to accept a value
+ * within tolerance of the boundary; `gt`/`lt` stay strict (a tolerant strict
+ * inequality would let a value equal to the boundary pass both `gt` and its
+ * own negation's neighbour). Omitted `opts`/`tolerance` = today's absolute-
+ * epsilon behaviour, unchanged.
+ */
+export function numericOpMatches(op, candidate, value, opts) {
+    const tol = opts?.tolerance;
+    if (tol !== undefined) {
+        const eps = tol * Math.max(Math.abs(candidate), Math.abs(value), 1);
+        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 - eps;
+            case 'lt': return candidate < value;
+            case 'lte': return candidate <= value + eps;
+        }
+    }
+    // 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, psetVal, ruleVal, valueKind, opts) {
+    switch (op) {
+        case 'isSet': return (psetVal ?? '').length > 0;
+        case 'isNotSet': return (psetVal ?? '').length === 0;
+        case 'eq': return fold(psetVal, opts?.caseSensitive) === fold(ruleVal, opts?.caseSensitive);
+        case 'ne': return fold(psetVal, opts?.caseSensitive) !== fold(ruleVal, opts?.caseSensitive);
+        case 'contains': return fold(psetVal, opts?.caseSensitive).includes(fold(ruleVal, opts?.caseSensitive));
+        case 'notContains': return !fold(psetVal, opts?.caseSensitive).includes(fold(ruleVal, opts?.caseSensitive));
+        case 'matches': return regexOpMatches(psetVal, ruleVal, valueKind);
+        case 'notMatches': return !regexOpMatches(psetVal, ruleVal, valueKind);
+        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, opts);
+        }
+    }
+}
+//# sourceMappingURL=filter-ops.js.map

package/dist/filter/filter-ops.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-ops.js","sourceRoot":"","sources":["../../src/filter/filter-ops.ts"],"names":[],"mappings":"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"}

package/dist/filter/filter-rule-guards.d.ts

@@ -0,0 +1,4 @@
+import type { FilterRule } from './filter-rules.js';
+export declare function isFilterRule(value: unknown): value is FilterRule;
+export declare function parseFilterRules(raw: unknown): FilterRule[];
+//# sourceMappingURL=filter-rule-guards.d.ts.map

package/dist/filter/filter-rule-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-rule-guards.d.ts","sourceRoot":"","sources":["../../src/filter/filter-rule-guards.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAoB,UAAU,EAAY,MAAM,mBAAmB,CAAC;AAUhF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CA6ChE;AASD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,EAAE,CAG3D"}