bways-grid 0.0.5

package/src/lib/workers/sorting.worker.ts

@@ -0,0 +1,423 @@
+import { UltraGridNode, UltraGridLeafNode, UltraGridGroupNode, UltraGridRow, UltraGridGroupFooterNode } from '../models/row.model';
+
+let cachedRows: UltraGridLeafNode[] = [];
+let cachedResultTree: UltraGridNode[] = [];
+
+addEventListener('message', (event: MessageEvent) => {
+    const { action, rows, sortModel, filterModel, conditionFilters, groupModel, aggregations, groupStateMap } = event.data;
+
+    if (action === 'INIT') {
+        const mappedRows = rows || [];
+        cachedRows = mappedRows.map((r: any) => ({
+            ...r,
+            type: 'leaf',
+            level: 0
+        }));
+        postMessage({ action: 'INIT_DONE' });
+        return;
+    }
+
+    if (action === 'FLATTEN_ONLY') {
+        const flatList = flattenTree(cachedResultTree, groupStateMap || {}, event.data.groupIncludeFooter);
+        postMessage({ flatList });
+        return;
+    }
+
+    if (action === 'EXECUTE') {
+        let processed = cachedRows;
+
+        // 1. Apply Filtering if present
+        if (filterModel && Object.keys(filterModel).length > 0) {
+            const filterSets: { [key: string]: Set<any> } = {};
+            for (const field of Object.keys(filterModel)) {
+                filterSets[field] = new Set(filterModel[field]);
+            }
+
+            processed = processed.filter((row: UltraGridLeafNode) => {
+                for (const field of Object.keys(filterSets)) {
+                    const allowedValues = filterSets[field];
+                    const cellValue = row.data ? row.data[field] : null;
+                    if (!allowedValues.has(cellValue)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+
+        // 1b. Apply Condition Filters (Contains, Equals, Greater Than, etc.)
+        if (conditionFilters && Object.keys(conditionFilters).length > 0) {
+            processed = applyConditionFilters(processed, conditionFilters);
+        }
+
+        // 2. Apply Grouping and Aggregation if present
+        let resultTree: UltraGridNode[] = processed;
+        const aggs = aggregations || {};
+
+        if (groupModel && groupModel.length > 0) {
+            resultTree = buildTree(processed, groupModel, aggs);
+        } else {
+            processed.forEach(r => r.level = 0);
+        }
+
+        // 3. Apply Recursive Sorting
+        if (sortModel && sortModel.length > 0) {
+            sortTree(resultTree, sortModel);
+        }
+
+        // Cache the processed tree so toggle operations don't need to rebuild it
+        cachedResultTree = resultTree;
+
+        // 4. Compute Grand Total if grouping and footers are enabled
+        if (groupModel && groupModel.length > 0 && event.data.groupIncludeFooter && Object.keys(aggs).length > 0) {
+            const grandTotalData = computeAggregations(processed, aggs);
+            const grandTotalNode: UltraGridGroupFooterNode = {
+                id: 'grand-total-footer',
+                type: 'group-footer',
+                level: 0,
+                groupField: 'Grand Total',
+                groupKey: 'Grand Total',
+                data: grandTotalData
+            };
+            // Append grand total at the end of the root level resultTree
+            cachedResultTree.push(grandTotalNode as any); // Cast as any to bypass strict type check for now since GroupFooterNode is expected by flattener
+        }
+
+        // 5. Client-side Flattening
+        const flatList = flattenTree(cachedResultTree, groupStateMap || {}, event.data.groupIncludeFooter);
+
+        // Strip massive data payloads from leaf nodes before sending full tree back
+        const strippedTree = stripTreeData(cachedResultTree);
+
+        postMessage({ flatList, resultTree: strippedTree });
+    }
+});
+
+function stripTreeData(nodes: UltraGridNode[]): UltraGridNode[] {
+    return nodes.map(node => {
+        if (node.type === 'leaf') {
+            // Strip the heavy .data payload, the main thread will rehydrate it by ID
+            return {
+                id: node.id,
+                type: 'leaf',
+                level: node.level
+                // Notice: no .data
+            } as any;
+        } else if (node.type === 'group') {
+            const groupNode = node as UltraGridGroupNode;
+            return {
+                ...groupNode,
+                children: groupNode.children ? stripTreeData(groupNode.children) : undefined
+            } as any;
+        }
+        return node;
+    });
+}
+
+function flattenTree(nodes: UltraGridNode[], stateMap: { [key: string]: boolean }, groupIncludeFooter: boolean = false): any[] {
+    const result: any[] = [];
+
+    // Use an explicit stack to avoid recursion stack overflow with 200,000+ children
+    // Process in reverse order so items appear in correct order when popped
+    const stack: UltraGridNode[] = [];
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        stack.push(nodes[i]);
+    }
+
+    while (stack.length > 0) {
+        const node = stack.pop()!;
+
+        if (node.type === 'group') {
+            const groupNode = node as UltraGridGroupNode;
+            // Send a lightweight group header — strip the heavy `.children` array
+            result.push({
+                id: groupNode.id,
+                type: 'group',
+                level: groupNode.level,
+                groupField: groupNode.groupField,
+                groupKey: groupNode.groupKey,
+                data: groupNode.data,
+                childCount: groupNode.children ? groupNode.children.length : 0
+            });
+
+            const isExpanded = !!stateMap[groupNode.id as string];
+            if (isExpanded) {
+                if (groupIncludeFooter) {
+                    stack.push({
+                        id: `${groupNode.id}-footer`,
+                        type: 'group-footer',
+                        level: groupNode.level,
+                        groupField: groupNode.groupField,
+                        groupKey: groupNode.groupKey,
+                        data: { ...groupNode.data }
+                    } as any);
+                }
+                if (groupNode.children) {
+                    // Push children in reverse order so they come out in correct order
+                    for (let i = groupNode.children.length - 1; i >= 0; i--) {
+                        stack.push(groupNode.children[i]);
+                    }
+                }
+            }
+        } else if (node.type === 'group-footer') {
+            result.push({
+                id: node.id,
+                type: 'group-footer',
+                level: node.level,
+                groupField: (node as any).groupField,
+                groupKey: (node as any).groupKey,
+                data: node.data
+            });
+        } else {
+            // CRITICAL PERFORMANCE: Send only a lightweight reference for leaf nodes.
+            // The main thread already has the full `.data` object cached in `_mappedRowData`.
+            // Sending 200,000 full data objects via postMessage would force V8 to deep-clone
+            // ~50MB of JSON, freezing the browser for 3-5 seconds.
+            result.push({
+                id: node.id,
+                type: 'leaf',
+                level: node.level
+            });
+        }
+    }
+
+    return result;
+}
+
+function buildTree(
+    leaves: UltraGridLeafNode[],
+    groupModel: string[],
+    aggregations: { [field: string]: string }
+): UltraGridGroupNode[] {
+    return groupLevel(leaves, groupModel, 0, aggregations, 'root');
+}
+
+function groupLevel(
+    nodes: (UltraGridLeafNode | UltraGridGroupNode)[],
+    groupModel: string[],
+    level: number,
+    aggregations: { [field: string]: string },
+    parentPath: string
+): UltraGridGroupNode[] {
+    const field = groupModel[level];
+    const isLastLevel = level === groupModel.length - 1;
+
+    const buckets = new Map<any, (UltraGridLeafNode | UltraGridGroupNode)[]>();
+
+    // 1. Bucket the nodes
+    for (const node of nodes) {
+        // Only bucket leaf nodes based on their data. 
+        // If it's already a group node, we shouldn't be re-bucketing it unless we flatten first.
+        const key = node.data ? node.data[field] : null;
+
+        if (!buckets.has(key)) {
+            buckets.set(key, []);
+        }
+        buckets.get(key)!.push(node);
+    }
+
+    const result: UltraGridGroupNode[] = [];
+
+    // 2. Build group nodes from buckets
+    for (const [key, bucketNodes] of buckets.entries()) {
+        const groupId = `${parentPath}-${field}-${key}`;
+
+        const groupNode: UltraGridGroupNode = {
+            id: groupId,
+            type: 'group',
+            level: level,
+            groupField: field,
+            groupKey: key,
+            data: { [field]: key },
+            children: []
+        };
+
+        // Aggregation Step
+        const bucketAggData = computeAggregations(bucketNodes, aggregations);
+        Object.assign(groupNode.data, bucketAggData);
+
+        // Recursive children or direct assignment
+        if (!isLastLevel) {
+            groupNode.children = groupLevel(
+                bucketNodes,
+                groupModel,
+                level + 1,
+                aggregations,
+                groupId
+            );
+        } else {
+            // Assign leaf nodes, increment their level to sit below this group
+            bucketNodes.forEach(leaf => leaf.level = level + 1);
+            groupNode.children = bucketNodes;
+        }
+
+        result.push(groupNode);
+    }
+
+    return result;
+}
+
+function computeAggregations(
+    nodes: (UltraGridLeafNode | UltraGridGroupNode)[],
+    aggregations: { [field: string]: string }
+): any {
+    const resultData: any = {};
+
+    for (const aggField of Object.keys(aggregations)) {
+        const aggType = aggregations[aggField];
+
+        let aggValue = 0;
+        if (aggType === 'count') {
+            aggValue = nodes.length;
+        } else {
+            let first = true;
+            let sumForAvg = 0;
+            let countForAvg = 0;
+
+            for (const child of nodes) {
+                const val = child.data ? child.data[aggField] : 0;
+
+                // Robust numeric parsing: strip currency symbols, commas, spaces
+                let numVal = 0;
+                if (typeof val === 'number') {
+                    numVal = val;
+                } else if (typeof val === 'string') {
+                    numVal = Number(val.replace(/[^0-9.-]+/g, ""));
+                }
+
+                if (isNaN(numVal)) numVal = 0;
+
+                if (aggType === 'sum') {
+                    aggValue += numVal;
+                } else if (aggType === 'min') {
+                    if (first) aggValue = numVal;
+                    else aggValue = Math.min(aggValue, numVal);
+                } else if (aggType === 'max') {
+                    if (first) aggValue = numVal;
+                    else aggValue = Math.max(aggValue, numVal);
+                } else if (aggType === 'avg') {
+                    sumForAvg += numVal;
+                    countForAvg++;
+                }
+                first = false;
+            }
+
+            if (aggType === 'avg') {
+                aggValue = countForAvg > 0 ? sumForAvg / countForAvg : 0;
+            }
+        }
+        resultData[aggField] = aggValue;
+    }
+    return resultData;
+}
+
+function sortTree(nodes: UltraGridNode[], sortModel: { field: string, direction: 'asc' | 'desc' }[]) {
+    nodes.sort((a, b) => {
+        for (const sort of sortModel) {
+            const { field, direction } = sort;
+            const valA = a.data ? a.data[field] : null;
+            const valB = b.data ? b.data[field] : null;
+
+            if (valA === valB) continue;
+
+            const comparison = valA > valB ? 1 : -1;
+            return direction === 'asc' ? comparison : -comparison;
+        }
+        return 0;
+    });
+
+    for (const node of nodes) {
+        if (node.type === 'group' && (node as UltraGridGroupNode).children) {
+            sortTree((node as UltraGridGroupNode).children, sortModel);
+        }
+    }
+}
+
+// --- Condition Filter Engine ---
+
+function applyConditionFilters(
+    rows: UltraGridLeafNode[],
+    conditionFilters: { [field: string]: any }
+): UltraGridLeafNode[] {
+    const fields = Object.keys(conditionFilters);
+    if (fields.length === 0) return rows;
+
+    return rows.filter(row => {
+        for (const field of fields) {
+            const filter = conditionFilters[field];
+            if (!filter || !filter.condition1) continue;
+
+            const cellValue = row.data ? row.data[field] : null;
+            const result1 = evaluateCondition(cellValue, filter.condition1);
+
+            if (filter.condition2 && filter.condition2.type) {
+                const result2 = evaluateCondition(cellValue, filter.condition2);
+                const combined = filter.operator === 'OR'
+                    ? (result1 || result2)
+                    : (result1 && result2);
+                if (!combined) return false;
+            } else {
+                if (!result1) return false;
+            }
+        }
+        return true;
+    });
+}
+
+function evaluateCondition(cellValue: any, condition: { type: string; value?: string; valueTo?: string }): boolean {
+    const { type, value, valueTo } = condition;
+
+    // Blank / Not Blank work without a value
+    if (type === 'blank') {
+        return cellValue === null || cellValue === undefined || cellValue === '';
+    }
+    if (type === 'notBlank') {
+        return cellValue !== null && cellValue !== undefined && cellValue !== '';
+    }
+
+    // For all other types, if no filter value is entered, pass the row through
+    if (value === undefined || value === null || value === '') return true;
+
+    const cellStr = String(cellValue ?? '').toLowerCase();
+    const filterStr = String(value).toLowerCase();
+
+    switch (type) {
+        // --- Text conditions ---
+        case 'contains':
+            return cellStr.includes(filterStr);
+        case 'notContains':
+            return !cellStr.includes(filterStr);
+        case 'equals':
+            // Try numeric comparison first, fall back to string
+            if (!isNaN(Number(cellValue)) && !isNaN(Number(value))) {
+                return Number(cellValue) === Number(value);
+            }
+            return cellStr === filterStr;
+        case 'notEqual':
+            if (!isNaN(Number(cellValue)) && !isNaN(Number(value))) {
+                return Number(cellValue) !== Number(value);
+            }
+            return cellStr !== filterStr;
+        case 'startsWith':
+            return cellStr.startsWith(filterStr);
+        case 'endsWith':
+            return cellStr.endsWith(filterStr);
+
+        // --- Number conditions ---
+        case 'greaterThan':
+            return Number(cellValue) > Number(value);
+        case 'greaterThanOrEqual':
+            return Number(cellValue) >= Number(value);
+        case 'lessThan':
+            return Number(cellValue) < Number(value);
+        case 'lessThanOrEqual':
+            return Number(cellValue) <= Number(value);
+        case 'inRange':
+            if (valueTo === undefined || valueTo === null || valueTo === '') return true;
+            const num = Number(cellValue);
+            return num >= Number(value) && num <= Number(valueTo);
+
+        default:
+            return true;
+    }
+}