@twinfinity/printing 5.0.3-ci.28538-beta

package/src/layout/filters.ts

@@ -0,0 +1,80 @@
+import { resolveProperty } from './renderUtils';
+
+import { isRecord, getProp } from './typeGuards';
+
+import type { WhereCondition } from './types';
+
+const normalizeClass = (cls: unknown): string | null => (typeof cls === 'string' ? cls.trim().toLowerCase() : null);
+
+/** Compare two class strings, treating the 'Ifc' prefix as optional.
+ *  e.g. "IfcSpace" matches "Space", "space", and "IfcSpace". */
+const classEquals = (a: string | null, b: string | null): boolean => {
+    if (a === null || b === null) return false;
+    if (a === b) return true;
+    // Try with/without Ifc prefix in both directions
+    const stripIfc = (s: string): string => (s.startsWith('ifc') ? s.slice(3) : s);
+    return stripIfc(a) === stripIfc(b);
+};
+const normalizeValue = (v: unknown): unknown => (typeof v === 'string' ? v.toLowerCase().trim() : v);
+
+/**
+ * Check whether an item's ifcClass matches the given class filter.
+ *
+ * Uses normalizeClass() for string comparison — works for extracted items
+ * where we have a normalized ifcClass string (not a live product).
+ *
+ * For live products, the caller should use product.class.is() directly.
+ */
+const matchesClass = (itemClass: unknown, classFilter: string | string[] | undefined): boolean => {
+    if (classFilter === undefined) return true;
+    const classes = Array.isArray(classFilter) ? classFilter : [classFilter];
+    const normalized = normalizeClass(itemClass);
+    if (normalized === null) return false;
+    return classes.some((c) => classEquals(normalizeClass(c), normalized));
+};
+
+/**
+ * Check whether an item matches a `where` condition.
+ *
+ * Each key in `where` is a short property path (e.g. "BIP.spacetype").
+ * Each value is either a scalar (equality check) or an array (any-of check).
+ * Multiple keys = AND. String comparison is case-insensitive.
+ */
+const matchesWhere = (item: unknown, where: WhereCondition | undefined): boolean => {
+    if (!where) return true;
+    for (const [path, expected] of Object.entries(where)) {
+        const value = resolveProperty(item, path);
+        if (Array.isArray(expected)) {
+            const target = normalizeValue(value);
+            if (!expected.some((v) => normalizeValue(v) === target)) return false;
+        } else {
+            if (normalizeValue(value) !== normalizeValue(expected)) return false;
+        }
+    }
+    return true;
+};
+
+/**
+ * V2 filter: match items by class + where conditions.
+ *
+ * @param item - An object with ifcClass and propertySets
+ * @param classFilter - IFC class name(s) to match, or undefined for any
+ * @param where - Property conditions (short paths), or undefined for no conditions
+ */
+export const matchesV2Filter = (
+    item: unknown,
+    classFilter: string | string[] | undefined,
+    where: WhereCondition | undefined
+): boolean => {
+    if (classFilter !== undefined && isRecord(item)) {
+        const itemClass = getProp(item, 'ifcClass');
+        const itemClassId = getProp(item, 'ifcClassId');
+        if (!matchesClass(itemClass, classFilter) && !matchesClass(itemClassId, classFilter)) {
+            return false;
+        }
+    }
+    if (!matchesWhere(item, where)) return false;
+    return true;
+};
+
+export { normalizeClass, classEquals, normalizeValue, matchesClass, matchesWhere };

package/src/layout/geometryConstants.ts

@@ -0,0 +1,11 @@
+/**
+ * Geometric computation constants
+ */
+
+// Epsilon values for floating-point comparisons
+export const EPSILON_INTERSECTION = 1e-9; // Used for detecting parallel lines
+export const EPSILON_DIVISION_SAFETY = 1e-9; // Used to prevent division by zero
+export const EPSILON_MIN_DIMENSION = 1e-6; // Minimum valid dimension for model bounds
+
+// Geometric multipliers
+export const CENTER_FRACTION = 0.5; // For calculating center/midpoint (x * 0.5)