@katlux/providers 0.1.0-beta.2 → 0.1.0-beta.6

package/dist/index.cjs

@@ -1,8 +1,6 @@
 'use strict';
 
-const useDebounce = require('@katlux/toolkit/composables/useDebounce');
-const useFilterLogic = require('@katlux/toolkit/composables/useFilterLogic');
-const useSortLogic = require('@katlux/toolkit/composables/useSortLogic');
+const providers = require('@katlux/providers');
 
 var ECacheStrategy = /* @__PURE__ */ ((ECacheStrategy2) => {
   ECacheStrategy2["Application"] = "Application";
@@ -2863,6 +2861,18 @@ if (!!(process.env.NODE_ENV !== "production")) {
   initDev();
 }
 
+const useDebounce = (callback, delay) => {
+  let timeoutId = null;
+  return function(...args) {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      callback.apply(this, args);
+    }, delay);
+  };
+};
+
 const APP_MODULE = "#app";
 class ADataProvider {
   filter = ref(null);
@@ -2957,7 +2967,7 @@ class ADataProvider {
       this.currentPage.value = 1;
       this.loadPageData();
     });
-    watch(this.filter, useDebounce.useDebounce(() => {
+    watch(this.filter, useDebounce(() => {
       this.currentPage.value = 1;
       this.loadPageData();
     }, 300));
@@ -2980,8 +2990,234 @@ class ADataProvider {
   }
 }
 
-const { evaluateFilter: evaluateFilter$1, filterData: filterData$1 } = useFilterLogic.useFilterLogic();
-const { sortData } = useSortLogic.useSortLogic();
+const useFilterLogic = () => {
+  const evaluateFilter = (filter, row) => {
+    if (filter.operator === providers.EDataFilterOperator.And || filter.operator === providers.EDataFilterOperator.Or || filter.operator === providers.EDataFilterOperator.Nand || filter.operator === providers.EDataFilterOperator.Nor) {
+      return !filter.active || applyOperator(filter.operator, row, filter.field);
+    }
+    if ("operator" in filter.field && "field" in filter.field) {
+      return !filter.active || evaluateFilter(filter.field, row);
+    }
+    const field = filter.field;
+    const fieldKeys = Object.keys(field);
+    return !filter.active || fieldKeys.every((key) => {
+      const filterValue = field[key];
+      const rowValue = row[key];
+      return applyOperator(filter.operator, rowValue, filterValue);
+    });
+  };
+  const applyOperator = (operator, rowValue, filterValue) => {
+    switch (operator) {
+      case providers.EDataFilterOperator.And:
+        return compareAnd(rowValue, filterValue);
+      case providers.EDataFilterOperator.Or:
+        return compareOr(rowValue, filterValue);
+      case providers.EDataFilterOperator.Nand:
+        return !compareAnd(rowValue, filterValue);
+      case providers.EDataFilterOperator.Nor:
+        return !compareOr(rowValue, filterValue);
+      case providers.EDataFilterOperator.Equal:
+        return compareEqual(rowValue, filterValue);
+      case providers.EDataFilterOperator.NotEqual:
+        return !compareEqual(rowValue, filterValue);
+      case providers.EDataFilterOperator.GreaterThan:
+        return compareValues(rowValue, filterValue) > 0;
+      case providers.EDataFilterOperator.LessThan:
+        return compareValues(rowValue, filterValue) < 0;
+      case providers.EDataFilterOperator.GreaterThanOrEqual:
+        return compareValues(rowValue, filterValue) >= 0;
+      case providers.EDataFilterOperator.LessThanOrEqual:
+        return compareValues(rowValue, filterValue) <= 0;
+      case providers.EDataFilterOperator.In:
+        return compareIn(rowValue, filterValue);
+      case providers.EDataFilterOperator.NotIn:
+        return !compareIn(rowValue, filterValue);
+      default:
+        return compareEqual(rowValue, filterValue);
+    }
+  };
+  const compareAnd = (row, nested) => {
+    const subFilters = Array.isArray(nested) ? nested : nested && typeof nested === "object" ? Object.values(nested) : [];
+    const validFilters = subFilters.filter((f) => f && typeof f === "object" && "operator" in f && "field" in f);
+    if (validFilters.length === 0) return true;
+    return validFilters.every((f) => {
+      const active = f.active !== false;
+      return active ? evaluateFilter(f, row) : true;
+    });
+  };
+  const compareOr = (row, nested) => {
+    const subFilters = Array.isArray(nested) ? nested : nested && typeof nested === "object" ? Object.values(nested) : [];
+    const validFilters = subFilters.filter((f) => f && typeof f === "object" && "operator" in f && "field" in f);
+    const activeFilters = validFilters.filter((f) => f.active !== false);
+    if (activeFilters.length === 0) return true;
+    return activeFilters.some((f) => {
+      return evaluateFilter(f, row);
+    });
+  };
+  const compareIn = (rowValue, filterValue) => {
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.toLowerCase().includes(filterValue.toLowerCase());
+    }
+    return false;
+  };
+  const compareEqual = (rowValue, filterValue) => {
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.toLowerCase() == filterValue.toLowerCase();
+    }
+    if (typeof rowValue === "number" && typeof filterValue === "number") {
+      return rowValue === filterValue;
+    }
+    if (typeof rowValue === "boolean" && typeof filterValue === "boolean") {
+      return rowValue === filterValue;
+    }
+    return rowValue === filterValue;
+  };
+  const compareValues = (rowValue, filterValue) => {
+    if (rowValue == null || filterValue == null) {
+      return rowValue == null ? -1 : 1;
+    }
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.localeCompare(filterValue);
+    }
+    if (typeof rowValue === "number" && typeof filterValue === "number") {
+      return rowValue - filterValue;
+    }
+    return String(rowValue).localeCompare(String(filterValue));
+  };
+  const filterTreeData = (nodes, filter, options) => {
+    const { idKey, parentKey } = options;
+    const nodeMap = new Map(nodes.map((node) => [node[idKey], node]));
+    const childrenMap = /* @__PURE__ */ new Map();
+    nodes.forEach((node) => {
+      const pId = node[parentKey];
+      if (pId != null) {
+        if (!childrenMap.has(pId)) {
+          childrenMap.set(pId, []);
+        }
+        childrenMap.get(pId).push(node);
+      }
+    });
+    const matchingNodeIds = /* @__PURE__ */ new Set();
+    const expandedNodes = /* @__PURE__ */ new Set();
+    const visibleNodeIds = /* @__PURE__ */ new Set();
+    nodes.forEach((node) => {
+      const evalRow = node.data ? { ...node.data, ...node } : node;
+      if (evaluateFilter(filter, evalRow)) {
+        matchingNodeIds.add(node[idKey]);
+      }
+    });
+    const addDescendants = (nodeId) => {
+      const children = childrenMap.get(nodeId);
+      if (children && children.length > 0) {
+        expandedNodes.add(nodeId);
+        children.forEach((child) => {
+          visibleNodeIds.add(child[idKey]);
+          addDescendants(child[idKey]);
+        });
+      }
+    };
+    matchingNodeIds.forEach((id) => {
+      visibleNodeIds.add(id);
+      addDescendants(id);
+      let currentId = id;
+      while (currentId != null) {
+        visibleNodeIds.add(currentId);
+        const node = nodeMap.get(currentId);
+        if (node) {
+          if (node[parentKey] != null) {
+            expandedNodes.add(node[parentKey]);
+            currentId = node[parentKey];
+          } else {
+            currentId = null;
+          }
+        } else {
+          break;
+        }
+      }
+    });
+    const visibleNodes = nodes.filter((node) => visibleNodeIds.has(node[idKey]));
+    return {
+      visibleNodes,
+      expandedNodes
+    };
+  };
+  const filterData = (data, filter, options) => {
+    if (options?.treeOptions) {
+      const { visibleNodes, expandedNodes } = filterTreeData(
+        data,
+        filter,
+        options.treeOptions
+      );
+      return { results: visibleNodes, expandedNodes };
+    }
+    const results = data.filter((row) => evaluateFilter(filter, row));
+    return { results };
+  };
+  return {
+    evaluateFilter,
+    filterTreeData,
+    filterData
+  };
+};
+
+const useSortLogic = () => {
+  const sortData = (sortList, rows) => {
+    if (!sortList || sortList.length === 0 || !rows || rows.length === 0) {
+      return rows;
+    }
+    const sortedRows = [...rows];
+    const compare = (a, b) => {
+      for (const sort of sortList) {
+        const aVal = a[sort.field];
+        const bVal = b[sort.field];
+        if (aVal === null || aVal === void 0) {
+          if (bVal === null || bVal === void 0) continue;
+          return sort.direction === "asc" ? -1 : 1;
+        }
+        if (bVal === null || bVal === void 0) {
+          return sort.direction === "asc" ? 1 : -1;
+        }
+        if (aVal < bVal) {
+          return sort.direction === "asc" ? -1 : 1;
+        } else if (aVal > bVal) {
+          return sort.direction === "asc" ? 1 : -1;
+        }
+      }
+      return 0;
+    };
+    const merge = (left, right) => {
+      const result = [];
+      let leftIndex = 0;
+      let rightIndex = 0;
+      while (leftIndex < left.length && rightIndex < right.length) {
+        if (compare(left[leftIndex], right[rightIndex]) <= 0) {
+          result.push(left[leftIndex]);
+          leftIndex++;
+        } else {
+          result.push(right[rightIndex]);
+          rightIndex++;
+        }
+      }
+      return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
+    };
+    const mergeSort = (arr) => {
+      if (arr.length <= 1) {
+        return arr;
+      }
+      const mid = Math.floor(arr.length / 2);
+      const left = mergeSort(arr.slice(0, mid));
+      const right = mergeSort(arr.slice(mid));
+      return merge(left, right);
+    };
+    return mergeSort(sortedRows);
+  };
+  return {
+    sortData
+  };
+};
+
+const { filterData: filterData$1 } = useFilterLogic();
+const { sortData } = useSortLogic();
 class CFlatClientDataProvider extends ADataProvider {
   allData = ref([]);
   filteredData = ref([]);
@@ -4645,7 +4881,7 @@ class AAPIDataProvider {
   }
 }
 
-const { evaluateFilter, filterData } = useFilterLogic.useFilterLogic();
+const { filterData } = useFilterLogic();
 class CTreeClientDataProvider extends CFlatClientDataProvider {
   // Tree configuration
   parentKey = "parentId";

package/dist/index.mjs

@@ -1,6 +1,4 @@
-import { useDebounce } from '@katlux/toolkit/composables/useDebounce';
-import { useFilterLogic } from '@katlux/toolkit/composables/useFilterLogic';
-import { useSortLogic } from '@katlux/toolkit/composables/useSortLogic';
+import { EDataFilterOperator as EDataFilterOperator$1 } from '@katlux/providers';
 
 var ECacheStrategy = /* @__PURE__ */ ((ECacheStrategy2) => {
   ECacheStrategy2["Application"] = "Application";
@@ -2861,6 +2859,18 @@ if (!!(process.env.NODE_ENV !== "production")) {
   initDev();
 }
 
+const useDebounce = (callback, delay) => {
+  let timeoutId = null;
+  return function(...args) {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      callback.apply(this, args);
+    }, delay);
+  };
+};
+
 const APP_MODULE = "#app";
 class ADataProvider {
   filter = ref(null);
@@ -2978,7 +2988,233 @@ class ADataProvider {
   }
 }
 
-const { evaluateFilter: evaluateFilter$1, filterData: filterData$1 } = useFilterLogic();
+const useFilterLogic = () => {
+  const evaluateFilter = (filter, row) => {
+    if (filter.operator === EDataFilterOperator$1.And || filter.operator === EDataFilterOperator$1.Or || filter.operator === EDataFilterOperator$1.Nand || filter.operator === EDataFilterOperator$1.Nor) {
+      return !filter.active || applyOperator(filter.operator, row, filter.field);
+    }
+    if ("operator" in filter.field && "field" in filter.field) {
+      return !filter.active || evaluateFilter(filter.field, row);
+    }
+    const field = filter.field;
+    const fieldKeys = Object.keys(field);
+    return !filter.active || fieldKeys.every((key) => {
+      const filterValue = field[key];
+      const rowValue = row[key];
+      return applyOperator(filter.operator, rowValue, filterValue);
+    });
+  };
+  const applyOperator = (operator, rowValue, filterValue) => {
+    switch (operator) {
+      case EDataFilterOperator$1.And:
+        return compareAnd(rowValue, filterValue);
+      case EDataFilterOperator$1.Or:
+        return compareOr(rowValue, filterValue);
+      case EDataFilterOperator$1.Nand:
+        return !compareAnd(rowValue, filterValue);
+      case EDataFilterOperator$1.Nor:
+        return !compareOr(rowValue, filterValue);
+      case EDataFilterOperator$1.Equal:
+        return compareEqual(rowValue, filterValue);
+      case EDataFilterOperator$1.NotEqual:
+        return !compareEqual(rowValue, filterValue);
+      case EDataFilterOperator$1.GreaterThan:
+        return compareValues(rowValue, filterValue) > 0;
+      case EDataFilterOperator$1.LessThan:
+        return compareValues(rowValue, filterValue) < 0;
+      case EDataFilterOperator$1.GreaterThanOrEqual:
+        return compareValues(rowValue, filterValue) >= 0;
+      case EDataFilterOperator$1.LessThanOrEqual:
+        return compareValues(rowValue, filterValue) <= 0;
+      case EDataFilterOperator$1.In:
+        return compareIn(rowValue, filterValue);
+      case EDataFilterOperator$1.NotIn:
+        return !compareIn(rowValue, filterValue);
+      default:
+        return compareEqual(rowValue, filterValue);
+    }
+  };
+  const compareAnd = (row, nested) => {
+    const subFilters = Array.isArray(nested) ? nested : nested && typeof nested === "object" ? Object.values(nested) : [];
+    const validFilters = subFilters.filter((f) => f && typeof f === "object" && "operator" in f && "field" in f);
+    if (validFilters.length === 0) return true;
+    return validFilters.every((f) => {
+      const active = f.active !== false;
+      return active ? evaluateFilter(f, row) : true;
+    });
+  };
+  const compareOr = (row, nested) => {
+    const subFilters = Array.isArray(nested) ? nested : nested && typeof nested === "object" ? Object.values(nested) : [];
+    const validFilters = subFilters.filter((f) => f && typeof f === "object" && "operator" in f && "field" in f);
+    const activeFilters = validFilters.filter((f) => f.active !== false);
+    if (activeFilters.length === 0) return true;
+    return activeFilters.some((f) => {
+      return evaluateFilter(f, row);
+    });
+  };
+  const compareIn = (rowValue, filterValue) => {
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.toLowerCase().includes(filterValue.toLowerCase());
+    }
+    return false;
+  };
+  const compareEqual = (rowValue, filterValue) => {
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.toLowerCase() == filterValue.toLowerCase();
+    }
+    if (typeof rowValue === "number" && typeof filterValue === "number") {
+      return rowValue === filterValue;
+    }
+    if (typeof rowValue === "boolean" && typeof filterValue === "boolean") {
+      return rowValue === filterValue;
+    }
+    return rowValue === filterValue;
+  };
+  const compareValues = (rowValue, filterValue) => {
+    if (rowValue == null || filterValue == null) {
+      return rowValue == null ? -1 : 1;
+    }
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.localeCompare(filterValue);
+    }
+    if (typeof rowValue === "number" && typeof filterValue === "number") {
+      return rowValue - filterValue;
+    }
+    return String(rowValue).localeCompare(String(filterValue));
+  };
+  const filterTreeData = (nodes, filter, options) => {
+    const { idKey, parentKey } = options;
+    const nodeMap = new Map(nodes.map((node) => [node[idKey], node]));
+    const childrenMap = /* @__PURE__ */ new Map();
+    nodes.forEach((node) => {
+      const pId = node[parentKey];
+      if (pId != null) {
+        if (!childrenMap.has(pId)) {
+          childrenMap.set(pId, []);
+        }
+        childrenMap.get(pId).push(node);
+      }
+    });
+    const matchingNodeIds = /* @__PURE__ */ new Set();
+    const expandedNodes = /* @__PURE__ */ new Set();
+    const visibleNodeIds = /* @__PURE__ */ new Set();
+    nodes.forEach((node) => {
+      const evalRow = node.data ? { ...node.data, ...node } : node;
+      if (evaluateFilter(filter, evalRow)) {
+        matchingNodeIds.add(node[idKey]);
+      }
+    });
+    const addDescendants = (nodeId) => {
+      const children = childrenMap.get(nodeId);
+      if (children && children.length > 0) {
+        expandedNodes.add(nodeId);
+        children.forEach((child) => {
+          visibleNodeIds.add(child[idKey]);
+          addDescendants(child[idKey]);
+        });
+      }
+    };
+    matchingNodeIds.forEach((id) => {
+      visibleNodeIds.add(id);
+      addDescendants(id);
+      let currentId = id;
+      while (currentId != null) {
+        visibleNodeIds.add(currentId);
+        const node = nodeMap.get(currentId);
+        if (node) {
+          if (node[parentKey] != null) {
+            expandedNodes.add(node[parentKey]);
+            currentId = node[parentKey];
+          } else {
+            currentId = null;
+          }
+        } else {
+          break;
+        }
+      }
+    });
+    const visibleNodes = nodes.filter((node) => visibleNodeIds.has(node[idKey]));
+    return {
+      visibleNodes,
+      expandedNodes
+    };
+  };
+  const filterData = (data, filter, options) => {
+    if (options?.treeOptions) {
+      const { visibleNodes, expandedNodes } = filterTreeData(
+        data,
+        filter,
+        options.treeOptions
+      );
+      return { results: visibleNodes, expandedNodes };
+    }
+    const results = data.filter((row) => evaluateFilter(filter, row));
+    return { results };
+  };
+  return {
+    evaluateFilter,
+    filterTreeData,
+    filterData
+  };
+};
+
+const useSortLogic = () => {
+  const sortData = (sortList, rows) => {
+    if (!sortList || sortList.length === 0 || !rows || rows.length === 0) {
+      return rows;
+    }
+    const sortedRows = [...rows];
+    const compare = (a, b) => {
+      for (const sort of sortList) {
+        const aVal = a[sort.field];
+        const bVal = b[sort.field];
+        if (aVal === null || aVal === void 0) {
+          if (bVal === null || bVal === void 0) continue;
+          return sort.direction === "asc" ? -1 : 1;
+        }
+        if (bVal === null || bVal === void 0) {
+          return sort.direction === "asc" ? 1 : -1;
+        }
+        if (aVal < bVal) {
+          return sort.direction === "asc" ? -1 : 1;
+        } else if (aVal > bVal) {
+          return sort.direction === "asc" ? 1 : -1;
+        }
+      }
+      return 0;
+    };
+    const merge = (left, right) => {
+      const result = [];
+      let leftIndex = 0;
+      let rightIndex = 0;
+      while (leftIndex < left.length && rightIndex < right.length) {
+        if (compare(left[leftIndex], right[rightIndex]) <= 0) {
+          result.push(left[leftIndex]);
+          leftIndex++;
+        } else {
+          result.push(right[rightIndex]);
+          rightIndex++;
+        }
+      }
+      return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
+    };
+    const mergeSort = (arr) => {
+      if (arr.length <= 1) {
+        return arr;
+      }
+      const mid = Math.floor(arr.length / 2);
+      const left = mergeSort(arr.slice(0, mid));
+      const right = mergeSort(arr.slice(mid));
+      return merge(left, right);
+    };
+    return mergeSort(sortedRows);
+  };
+  return {
+    sortData
+  };
+};
+
+const { filterData: filterData$1 } = useFilterLogic();
 const { sortData } = useSortLogic();
 class CFlatClientDataProvider extends ADataProvider {
   allData = ref([]);
@@ -4643,7 +4879,7 @@ class AAPIDataProvider {
   }
 }
 
-const { evaluateFilter, filterData } = useFilterLogic();
+const { filterData } = useFilterLogic();
 class CTreeClientDataProvider extends CFlatClientDataProvider {
   // Tree configuration
   parentKey = "parentId";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@katlux/providers",
-	"version": "0.1.0-beta.2",
+	"version": "0.1.0-beta.6",
 	"description": "Core data calculation and caching providers for the Katlux ecosystem",
 	"author": "Katlux",
 	"license": "MIT",
@@ -11,7 +11,8 @@
 	"types": "./dist/index.d.ts",
 	"scripts": {
 		"build": "unbuild",
-		"dev": "unbuild --stub"
+		"dev": "unbuild --stub",
+		"prepublishOnly": "npm run build"
 	},
 	"exports": {
 		".": {
@@ -20,9 +21,7 @@
 			"require": "./dist/index.cjs"
 		}
 	},
-	"dependencies": {
-		"@katlux/toolkit": "*"
-	},
+	"dependencies": {},
 	"files": [
 		"dist"
 	]