@vuu-ui/vuu-data-local 2.1.18 → 2.1.19-beta.2

package/package.json

@@ -1,34 +1,31 @@
 {
-  "version": "2.1.18",
+  "version": "2.1.19-beta.2",
   "author": "heswell",
+  "type": "module",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "2.1.18",
-    "@vuu-ui/vuu-table-types": "2.1.18",
-    "@vuu-ui/vuu-filter-types": "2.1.18",
-    "@vuu-ui/vuu-protocol-types": "2.1.18"
+    "@vuu-ui/vuu-data-types": "2.1.19-beta.2",
+    "@vuu-ui/vuu-table-types": "2.1.19-beta.2",
+    "@vuu-ui/vuu-filter-types": "2.1.19-beta.2",
+    "@vuu-ui/vuu-protocol-types": "2.1.19-beta.2"
   },
   "dependencies": {
-    "@vuu-ui/vuu-filter-parser": "2.1.18",
-    "@vuu-ui/vuu-utils": "2.1.18"
+    "@vuu-ui/vuu-filter-parser": "2.1.19-beta.2",
+    "@vuu-ui/vuu-utils": "2.1.19-beta.2"
   },
   "sideEffects": false,
   "files": [
     "README.md",
-    "esm",
-    "cjs",
+    "src",
     "/types"
   ],
   "exports": {
     ".": {
-      "require": "./cjs/index.js",
-      "import": "./esm/index.js",
+      "import": "./src/index.js",
       "types": "./types/index.d.ts"
     }
   },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
+  "module": "index.js",
   "name": "@vuu-ui/vuu-data-local",
-  "type": "module",
   "types": "types/index.d.ts"
 }

package/src/array-data-source/aggregate-utils.js

@@ -0,0 +1,121 @@
+const aggregate_utils_count = (arr)=>arr.length;
+const aggregateData = (aggregations, targetData, groupBy, leafData, columnMap, groupMap)=>{
+    const aggType = aggregations[aggregations.length - 1].aggType;
+    const groupIndices = groupBy.map((column)=>columnMap[column]);
+    switch(aggType){
+        case 1:
+            return aggregateSum(groupMap, leafData, columnMap, aggregations, targetData, groupIndices);
+        case 2:
+            return aggregateAverage(groupMap, leafData, columnMap, aggregations, targetData, groupIndices);
+        case 3:
+            return aggregateCount(groupMap, columnMap, aggregations, targetData, groupIndices);
+        case 4:
+            return aggregateHigh(groupMap, leafData, columnMap, aggregations, targetData, groupIndices);
+        case 5:
+            return aggregateLow(groupMap, leafData, columnMap, aggregations, targetData, groupIndices);
+        case 6:
+            return aggregateDistinct(groupMap, leafData, columnMap, aggregations, targetData, groupIndices);
+    }
+};
+function aggregateCount(groupMap, columnMap, aggregations, targetData, groupIndices) {
+    const counts = {};
+    const aggColumn = getAggColumn(columnMap, aggregations);
+    function countRecursive(map) {
+        if (Array.isArray(map)) return map.length;
+        {
+            let count = 0;
+            for(const key in map)count += 1 + countRecursive(map[key]);
+            return count;
+        }
+    }
+    for(const key in groupMap){
+        const count = countRecursive(groupMap[key]);
+        counts[key] = count;
+    }
+    for(let index = 0; index < targetData.length; index++)for(const key in counts)if (targetData[index][groupIndices[0]] === key) targetData[index][aggColumn] = counts[key];
+    return counts;
+}
+function getAggColumn(columnMap, aggregations) {
+    const columnName = aggregations[aggregations.length - 1].column;
+    const columnNumber = columnMap[columnName];
+    return columnNumber;
+}
+function aggregateSum(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+    const sums = {};
+    const aggColumn = getAggColumn(columnMap, aggregations);
+    function sumRecursive(map, leafData, aggColumn) {
+        if (Array.isArray(map)) {
+            let sum = 0;
+            for (const key of map)sum += Number(leafData[key][aggColumn]);
+            return sum;
+        }
+        {
+            let sum = 0;
+            for(const key in map)sum += sumRecursive(map[key], leafData, aggColumn);
+            return sum;
+        }
+    }
+    for(const key in groupMap){
+        const sum = Number(sumRecursive(groupMap[key], leafData, aggColumn));
+        sums[key] = sum;
+    }
+    for(let index = 0; index < targetData.length; index++)for(const key in sums)if (targetData[index][groupIndices[0]] === key) targetData[index][aggColumn] = sums[key];
+    return sums;
+}
+function aggregateAverage(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+    const averages = {};
+    const aggColumn = getAggColumn(columnMap, aggregations);
+    const count = aggregateCount(groupMap, columnMap, aggregations, targetData, groupIndices);
+    const sum = aggregateSum(groupMap, leafData, columnMap, aggregations, targetData, groupIndices);
+    for(const key in count){
+        let average = 0;
+        average = sum[key] / count[key];
+        averages[key] = average;
+    }
+    for(let index = 0; index < targetData.length; index++)for(const key in averages)if (targetData[index][groupIndices[0]] === key) targetData[index][aggColumn] = averages[key];
+    console.log("!!!! targetData", targetData);
+    console.log("!!!! averages", averages);
+    return averages;
+}
+function getLeafColumnData(map, leafData, aggColumn) {
+    const data = [];
+    if (Array.isArray(map)) for (const key of map)data.push(leafData[key][aggColumn]);
+    else for(const key in map)data.push(...getLeafColumnData(map[key], leafData, aggColumn));
+    return data;
+}
+function aggregateDistinct(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+    const distincts = {};
+    const aggColumn = getAggColumn(columnMap, aggregations);
+    for(const key in groupMap){
+        const leafColumnData = getLeafColumnData(groupMap[key], leafData, aggColumn);
+        const distinct = [
+            ...new Set(leafColumnData)
+        ];
+        distincts[key] = distinct.length;
+    }
+    for(let index = 0; index < targetData.length; index++)for(const key in distincts)if (targetData[index][groupIndices[0]] === key) targetData[index][aggColumn] = distincts[key];
+    return distincts;
+}
+function aggregateHigh(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+    const highs = {};
+    const aggColumn = getAggColumn(columnMap, aggregations);
+    for(const key in groupMap){
+        const leafColumnData = getLeafColumnData(groupMap[key], leafData, aggColumn);
+        const maxNumber = Math.max(...leafColumnData);
+        highs[key] = maxNumber;
+    }
+    for(let index = 0; index < targetData.length; index++)for(const key in highs)if (targetData[index][groupIndices[0]] === key) targetData[index][aggColumn] = highs[key];
+    return highs;
+}
+function aggregateLow(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
+    const mins = {};
+    const aggColumn = getAggColumn(columnMap, aggregations);
+    for(const key in groupMap){
+        const leafColumnData = getLeafColumnData(groupMap[key], leafData, aggColumn);
+        const minNumber = Math.min(...leafColumnData);
+        mins[key] = minNumber;
+    }
+    for(let index = 0; index < targetData.length; index++)for(const key in mins)if (targetData[index][groupIndices[0]] === key) targetData[index][aggColumn] = mins[key];
+    return mins;
+}
+export { aggregateData, aggregate_utils_count as count };