@katlux/providers 0.1.0-alpha.81

package/dist/index.cjs

@@ -0,0 +1,2763 @@
+'use strict';
+
+const vue = require('vue');
+const nuxtAppCompat = require('@katlux/providers/nuxtAppCompat');
+const providers = require('@katlux/providers');
+const h3 = require('h3');
+const ofetch = require('ofetch');
+
+var EDataFilterOperator = /* @__PURE__ */ ((EDataFilterOperator2) => {
+  EDataFilterOperator2["Equal"] = "==";
+  EDataFilterOperator2["NotEqual"] = "!=";
+  EDataFilterOperator2["GreaterThan"] = ">";
+  EDataFilterOperator2["LessThan"] = "<";
+  EDataFilterOperator2["GreaterThanOrEqual"] = ">=";
+  EDataFilterOperator2["LessThanOrEqual"] = "<=";
+  EDataFilterOperator2["In"] = "in";
+  EDataFilterOperator2["NotIn"] = "nin";
+  EDataFilterOperator2["And"] = "and";
+  EDataFilterOperator2["Or"] = "or";
+  EDataFilterOperator2["Nand"] = "nand";
+  EDataFilterOperator2["Nor"] = "nor";
+  return EDataFilterOperator2;
+})(EDataFilterOperator || {});
+var ECacheStrategy = /* @__PURE__ */ ((ECacheStrategy2) => {
+  ECacheStrategy2["Application"] = "Application";
+  ECacheStrategy2["Session"] = "Session";
+  ECacheStrategy2["Memory"] = "Memory";
+  ECacheStrategy2["LocalStorage"] = "LocalStorage";
+  ECacheStrategy2["IndexedDB"] = "IndexedDB";
+  ECacheStrategy2["Cookie"] = "Cookie";
+  return ECacheStrategy2;
+})(ECacheStrategy || {});
+
+const useDebounce = (callback, delay) => {
+  let timeoutId = null;
+  return function(...args) {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      callback.apply(this, args);
+    }, delay);
+  };
+};
+
+class ADataProvider {
+  filter = vue.ref(null);
+  sortList = vue.ref([]);
+  currentPage = vue.ref(1);
+  pageSize = vue.ref(10);
+  pageData = vue.ref([]);
+  rowCount = vue.ref(0);
+  loading = vue.ref(false);
+  SSR = vue.ref(false);
+  deduplicate = vue.ref(true);
+  nuxtApp = null;
+  urlPageParam = vue.ref("");
+  selectedRows = vue.ref([]);
+  selectAll = vue.ref(false);
+  constructor(options) {
+    if (options?.nuxtApp) {
+      this.nuxtApp = options.nuxtApp;
+    } else if (undefined) {
+      try {
+        this.nuxtApp = nuxtAppCompat.getNuxtApp();
+      } catch {
+      }
+    }
+    if (options?.filter) {
+      this.filter.value = options.filter;
+    }
+    if (options?.sortList) {
+      this.sortList.value = options.sortList;
+    }
+    if (options?.pageSize) {
+      this.pageSize.value = options.pageSize;
+    }
+    if (options?.currentPage) {
+      this.currentPage.value = options.currentPage;
+    }
+    if (options?.SSR) {
+      this.SSR.value = options.SSR;
+    }
+    if (options?.deduplicate !== void 0) {
+      this.deduplicate.value = options.deduplicate;
+    }
+    if (options?.urlPageParam) {
+      this.urlPageParam.value = options.urlPageParam;
+      if (undefined) {
+        try {
+          const route = nuxtAppCompat.getRoute();
+          if (route) {
+            const pageFromUrl = route.query[options.urlPageParam];
+            if (pageFromUrl) {
+              const parsedPage = parseInt(pageFromUrl, 10);
+              if (!isNaN(parsedPage) && parsedPage > 0) {
+                this.currentPage.value = parsedPage;
+              }
+            }
+          }
+        } catch (e) {
+        }
+      }
+    }
+    vue.watch(this.currentPage, (newPage) => {
+      this.loadPageData();
+      if (undefined && this.urlPageParam.value) {
+        try {
+          const router = nuxtAppCompat.getRouter();
+          if (router) {
+            const currentQuery = { ...router.currentRoute.value.query };
+            if (newPage === 1) {
+              delete currentQuery[this.urlPageParam.value];
+            } else {
+              currentQuery[this.urlPageParam.value] = String(newPage);
+            }
+            router.replace({ query: currentQuery });
+          }
+        } catch (e) {
+        }
+      }
+    });
+    vue.watch(this.pageSize, () => {
+      this.currentPage.value = 1;
+      this.loadPageData();
+    });
+    vue.watch(this.filter, useDebounce(() => {
+      this.currentPage.value = 1;
+      this.loadPageData();
+    }, 300));
+    vue.watch(this.sortList, () => {
+      this.currentPage.value = 1;
+      this.loadPageData();
+    });
+  }
+  setFilter(filter) {
+    this.filter.value = filter;
+  }
+  setSortList(sortList) {
+    this.sortList.value = sortList;
+  }
+  setCurrentPage(currentPage) {
+    this.currentPage.value = currentPage;
+  }
+  setPageSize(pageSize) {
+    this.pageSize.value = pageSize;
+  }
+  async refresh(hardRefresh = false) {
+    this.loadPageData();
+  }
+}
+
+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 = vue.ref([]);
+  filteredData = vue.ref([]);
+  constructor(options) {
+    super(options);
+  }
+  setData(data) {
+    this.allData.value = [...data];
+    this.loadPageData();
+  }
+  async loadPageData() {
+    if (!this.filter.value) {
+      this.filteredData.value = this.allData.value;
+    } else {
+      const { results } = filterData$1(this.allData.value, this.filter.value);
+      this.filteredData.value = results;
+    }
+    this.rowCount.value = this.filteredData.value.length;
+    if (this.sortList.value.length > 0)
+      this.filteredData.value = sortData(this.sortList.value, this.filteredData.value);
+    if (this.pageSize.value <= 0) {
+      this.pageData.value = this.filteredData.value;
+    } else {
+      const startIndex = (this.currentPage.value - 1) * this.pageSize.value;
+      const endIndex = startIndex + this.pageSize.value;
+      this.pageData.value = this.filteredData.value.slice(startIndex, endIndex);
+    }
+  }
+}
+
+class ACacheProvider {
+  constructor() {
+    this.cleanupExpired();
+  }
+}
+
+class CApplicationCache extends ACacheProvider {
+  static instance = null;
+  static _storage = null;
+  static get storage() {
+    if (!this._storage) {
+      this._storage = /* @__PURE__ */ new Map();
+    }
+    return this._storage;
+  }
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CApplicationCache();
+    }
+    return this.instance;
+  }
+  static getSnapshot() {
+    return this.storage;
+  }
+  constructor() {
+    super();
+  }
+  async getKeyList(nuxtApp) {
+    const prefix = "cache:";
+    const storage = CApplicationCache.storage;
+    return Array.from(storage.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+  }
+  async get(key, nuxtApp) {
+    if (undefined) {
+      const prefixedKey = "cache:" + key;
+      const storage = CApplicationCache.storage;
+      const entry = storage.get(prefixedKey);
+      if (!entry) return null;
+      if (Date.now() - entry.timestamp > entry.lifetime) {
+        storage.delete(prefixedKey);
+        return null;
+      }
+      return entry.data;
+    }
+    return null;
+  }
+  async set(key, data, lifetime, nuxtApp) {
+    if (undefined) {
+      const prefixedKey = "cache:" + key;
+      const storage = CApplicationCache.storage;
+      storage.set(prefixedKey, {
+        data,
+        timestamp: Date.now(),
+        lifetime
+      });
+    }
+  }
+  async remove(key, nuxtApp) {
+    if (undefined) {
+      const prefixedKey = "cache:" + key;
+      CApplicationCache.storage.delete(prefixedKey);
+    }
+  }
+  async removeByPrefix(prefix, nuxtApp) {
+    if (undefined) {
+      const fullPrefix = "cache:" + prefix;
+      const storage = CApplicationCache.storage;
+      const keysToDelete = [];
+      for (const key of storage.keys()) {
+        if (key.startsWith(fullPrefix)) {
+          keysToDelete.push(key);
+        }
+      }
+      for (const key of keysToDelete) {
+        storage.delete(key);
+      }
+    }
+  }
+  async getRemainingTime(key, nuxtApp) {
+    if (undefined) {
+      const prefixedKey = "cache:" + key;
+      const storage = CApplicationCache.storage;
+      const entry = storage.get(prefixedKey);
+      if (!entry) return null;
+      return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+    }
+    return null;
+  }
+  async cleanupExpired() {
+    if (undefined) {
+      const prefix = "cache:";
+      const now = Date.now();
+      const storage = CApplicationCache.storage;
+      const keysToDelete = [];
+      for (const [key, entry] of storage.entries()) {
+        if (key.startsWith(prefix)) {
+          if (now - entry.timestamp > entry.lifetime) {
+            keysToDelete.push(key);
+          }
+        }
+      }
+      for (const key of keysToDelete) {
+        storage.delete(key);
+      }
+    }
+  }
+}
+
+class CMemoryCache extends ACacheProvider {
+  static instance = null;
+  static _storage = null;
+  static get storage() {
+    if (!this._storage) this._storage = /* @__PURE__ */ new Map();
+    return this._storage;
+  }
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CMemoryCache();
+    }
+    return this.instance;
+  }
+  constructor() {
+    super();
+    if (undefined && CMemoryCache.storage.size === 0) {
+      this._hydrateFromPayload();
+    }
+  }
+  async _hydrateFromPayload() {
+    try {
+      const nuxtApp = await nuxtAppCompat.getNuxtApp();
+      const payloadData = nuxtApp?.payload?.data || globalThis.__NUXT__?.payload?.data;
+      if (!payloadData) return;
+      for (const key in payloadData) {
+        const value = payloadData[key];
+        if (value && typeof value === "object" && "data" in value && "timestamp" in value && "lifetime" in value) {
+          if (typeof value.lifetime === "number") {
+            CMemoryCache.storage.set(key, value);
+          }
+        }
+      }
+    } catch (e) {
+    }
+  }
+  async getKeyList(nuxtApp) {
+    const prefix = "cache:";
+    return Array.from(CMemoryCache.storage.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+  }
+  async get(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      const entry = CMemoryCache.storage.get(prefixedKey);
+      if (entry) {
+        if (Date.now() - entry.timestamp <= entry.lifetime) {
+          return entry.data;
+        } else {
+          CMemoryCache.storage.delete(prefixedKey);
+        }
+      }
+    }
+    try {
+      let payloadData = null;
+      if (undefined) {
+        payloadData = globalThis.__NUXT__?.payload?.data;
+      } else if (nuxtApp) {
+        payloadData = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+      }
+      if (payloadData && payloadData[prefixedKey]) {
+        const entry = payloadData[prefixedKey];
+        if (Date.now() - entry.timestamp <= entry.lifetime) {
+          if (undefined) {
+            CMemoryCache.storage.set(prefixedKey, entry);
+          }
+          return entry.data;
+        }
+      }
+    } catch (e) {
+    }
+    return null;
+  }
+  async set(key, data, lifetime, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      lifetime
+    };
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload) {
+          payload[prefixedKey] = entry;
+        }
+      } catch (e) {
+      }
+    }
+    if (undefined) {
+      CMemoryCache.storage.set(prefixedKey, entry);
+    }
+  }
+  async remove(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    CMemoryCache.storage.delete(prefixedKey);
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload && payload[prefixedKey]) {
+          delete payload[prefixedKey];
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async removeByPrefix(prefix, nuxtApp) {
+    const fullPrefix = "cache:" + prefix;
+    const keysToDelete = [];
+    for (const key of CMemoryCache.storage.keys()) {
+      if (key.startsWith(fullPrefix)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      CMemoryCache.storage.delete(key);
+    }
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload) {
+          for (const key in payload) {
+            if (key.startsWith(fullPrefix)) {
+              delete payload[key];
+            }
+          }
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async getRemainingTime(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    const entry = CMemoryCache.storage.get(prefixedKey);
+    if (!entry) return null;
+    return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+  }
+  async cleanupExpired() {
+    const prefix = "cache:";
+    const now = Date.now();
+    const keysToDelete = [];
+    for (const [key, entry] of CMemoryCache.storage.entries()) {
+      if (key.startsWith(prefix)) {
+        if (now - entry.timestamp > entry.lifetime) {
+          keysToDelete.push(key);
+        }
+      }
+    }
+    for (const key of keysToDelete) {
+      CMemoryCache.storage.delete(key);
+    }
+  }
+}
+
+class CLocalStorageCache extends ACacheProvider {
+  static instance = null;
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CLocalStorageCache();
+    }
+    return this.instance;
+  }
+  type = "LocalStorage";
+  constructor() {
+    super();
+    if (undefined) {
+      this._hydrateFromPayload();
+    }
+  }
+  async _hydrateFromPayload() {
+    try {
+      const nuxtApp = await nuxtAppCompat.getNuxtApp();
+      const payloadData = nuxtApp?.payload?.data || window.__NUXT__?.payload?.data;
+      if (!payloadData) return;
+      const prefix = "cache:";
+      let count = 0;
+      for (const key in payloadData) {
+        if (key.startsWith(prefix)) {
+          const value = payloadData[key];
+          if (value && typeof value === "object" && "data" in value && "timestamp" in value && "lifetime" in value) {
+            try {
+              localStorage.setItem(key, JSON.stringify(value));
+              count++;
+            } catch (e) {
+            }
+          }
+        }
+      }
+      if (count > 0) console.log(`[CLocalStorageCache] Hydrated ${count} entries from payload`);
+    } catch (e) {
+    }
+  }
+  async getKeyList(nuxtApp) {
+    if (!undefined) return [];
+    const prefix = "cache:";
+    return Object.keys(localStorage).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+  }
+  async get(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      try {
+        const stored = localStorage.getItem(prefixedKey);
+        if (stored) {
+          const entry = JSON.parse(stored);
+          if (Date.now() - entry.timestamp <= entry.lifetime) {
+            console.log(`[CLocalStorageCache] GET SUCCESS: ${key}`);
+            return entry.data;
+          } else {
+            console.log(`[CLocalStorageCache] EXPIRED: ${key}`);
+            localStorage.removeItem(prefixedKey);
+          }
+        } else {
+          console.log(`[CLocalStorageCache] NOT IN STORAGE: ${key}`);
+        }
+      } catch (e) {
+      }
+    }
+    try {
+      let payloadData = null;
+      if (undefined) {
+        payloadData = window.__NUXT__?.payload?.data;
+      } else if (nuxtApp) {
+        payloadData = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+      }
+      if (payloadData && payloadData[prefixedKey]) {
+        const entry = payloadData[prefixedKey];
+        if (Date.now() - entry.timestamp <= entry.lifetime) {
+          if (undefined) {
+            localStorage.setItem(prefixedKey, JSON.stringify(entry));
+          }
+          return entry.data;
+        }
+      }
+    } catch (e) {
+    }
+    return null;
+  }
+  async set(key, data, lifetime, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      lifetime
+    };
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload) {
+          payload[prefixedKey] = entry;
+        }
+      } catch (e) {
+      }
+    }
+    if (undefined) {
+      try {
+        localStorage.setItem(prefixedKey, JSON.stringify(entry));
+      } catch (e) {
+      }
+    }
+  }
+  async remove(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      localStorage.removeItem(prefixedKey);
+    }
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload && payload[prefixedKey]) {
+          delete payload[prefixedKey];
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async removeByPrefix(prefix, nuxtApp) {
+    const fullPrefix = "cache:" + prefix;
+    if (undefined) {
+      const keysToDelete = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && key.startsWith(fullPrefix)) {
+          keysToDelete.push(key);
+        }
+      }
+      for (const key of keysToDelete) {
+        localStorage.removeItem(key);
+      }
+    }
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload) {
+          for (const key in payload) {
+            if (key.startsWith(fullPrefix)) {
+              delete payload[key];
+            }
+          }
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async getRemainingTime(key, nuxtApp) {
+    if (undefined) {
+      const prefixedKey = "cache:" + key;
+      const entryStr = localStorage.getItem(prefixedKey);
+      if (!entryStr) return null;
+      try {
+        const entry = JSON.parse(entryStr);
+        return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+      } catch (e) {
+        return null;
+      }
+    }
+    return null;
+  }
+  async cleanupExpired() {
+    if (undefined) {
+      try {
+        const prefix = "cache:";
+        const now = Date.now();
+        const keysToDelete = [];
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key && key.startsWith(prefix)) {
+            const stored = localStorage.getItem(key);
+            if (stored) {
+              try {
+                const entry = JSON.parse(stored);
+                if (now - entry.timestamp > entry.lifetime) {
+                  keysToDelete.push(key);
+                }
+              } catch (e) {
+                keysToDelete.push(key);
+              }
+            }
+          }
+        }
+        for (const key of keysToDelete) {
+          localStorage.removeItem(key);
+        }
+      } catch (e) {
+      }
+    }
+  }
+}
+
+class CIndexedDBCache extends ACacheProvider {
+  static instance = null;
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CIndexedDBCache();
+    }
+    return this.instance;
+  }
+  dbName = "KatluxDB";
+  storeName = "cache";
+  version = 2;
+  dbPromise = null;
+  setStore(storeName = "cache") {
+    this.storeName = storeName || "cache";
+    if (undefined) {
+      this.dbPromise = this.openDB();
+      this._hydrateFromPayload();
+    }
+  }
+  constructor() {
+    super();
+    this.setStore();
+  }
+  async _hydrateFromPayload() {
+    try {
+      const nuxtApp = await nuxtAppCompat.getNuxtApp();
+      const payloadData = nuxtApp?.payload?.data || globalThis.__NUXT__?.payload?.data;
+      if (!payloadData) return;
+      const prefix = "cache:";
+      let count = 0;
+      for (const key in payloadData) {
+        if (key.startsWith(prefix)) {
+          const value = payloadData[key];
+          if (value && typeof value === "object" && "data" in value && "timestamp" in value && "lifetime" in value) {
+            this.dbPromise?.then(async (db) => {
+              try {
+                const tx = db.transaction(this.storeName, "readwrite");
+                const store = tx.objectStore(this.storeName);
+                store.put(value, key);
+                tx.commit?.();
+              } catch (e) {
+              }
+            });
+            count++;
+          }
+        }
+      }
+      if (count > 0) console.log(`[CIndexedDBCache] Hydrated ${count} entries from payload`);
+    } catch (e) {
+    }
+  }
+  openDB() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.version);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+    });
+  }
+  async getStore(mode) {
+    if (!this.dbPromise) return Promise.reject("IndexedDB not initialized");
+    const db = await this.dbPromise;
+    return db.transaction(this.storeName, mode).objectStore(this.storeName);
+  }
+  async getKeyList(nuxtApp) {
+    if (!undefined || !this.dbPromise) return [];
+    const db = await this.dbPromise;
+    const store = db.transaction(this.storeName, "readonly").objectStore(this.storeName);
+    const keys = await new Promise((resolve, reject) => {
+      const req = store.getAllKeys();
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+    const prefix = "cache:";
+    return keys.filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+  }
+  async get(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      try {
+        const store = await this.getStore("readonly");
+        const data = await new Promise((resolve, reject) => {
+          const req = store.get(prefixedKey);
+          req.onsuccess = () => resolve(req.result);
+          req.onerror = () => reject(req.error);
+        });
+        if (data) {
+          if (Date.now() - data.timestamp <= data.lifetime) {
+            console.log(`[CIndexedDBCache] GET SUCCESS: ${key}`);
+            return data.data;
+          } else {
+            console.log(`[CIndexedDBCache] EXPIRED: ${key}`);
+            const writeStore = await this.getStore("readwrite");
+            writeStore.delete(prefixedKey);
+          }
+        } else {
+          console.log(`[CIndexedDBCache] NOT IN DB: ${key}`);
+        }
+      } catch (e) {
+      }
+    }
+    try {
+      let payloadData = null;
+      if (undefined) {
+        payloadData = globalThis.__NUXT__?.payload?.data;
+      } else if (nuxtApp) {
+        payloadData = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+      }
+      if (payloadData && payloadData[prefixedKey]) {
+        const entry = payloadData[prefixedKey];
+        if (Date.now() - entry.timestamp <= entry.lifetime) {
+          if (undefined) {
+            this.set(key, entry.data, entry.lifetime, nuxtApp);
+          }
+          return entry.data;
+        }
+      }
+    } catch (e) {
+    }
+    return null;
+  }
+  async set(key, data, lifetime, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      lifetime
+    };
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload) {
+          payload[prefixedKey] = entry;
+        }
+      } catch (e) {
+      }
+    }
+    if (undefined) {
+      try {
+        const store = await this.getStore("readwrite");
+        await new Promise((resolve, reject) => {
+          const req = store.put(entry, prefixedKey);
+          req.onsuccess = () => resolve();
+          req.onerror = () => reject(req.error);
+        });
+      } catch (e) {
+      }
+    }
+  }
+  async remove(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      try {
+        const store = await this.getStore("readwrite");
+        await new Promise((resolve, reject) => {
+          const req = store.delete(prefixedKey);
+          req.onsuccess = () => resolve();
+          req.onerror = () => reject(req.error);
+        });
+      } catch (e) {
+      }
+    }
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload && payload[prefixedKey]) {
+          delete payload[prefixedKey];
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async removeByPrefix(prefix, nuxtApp) {
+    const fullPrefix = "cache:" + prefix;
+    if (undefined) {
+      try {
+        const store = await this.getStore("readwrite");
+        const allKeys = await new Promise((resolve, reject) => {
+          const req = store.getAllKeys();
+          req.onsuccess = () => resolve(req.result);
+          req.onerror = () => reject(req.error);
+        });
+        const keysToDelete = allKeys.filter((k) => k.startsWith(fullPrefix));
+        for (const key of keysToDelete) {
+          await new Promise((resolve, reject) => {
+            const req = store.delete(key);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+          });
+        }
+      } catch (e) {
+      }
+    }
+    if (undefined && nuxtApp) {
+      try {
+        const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+        if (payload) {
+          for (const key in payload) {
+            if (key.startsWith(fullPrefix)) {
+              delete payload[key];
+            }
+          }
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async getRemainingTime(key, nuxtApp) {
+    if (undefined) {
+      try {
+        const prefixedKey = "cache:" + key;
+        const store = await this.getStore("readonly");
+        const entry = await new Promise((resolve, reject) => {
+          const req = store.get(prefixedKey);
+          req.onsuccess = () => resolve(req.result);
+          req.onerror = () => reject(req.error);
+        });
+        if (!entry) return null;
+        return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+      } catch (e) {
+        return null;
+      }
+    }
+    return null;
+  }
+  async cleanupExpired() {
+    if (undefined && this.dbPromise) {
+      try {
+        const prefix = "cache:";
+        const now = Date.now();
+        const keysToDelete = [];
+        const store = await this.getStore("readwrite");
+        const allKeys = await new Promise((resolve, reject) => {
+          const req = store.getAllKeys();
+          req.onsuccess = () => resolve(req.result);
+          req.onerror = () => reject(req.error);
+        });
+        for (const key of allKeys) {
+          if (key.startsWith(prefix)) {
+            const entry = await new Promise((resolve, reject) => {
+              const req = store.get(key);
+              req.onsuccess = () => resolve(req.result);
+              req.onerror = () => reject(req.error);
+            });
+            if (entry && now - entry.timestamp > entry.lifetime) {
+              keysToDelete.push(key);
+            }
+          }
+        }
+        for (const key of keysToDelete) {
+          await new Promise((resolve, reject) => {
+            const req = store.delete(key);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+          });
+        }
+      } catch (e) {
+      }
+    }
+  }
+}
+
+class CCookieCache extends ACacheProvider {
+  static instance = null;
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CCookieCache();
+    }
+    return this.instance;
+  }
+  type = "Cookie";
+  constructor() {
+    super();
+  }
+  async getKeyList(nuxtApp) {
+    const prefix = "cache:";
+    let cookieStr = "";
+    if (undefined) {
+      cookieStr = document.cookie;
+    } else if (nuxtApp) {
+      const event = nuxtApp.ssrContext?.event;
+      if (event) {
+        const cookies2 = h3.parseCookies(event);
+        return Object.keys(cookies2).filter((k) => k.startsWith(prefix)).map((k) => k.substring(prefix.length));
+      }
+    }
+    if (!cookieStr) return [];
+    const keys = [];
+    const cookies = cookieStr.split(";");
+    for (let i = 0; i < cookies.length; i++) {
+      const cookie = cookies[i].trim();
+      const eqPos = cookie.indexOf("=");
+      if (eqPos > 0) {
+        const name = decodeURIComponent(cookie.substring(0, eqPos));
+        if (name.startsWith(prefix)) {
+          keys.push(name.substring(prefix.length));
+        }
+      }
+    }
+    return keys;
+  }
+  async get(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    let cookieValue = null;
+    if (undefined) {
+      const name = prefixedKey + "=";
+      const ca = document.cookie.split(";");
+      for (let i = 0; i < ca.length; i++) {
+        let c = ca[i].trim();
+        if (c.indexOf(name) === 0) {
+          cookieValue = c.substring(name.length, c.length);
+          break;
+        }
+      }
+    } else if (nuxtApp) {
+      const event = nuxtApp.ssrContext?.event;
+      if (event) {
+        cookieValue = h3.getCookie(event, prefixedKey) ?? null;
+      }
+    }
+    if (!cookieValue) return null;
+    try {
+      const val = JSON.parse(cookieValue);
+      if (val && val.timestamp && val.lifetime) {
+        if (Date.now() - val.timestamp <= val.lifetime) {
+          return val.data;
+        } else {
+          await this.set(key, null, 0, nuxtApp);
+        }
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }
+  async set(key, data, lifetime, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      lifetime
+    };
+    const maxAge = Math.floor(lifetime / 1e3);
+    if (undefined) {
+      const cookieValue = encodeURIComponent(JSON.stringify(entry));
+      document.cookie = `${prefixedKey}=${cookieValue}; Max-Age=${maxAge}; Path=/; SameSite=Lax`;
+    } else if (nuxtApp) {
+      const event = nuxtApp.ssrContext?.event;
+      if (event) {
+        h3.setCookie(event, prefixedKey, JSON.stringify(entry), {
+          maxAge,
+          path: "/",
+          sameSite: "lax",
+          httpOnly: true
+        });
+      }
+    }
+  }
+  async remove(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      document.cookie = `${prefixedKey}=; Max-Age=0; Path=/; SameSite=Lax`;
+    } else if (nuxtApp) {
+      const event = nuxtApp.ssrContext?.event;
+      if (event) {
+        h3.deleteCookie(event, prefixedKey, { path: "/", sameSite: "lax", httpOnly: true });
+      }
+    }
+  }
+  async getRemainingTime(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    let cookieValue = null;
+    if (undefined) {
+      const name = prefixedKey + "=";
+      const ca = document.cookie.split(";");
+      for (let i = 0; i < ca.length; i++) {
+        let c = ca[i].trim();
+        if (c.indexOf(name) === 0) {
+          cookieValue = c.substring(name.length, c.length);
+          break;
+        }
+      }
+    } else if (nuxtApp) {
+      const event = nuxtApp.ssrContext?.event;
+      if (event) {
+        cookieValue = h3.getCookie(event, prefixedKey) ?? null;
+      }
+    }
+    if (!cookieValue) return null;
+    try {
+      const val = JSON.parse(cookieValue);
+      if (val && val.timestamp && val.lifetime) {
+        return Math.max(0, val.timestamp + val.lifetime - Date.now());
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }
+  async cleanupExpired() {
+    if (undefined) {
+      const prefix = "cache:";
+      const now = Date.now();
+      const cookies = document.cookie.split(";");
+      for (let i = 0; i < cookies.length; i++) {
+        const cookie = cookies[i].trim();
+        const eqPos = cookie.indexOf("=");
+        if (eqPos > 0) {
+          const name = decodeURIComponent(cookie.substring(0, eqPos));
+          if (name.startsWith(prefix)) {
+            const value = decodeURIComponent(cookie.substring(eqPos + 1));
+            try {
+              const entry = JSON.parse(value);
+              if (now - entry.timestamp > entry.lifetime) {
+                document.cookie = `${encodeURIComponent(name)}=; max-age=0; path=/`;
+              }
+            } catch (e) {
+              document.cookie = `${encodeURIComponent(name)}=; max-age=0; path=/`;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+class CSessionCache extends ACacheProvider {
+  static instance = null;
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CSessionCache();
+    }
+    return this.instance;
+  }
+  // Use global symbol to share storage across module instances (API vs App)
+  static get storage() {
+    const globalKey = Symbol.for("Katlux_CSessionCache_Storage");
+    const _global = globalThis;
+    if (!_global[globalKey]) {
+      _global[globalKey] = /* @__PURE__ */ new Map();
+    }
+    return _global[globalKey];
+  }
+  static getSnapshot() {
+    return this.storage;
+  }
+  sessionIdCache = null;
+  sessionId = null;
+  SESSION_ID_KEY = "_session_id";
+  constructor() {
+    super();
+    this.sessionIdCache = CCookieCache.getInstance();
+  }
+  /**
+   * Generate a UUID v4 sessionId
+   */
+  generateSessionId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  /**
+   * Get or create sessionId
+   */
+  async getSessionId(nuxtApp) {
+    if (this.sessionId) {
+      return this.sessionId;
+    }
+    if (!this.sessionIdCache) {
+      return this.generateSessionId();
+    }
+    const existingId = await this.sessionIdCache.get(this.SESSION_ID_KEY, nuxtApp);
+    if (existingId) {
+      this.sessionId = existingId;
+      return existingId;
+    }
+    const newId = this.generateSessionId();
+    this.sessionId = newId;
+    if (this.sessionIdCache) {
+      await this.sessionIdCache.set(this.SESSION_ID_KEY, newId, 365 * 24 * 60 * 60 * 1e3, nuxtApp);
+    }
+    return newId;
+  }
+  async getKeyList(nuxtApp) {
+    const prefix = "cache:";
+    if (undefined) {
+      return Object.keys(sessionStorage).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+    }
+    const sessionId = await this.getSessionId(nuxtApp);
+    const sessionData = CSessionCache.storage.get(sessionId);
+    if (!sessionData) {
+      return [];
+    }
+    return Array.from(sessionData.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+  }
+  async get(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      try {
+        const stored = sessionStorage.getItem(prefixedKey);
+        if (stored) {
+          const entry = JSON.parse(stored);
+          if (Date.now() - entry.timestamp <= entry.lifetime) {
+            return entry.data;
+          } else {
+            sessionStorage.removeItem(prefixedKey);
+          }
+        }
+      } catch (e) {
+      }
+      try {
+        const payloadData = window.__NUXT__?.payload?.data;
+        if (payloadData && payloadData[prefixedKey]) {
+          const entry = payloadData[prefixedKey];
+          if (Date.now() - entry.timestamp <= entry.lifetime) {
+            window.sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
+            return entry.data;
+          }
+        }
+      } catch (e) {
+      }
+      return null;
+    }
+    if (undefined) {
+      const sessionId = await this.getSessionId(nuxtApp);
+      const sessionData = CSessionCache.storage.get(sessionId);
+      if (!sessionData) {
+        return null;
+      }
+      const entry = sessionData.get(prefixedKey);
+      if (!entry) {
+        return null;
+      }
+      if (Date.now() - entry.timestamp <= entry.lifetime) {
+        return entry.data;
+      } else {
+        sessionData.delete(prefixedKey);
+        return null;
+      }
+    }
+    return null;
+  }
+  async set(key, data, lifetime, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      lifetime
+    };
+    if (undefined) {
+      try {
+        sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
+      } catch (e) {
+      }
+    }
+    if (undefined) {
+      try {
+        const sessionId = await this.getSessionId(nuxtApp);
+        let sessionData = CSessionCache.storage.get(sessionId);
+        if (!sessionData) {
+          sessionData = /* @__PURE__ */ new Map();
+          CSessionCache.storage.set(sessionId, sessionData);
+        }
+        sessionData.set(prefixedKey, entry);
+        if (nuxtApp) {
+          const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+          if (payload) {
+            payload[prefixedKey] = entry;
+          }
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async remove(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      sessionStorage.removeItem(prefixedKey);
+    }
+    if (undefined) {
+      try {
+        const sessionId = await this.getSessionId(nuxtApp);
+        const sessionData = CSessionCache.storage.get(sessionId);
+        if (sessionData) {
+          sessionData.delete(prefixedKey);
+        }
+        if (nuxtApp) {
+          const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+          if (payload && payload[prefixedKey]) {
+            delete payload[prefixedKey];
+          }
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async removeByPrefix(prefix, nuxtApp) {
+    const fullPrefix = "cache:" + prefix;
+    if (undefined) {
+      const keysToDelete = [];
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key && key.startsWith(fullPrefix)) {
+          keysToDelete.push(key);
+        }
+      }
+      for (const key of keysToDelete) {
+        sessionStorage.removeItem(key);
+      }
+    }
+    if (undefined) {
+      try {
+        const sessionId = await this.getSessionId(nuxtApp);
+        const sessionData = CSessionCache.storage.get(sessionId);
+        if (sessionData) {
+          const keysToDelete = [];
+          for (const key of sessionData.keys()) {
+            if (key.startsWith(fullPrefix)) {
+              keysToDelete.push(key);
+            }
+          }
+          for (const key of keysToDelete) {
+            sessionData.delete(key);
+          }
+        }
+        if (nuxtApp) {
+          const payload = nuxtApp.payload?.data || nuxtApp.ssrContext?.payload?.data;
+          if (payload) {
+            for (const key in payload) {
+              if (key.startsWith(fullPrefix)) {
+                delete payload[key];
+              }
+            }
+          }
+        }
+      } catch (e) {
+      }
+    }
+  }
+  async getRemainingTime(key, nuxtApp) {
+    const prefixedKey = "cache:" + key;
+    if (undefined) {
+      const entryStr = sessionStorage.getItem(prefixedKey);
+      if (!entryStr) return null;
+      try {
+        const entry = JSON.parse(entryStr);
+        return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+      } catch (e) {
+        return null;
+      }
+    }
+    if (undefined) {
+      const sessionId = await this.getSessionId(nuxtApp);
+      const sessionData = CSessionCache.storage.get(sessionId);
+      if (!sessionData) return null;
+      const entry = sessionData.get(prefixedKey);
+      if (!entry) return null;
+      return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+    }
+    return null;
+  }
+  async cleanupExpired() {
+    const prefix = "cache:";
+    const now = Date.now();
+    if (undefined) {
+      const keysToDelete = [];
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key && key.startsWith(prefix)) {
+          const stored = sessionStorage.getItem(key);
+          if (stored) {
+            try {
+              const entry = JSON.parse(stored);
+              if (now - entry.timestamp > entry.lifetime) {
+                keysToDelete.push(key);
+              }
+            } catch (e) {
+              keysToDelete.push(key);
+            }
+          }
+        }
+      }
+      for (const key of keysToDelete) {
+        sessionStorage.removeItem(key);
+      }
+    }
+    if (undefined) {
+      const sessionsToDelete = [];
+      for (const [sessionId, sessionData] of CSessionCache.storage.entries()) {
+        const keysToDelete = [];
+        for (const [key, entry] of sessionData.entries()) {
+          if (key.startsWith(prefix)) {
+            if (now - entry.timestamp > entry.lifetime) {
+              keysToDelete.push(key);
+            }
+          }
+        }
+        for (const key of keysToDelete) {
+          sessionData.delete(key);
+        }
+        if (sessionData.size === 0) {
+          sessionsToDelete.push(sessionId);
+        }
+      }
+      for (const sessionId of sessionsToDelete) {
+        CSessionCache.storage.delete(sessionId);
+      }
+    }
+  }
+}
+
+class CacheProviderFactory {
+  static getProvider(strategy) {
+    switch (strategy) {
+      case ECacheStrategy.Application:
+        return CApplicationCache.getInstance();
+      case ECacheStrategy.Session:
+        return CSessionCache.getInstance();
+      case ECacheStrategy.Memory:
+        return CMemoryCache.getInstance();
+      case ECacheStrategy.LocalStorage:
+        return CLocalStorageCache.getInstance();
+      case ECacheStrategy.IndexedDB:
+        return CIndexedDBCache.getInstance();
+      case ECacheStrategy.Cookie:
+        return CCookieCache.getInstance();
+      default:
+        return null;
+    }
+  }
+}
+
+class RequestProvider {
+  cacheProvider = null;
+  cacheLifetime = 60 * 60 * 1e3;
+  deduplicate = true;
+  cacheKey = "";
+  static requestQueue = [];
+  static executing = false;
+  static requestsInFlight = /* @__PURE__ */ new Map();
+  lastUrl;
+  lastOptions;
+  dataReceivedCallback;
+  constructor(provider, lifetime, deduplicate) {
+    if (provider) this.setCacheProvider(provider);
+    if (lifetime) this.setCacheLifetime(lifetime);
+    if (deduplicate !== void 0) this.setDeduplicate(deduplicate);
+  }
+  setCacheProvider(provider) {
+    if (!provider) {
+      console.warn("RequestProvider: provider is required");
+    }
+    if (provider instanceof ACacheProvider) this.cacheProvider = provider;
+    else this.cacheProvider = CacheProviderFactory.getProvider(provider);
+  }
+  setCacheLifetime(lifetime) {
+    this.cacheLifetime = lifetime;
+  }
+  setDeduplicate(deduplicate) {
+    this.deduplicate = deduplicate;
+  }
+  onDataReceived(callback) {
+    this.dataReceivedCallback = callback;
+  }
+  hasLastUrl() {
+    return !!this.lastUrl;
+  }
+  async refresh(hardRefresh = false) {
+    if (!this.dataReceivedCallback) {
+      return null;
+    }
+    if (!this.lastUrl) {
+      console.warn("[RequestProvider] refresh called before any request was made.");
+      return null;
+    }
+    const options = { ...this.lastOptions };
+    if (hardRefresh) {
+      options.disableCache = true;
+    }
+    return this.request(this.lastUrl, options);
+  }
+  getUniqueKey(url, options) {
+    if (options?.key) return options.key;
+    const { query, body, headers, method } = options || {};
+    const stableStringify = (val) => JSON.stringify(val === void 0 ? null : val);
+    return [
+      url,
+      stableStringify(query || {}),
+      stableStringify(body || null),
+      stableStringify(headers || {}),
+      method || "GET"
+    ].join("|");
+  }
+  registerRequest(url, options) {
+    const uniqueKey = this.getUniqueKey(url, options);
+    const shouldDeduplicate = options?.deduplicate ?? this.deduplicate;
+    if (shouldDeduplicate && RequestProvider.requestsInFlight.has(uniqueKey)) {
+      const inflightPromise = RequestProvider.requestsInFlight.get(uniqueKey);
+      return inflightPromise.then((result) => {
+        this.lastUrl = url;
+        this.lastOptions = options;
+        if (this.dataReceivedCallback) {
+          this.dataReceivedCallback(result);
+        }
+        return result;
+      });
+    }
+    const promise = new Promise((resolve, reject) => {
+      RequestProvider.requestQueue.push({
+        url,
+        options,
+        instance: this,
+        resolve,
+        reject
+      });
+      RequestProvider.executeAll();
+    }).finally(() => {
+      if (shouldDeduplicate) {
+        RequestProvider.requestsInFlight.delete(uniqueKey);
+      }
+    });
+    if (shouldDeduplicate) {
+      RequestProvider.requestsInFlight.set(uniqueKey, promise);
+    }
+    return promise;
+  }
+  static executeAll() {
+    if (RequestProvider.executing) return;
+    if (RequestProvider.requestQueue.length === 0) return;
+    RequestProvider.executing = true;
+    const queue = [...RequestProvider.requestQueue];
+    RequestProvider.requestQueue = [];
+    queue.forEach((queuedRequest) => {
+      queuedRequest.instance.request(queuedRequest.url, queuedRequest.options).then((result) => queuedRequest.resolve?.(result)).catch((error) => queuedRequest.reject?.(error instanceof Error ? error : new Error(String(error))));
+    });
+    Promise.resolve().then(() => {
+      RequestProvider.executing = false;
+      if (RequestProvider.requestQueue.length > 0) {
+        RequestProvider.executeAll();
+      }
+    });
+  }
+  async request(url, options) {
+    const { cacheStrategy, lifetime, query, body, headers, method } = options || {};
+    const uniqueKey = this.getUniqueKey(url, options);
+    const nuxtApp = options?.nuxtApp;
+    let serverHeaders = {};
+    if (nuxtApp && undefined) {
+      const event = nuxtApp.ssrContext?.event;
+      if (event) {
+        const { getRequestHeader } = await import('h3');
+        const cookieHeader = getRequestHeader(event, "cookie");
+        if (cookieHeader) {
+          serverHeaders = { cookie: cookieHeader };
+        }
+      }
+    }
+    const provider = cacheStrategy ? CacheProviderFactory.getProvider(cacheStrategy) : this.cacheProvider;
+    const cacheLifetime = lifetime || this.cacheLifetime;
+    const requestMethod = method || "GET";
+    const isGetRequest = requestMethod === "GET";
+    if (provider && isGetRequest && !options?.disableCache) {
+      const cached = await provider.get(uniqueKey, nuxtApp);
+      if (cached) {
+        console.log(`[RequestProvider] CACHE HIT: ${url}`);
+        this.lastUrl = url;
+        this.lastOptions = options;
+        if (this.dataReceivedCallback) {
+          this.dataReceivedCallback(cached);
+        }
+        return cached;
+      }
+      console.log(`[RequestProvider] CACHE MISS: ${url}`);
+    }
+    const fetchOptions = {
+      method: requestMethod,
+      body,
+      headers: { ...headers, ...serverHeaders },
+      query
+    };
+    const responseData = await ofetch.$fetch(url, fetchOptions);
+    if (provider && cacheLifetime && responseData && isGetRequest) {
+      await provider.set(uniqueKey, responseData, cacheLifetime, nuxtApp);
+    }
+    this.lastUrl = url;
+    this.lastOptions = options;
+    if (this.dataReceivedCallback) {
+      this.dataReceivedCallback(responseData);
+    }
+    return responseData;
+  }
+}
+
+class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
+  apiUrl = vue.ref("");
+  contextKey = vue.ref("");
+  initialLoad = vue.ref(true);
+  requestProvider = new RequestProvider();
+  cacheStrategy = vue.ref(null);
+  cacheLifetime = vue.ref(0);
+  refreshOnMutation = vue.ref(void 0);
+  constructor(options) {
+    super(options);
+    if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy;
+    if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime;
+    if (options?.refreshOnMutation !== void 0) this.refreshOnMutation.value = options.refreshOnMutation;
+    this.requestProvider.onDataReceived((data) => {
+      if (data) {
+        this.setData(data.rows || data);
+      }
+    });
+  }
+  setContextKey(key) {
+    this.contextKey.value = key;
+    this.requestProvider.cacheKey = key;
+    if (this.cacheStrategy.value) this.requestProvider.setCacheProvider(this.cacheStrategy.value);
+    if (this.cacheLifetime.value) this.requestProvider.setCacheLifetime(this.cacheLifetime.value);
+  }
+  async refresh(hardRefresh = false) {
+    await this.refreshData({ disableCache: hardRefresh });
+  }
+  async refreshData(options) {
+    if (!this.requestProvider.hasLastUrl()) {
+      await this._initialFetch(options?.disableCache ?? false);
+      return;
+    }
+    this.loading.value = true;
+    try {
+      await this.requestProvider.refresh(options?.disableCache ?? false);
+    } finally {
+      this.loading.value = false;
+    }
+  }
+  async _initialFetch(disableCache = false) {
+    if (!this.SSR.value && undefined) return;
+    const fetcher = async () => {
+      const promise = this.requestProvider.registerRequest(this.apiUrl.value, {
+        deduplicate: this.deduplicate.value,
+        nuxtApp: this.nuxtApp,
+        disableCache
+      });
+      if (this.SSR.value && undefined) return await promise;
+      return promise;
+    };
+    const key = `${this.contextKey.value}`;
+    if (this.contextKey.value && this.initialLoad.value && !disableCache) {
+      const { data } = nuxtAppCompat.getNuxtData(key, this.nuxtApp);
+      if (data.value) {
+        const result = data.value;
+        this.setData(result.rows);
+        this.initialLoad.value = false;
+        this.loading.value = false;
+        return;
+      }
+    }
+    if (undefined && this.contextKey.value) {
+      if (disableCache) {
+        nuxtAppCompat.clearNuxtDataKey(key, this.nuxtApp);
+      }
+      const { data } = await nuxtAppCompat.getAsyncData(key, fetcher, this.nuxtApp);
+      if (data.value) {
+        const result = data.value;
+        this.setData(result.rows);
+        this.initialLoad.value = false;
+        this.loading.value = false;
+        return;
+      }
+    }
+    if (!this.SSR.value) {
+      const promise = this.requestProvider.registerRequest(this.apiUrl.value, {
+        deduplicate: this.deduplicate.value,
+        nuxtApp: this.nuxtApp,
+        disableCache
+      });
+      promise.then(() => {
+        this.initialLoad.value = false;
+        this.loading.value = false;
+      }).catch(() => {
+        this.initialLoad.value = false;
+        this.loading.value = false;
+      });
+      return;
+    }
+    await fetcher();
+    this.initialLoad.value = false;
+    this.loading.value = false;
+  }
+  async setAPIUrl(url) {
+    this.loading.value = true;
+    this.apiUrl.value = url;
+    this.setContextKey(url);
+    if (this.allData.value.length == 0)
+      await this.refreshData();
+  }
+  async create(item) {
+    if (!this.apiUrl.value) return;
+    const result = await this.requestProvider.registerRequest(this.apiUrl.value, {
+      method: "POST",
+      body: item,
+      nuxtApp: this.nuxtApp
+    });
+    if (this.refreshOnMutation.value) {
+      await this.refresh(true);
+    } else {
+      if (result && result.item) {
+        this.allData.value.push(result.item);
+        this.loadPageData();
+        await this.refresh(true);
+      }
+      if (this.requestProvider.cacheProvider) {
+        await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+      }
+      if (this.contextKey.value) {
+        nuxtAppCompat.clearNuxtDataKey(this.contextKey.value, this.nuxtApp);
+      }
+    }
+  }
+  async update(item) {
+    if (!this.apiUrl.value) return;
+    const result = await this.requestProvider.registerRequest(this.apiUrl.value, {
+      method: "PUT",
+      body: item,
+      nuxtApp: this.nuxtApp
+    });
+    if (this.refreshOnMutation.value) {
+      await this.refresh(true);
+    } else {
+      const index = this.allData.value.findIndex((row) => row["id"] === item["id"]);
+      if (index !== -1) {
+        if (result && result.item) {
+          this.allData.value[index] = result.item;
+        } else {
+          this.allData.value[index] = { ...this.allData.value[index], ...item };
+        }
+        this.loadPageData();
+      }
+      if (this.requestProvider.cacheProvider) {
+        await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+      }
+      if (this.contextKey.value) {
+        nuxtAppCompat.clearNuxtDataKey(this.contextKey.value, this.nuxtApp);
+      }
+    }
+  }
+  async delete(items) {
+    if (!this.apiUrl.value) return;
+    if (!items || items.length === 0) return;
+    const ids = items.map((i) => i.id);
+    await this.requestProvider.registerRequest(this.apiUrl.value, {
+      method: "DELETE",
+      body: { id: ids },
+      nuxtApp: this.nuxtApp
+    });
+    if (this.refreshOnMutation.value) {
+      await this.refresh(true);
+    } else {
+      const idsToDelete = new Set(ids);
+      this.allData.value = this.allData.value.filter((row) => !idsToDelete.has(row["id"]));
+      if (this.requestProvider.cacheProvider) {
+        await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+      }
+      if (this.contextKey.value) {
+        nuxtAppCompat.clearNuxtDataKey(this.contextKey.value, this.nuxtApp);
+      }
+    }
+  }
+}
+
+class CFlatServerDataProvider extends ADataProvider {
+  pageDataHandler = vue.ref((currentPage, pageSize, filter, sortList) => {
+    return {
+      rows: [],
+      rowCount: 0
+    };
+  });
+  contextKey = vue.ref("");
+  initialLoad = vue.ref(true);
+  constructor(options) {
+    super(options);
+  }
+  setContextKey(key) {
+    this.contextKey.value = key;
+  }
+  async setPageDataHandler(handler) {
+    this.pageDataHandler.value = handler;
+    await this.loadPageData();
+  }
+  async loadPageData(options) {
+    if (!this.pageDataHandler.value || !this.SSR.value && undefined) return;
+    const stableStringify = (val) => JSON.stringify(val === void 0 ? "" : val);
+    const key = [
+      this.contextKey.value,
+      this.currentPage.value,
+      this.pageSize.value,
+      stableStringify(this.filter.value),
+      stableStringify(this.sortList.value)
+    ].join("-");
+    const fetcher = async () => await this.pageDataHandler.value(this.currentPage.value, this.pageSize.value, this.filter.value, this.sortList.value, options);
+    if (!options?.disableCache && this.SSR.value && this.contextKey.value && this.initialLoad.value) {
+      const { data } = nuxtAppCompat.getNuxtData(key, this.nuxtApp);
+      if (data.value) {
+        const result = data.value;
+        this.pageData.value = result.rows;
+        this.rowCount.value = result.rowCount;
+        this.initialLoad.value = false;
+        this.loading.value = false;
+        return;
+      }
+    }
+    if (this.SSR.value && this.contextKey.value && !options?.disableCache && (undefined || this.initialLoad.value)) {
+      this.loading.value = true;
+      const { data } = await nuxtAppCompat.getAsyncData(key, fetcher, this.nuxtApp);
+      if (data.value) {
+        const result = data.value;
+        this.pageData.value = result.rows;
+        this.rowCount.value = result.rowCount;
+        this.initialLoad.value = false;
+        this.loading.value = false;
+        return;
+      }
+    }
+    if (!this.SSR.value) {
+      nuxtAppCompat.onNuxtReadyCallback(() => {
+        this.loading.value = true;
+        fetcher().then((returnedData2) => {
+          this.pageData.value = returnedData2.rows;
+          this.rowCount.value = returnedData2.rowCount;
+          this.initialLoad.value = false;
+          this.loading.value = false;
+        }).catch(() => {
+          this.initialLoad.value = false;
+          this.loading.value = false;
+        });
+      });
+      return;
+    }
+    this.loading.value = true;
+    const returnedData = await fetcher();
+    this.pageData.value = returnedData.rows;
+    this.rowCount.value = returnedData.rowCount;
+    this.initialLoad.value = false;
+    this.loading.value = false;
+  }
+  async refresh(hardRefresh = false) {
+    await this.loadPageData(hardRefresh ? { disableCache: true } : void 0);
+  }
+}
+
+class CAPIFlatServerDataProvider extends CFlatServerDataProvider {
+  apiUrl = vue.ref("");
+  requestProvider = new RequestProvider();
+  cacheStrategy = vue.ref(null);
+  cacheLifetime = vue.ref(0);
+  refreshOnMutation = vue.ref(true);
+  // Default true for server
+  constructor(options) {
+    super(options);
+    if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy;
+    if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime;
+    if (options?.refreshOnMutation !== void 0) this.refreshOnMutation.value = options.refreshOnMutation;
+    this.requestProvider.onDataReceived((data) => {
+      if (data) {
+        this.pageData.value = data.rows || data;
+        if (data.rowCount !== void 0) {
+          this.rowCount.value = data.rowCount;
+        }
+      }
+    });
+  }
+  async refresh(hardRefresh = false) {
+    if (hardRefresh && this.requestProvider.cacheProvider) {
+      await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+    }
+    this.loading.value = true;
+    try {
+      await this.loadPageData(hardRefresh ? { disableCache: true } : void 0);
+    } finally {
+      this.loading.value = false;
+    }
+  }
+  async refreshData(options) {
+    await this.refresh(options?.disableCache ?? false);
+  }
+  async setAPIUrl(url) {
+    this.apiUrl.value = url;
+    this.setContextKey(url);
+    if (this.cacheStrategy.value) this.requestProvider.setCacheProvider(this.cacheStrategy.value);
+    if (this.cacheLifetime.value) this.requestProvider.setCacheLifetime(this.cacheLifetime.value);
+    await this.setPageDataHandler(
+      async (currentPage, pageSize, filter, sortList, options) => {
+        return await this.requestProvider.registerRequest(this.apiUrl.value, {
+          query: {
+            pageNumber: currentPage,
+            pageSize,
+            filter,
+            sortList
+          },
+          deduplicate: this.deduplicate.value,
+          nuxtApp: this.nuxtApp,
+          disableCache: options?.disableCache
+        });
+      }
+    );
+  }
+  async delete(items) {
+    if (!this.apiUrl.value) return;
+    if (!items || items.length === 0) return;
+    const ids = items.map((i) => i.id);
+    await this.requestProvider.registerRequest(this.apiUrl.value, {
+      method: "DELETE",
+      body: { id: ids },
+      nuxtApp: this.nuxtApp
+    });
+    if (this.refreshOnMutation.value !== false) {
+      if (this.requestProvider.cacheProvider) {
+        await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+      }
+      await this.refresh(true);
+    }
+  }
+}
+
+class AAPIDataProvider {
+  apiUrl = vue.ref("");
+  cacheStrategy = vue.ref(null);
+  cacheLifetime = vue.ref(60 * 1e3);
+  requestProvider = new RequestProvider();
+  refreshOnMutation = vue.ref(void 0);
+  constructor(options) {
+    if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy;
+    if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime;
+    if (options?.refreshOnMutation !== void 0) this.refreshOnMutation.value = options.refreshOnMutation;
+  }
+}
+
+const { filterData } = useFilterLogic();
+class CTreeClientDataProvider extends CFlatClientDataProvider {
+  // Tree configuration
+  parentKey = "parentId";
+  idKey = "id";
+  expandedByDefault = false;
+  paginateBy = "all";
+  // Tree state
+  expandedNodes = vue.ref(/* @__PURE__ */ new Set());
+  // Internal: static tree structure (only rebuilds when data changes)
+  _staticNodes;
+  _nodeMap;
+  _sortedNodeIds;
+  constructor(options) {
+    super(options);
+    if (options?.parentKey) this.parentKey = options.parentKey;
+    if (options?.idKey) this.idKey = options.idKey;
+    if (options?.expandedByDefault) this.expandedByDefault = options.expandedByDefault;
+    if (options?.paginateBy) this.paginateBy = options.paginateBy;
+    this._staticNodes = vue.computed(() => this.buildStaticNodes());
+    this._nodeMap = vue.computed(() => new Map(this._staticNodes.value.map((n) => [n.id, n])));
+    this._sortedNodeIds = vue.computed(() => this.computeSortedIds());
+    vue.watch([this.expandedNodes, this._staticNodes], () => {
+      this.updatePageData();
+    }, { immediate: true });
+  }
+  buildStaticNodes() {
+    const allData = this.allData.value || [];
+    const nodeMap = /* @__PURE__ */ new Map();
+    const childrenMap = /* @__PURE__ */ new Map();
+    allData.forEach((item) => {
+      const id = item[this.idKey];
+      const parentId = item[this.parentKey] || null;
+      nodeMap.set(id, {
+        data: item,
+        id,
+        parentId,
+        depth: 0,
+        hasChildren: false
+      });
+      if (parentId !== null) {
+        if (!childrenMap.has(parentId)) {
+          childrenMap.set(parentId, []);
+        }
+        childrenMap.get(parentId).push(item);
+      }
+    });
+    const calculateDepth = (nodeId, depth = 0) => {
+      const node = nodeMap.get(nodeId);
+      if (!node) return;
+      node.depth = depth;
+      const children = childrenMap.get(nodeId);
+      if (children && children.length > 0) {
+        node.hasChildren = true;
+        children.forEach((child) => {
+          calculateDepth(child[this.idKey], depth + 1);
+        });
+      }
+    };
+    nodeMap.forEach((node) => {
+      if (node.parentId === null) {
+        calculateDepth(node.id, 0);
+      }
+    });
+    return Array.from(nodeMap.values());
+  }
+  // Pre-compute sorted order once (only when data changes)
+  computeSortedIds() {
+    const nodes = this._staticNodes.value;
+    new Map(nodes.map((n) => [n.id, n]));
+    const sortedIds = [];
+    const rootNodes = nodes.filter((n) => n.parentId === null);
+    const childrenMap = /* @__PURE__ */ new Map();
+    nodes.forEach((n) => {
+      if (n.parentId !== null) {
+        if (!childrenMap.has(n.parentId)) {
+          childrenMap.set(n.parentId, []);
+        }
+        childrenMap.get(n.parentId).push(n);
+      }
+    });
+    const collectNodes = (node) => {
+      sortedIds.push(node.id);
+      const children = childrenMap.get(node.id) || [];
+      children.forEach((child) => collectNodes(child));
+    };
+    rootNodes.forEach((root) => collectNodes(root));
+    return sortedIds;
+  }
+  // Fast visibility check and page data update
+  updatePageData() {
+    const nodeMap = this._nodeMap.value;
+    const sortedIds = this._sortedNodeIds.value;
+    const visibleNodes = [];
+    if (this.filter.value && this.filter.value.active) {
+      const { results: filtered, expandedNodes: expandedResults } = filterData(
+        this._staticNodes.value,
+        this.filter.value,
+        {
+          treeOptions: {
+            idKey: this.idKey,
+            parentKey: this.parentKey
+          }
+        }
+      );
+      const expandedSet = expandedResults || /* @__PURE__ */ new Set();
+      for (const node of filtered) {
+        visibleNodes.push({
+          ...node,
+          isExpanded: expandedSet.has(node.id)
+        });
+      }
+    } else {
+      for (const id of sortedIds) {
+        const staticNode = nodeMap.get(id);
+        if (!staticNode) continue;
+        if (this.isNodeVisible(staticNode, nodeMap)) {
+          const isExpanded = this.expandedByDefault ? !this.expandedNodes.value.has(id) : this.expandedNodes.value.has(id);
+          visibleNodes.push({
+            ...staticNode,
+            isExpanded
+          });
+        }
+      }
+    }
+    const paginatedNodes = this.paginateNodes(visibleNodes);
+    this.pageData.value = paginatedNodes.map((node) => ({
+      ...node.data,
+      __treeNode: node
+    }));
+  }
+  isNodeVisible(node, nodeMap) {
+    if (node.parentId === null) return true;
+    let currentId = node.parentId;
+    while (currentId !== null) {
+      const parent = nodeMap.get(currentId);
+      if (!parent) return false;
+      const parentExpanded = this.expandedByDefault ? !this.expandedNodes.value.has(currentId) : this.expandedNodes.value.has(currentId);
+      if (!parentExpanded) return false;
+      currentId = parent.parentId;
+    }
+    return true;
+  }
+  paginateNodes(visible) {
+    const pageSize = this.pageSize.value;
+    const currentPage = this.currentPage.value;
+    if (pageSize <= 0) {
+      this.rowCount.value = visible.length;
+      return visible;
+    }
+    if (this.paginateBy === "root") {
+      const rootNodes = visible.filter((n) => n.parentId === null);
+      const startIndex = (currentPage - 1) * pageSize;
+      const endIndex = startIndex + pageSize;
+      const paginatedRoots = rootNodes.slice(startIndex, endIndex);
+      const paginatedRootIds = new Set(paginatedRoots.map((n) => n.id));
+      const nodeMap = new Map(visible.map((n) => [n.id, n]));
+      const getRootId = (node) => {
+        let current = node;
+        while (current.parentId !== null) {
+          const parent = nodeMap.get(current.parentId);
+          if (!parent) break;
+          current = parent;
+        }
+        return current.id;
+      };
+      const result = visible.filter((node) => paginatedRootIds.has(getRootId(node)));
+      this.rowCount.value = rootNodes.length;
+      return result;
+    } else {
+      const startIndex = (currentPage - 1) * pageSize;
+      const endIndex = startIndex + pageSize;
+      this.rowCount.value = visible.length;
+      return visible.slice(startIndex, endIndex);
+    }
+  }
+  // Override loadPageData
+  async loadPageData() {
+    this.updatePageData();
+  }
+  // Public API
+  get treeNodes() {
+    return this._staticNodes.value.map((node) => ({
+      ...node,
+      isExpanded: this.expandedByDefault ? !this.expandedNodes.value.has(node.id) : this.expandedNodes.value.has(node.id)
+    }));
+  }
+  get visibleRows() {
+    const nodeMap = this._nodeMap.value;
+    const sortedIds = this._sortedNodeIds.value;
+    const visibleNodes = [];
+    for (const id of sortedIds) {
+      const staticNode = nodeMap.get(id);
+      if (!staticNode) continue;
+      if (this.isNodeVisible(staticNode, nodeMap)) {
+        visibleNodes.push({
+          ...staticNode,
+          isExpanded: this.expandedByDefault ? !this.expandedNodes.value.has(id) : this.expandedNodes.value.has(id)
+        });
+      }
+    }
+    return this.paginateNodes(visibleNodes);
+  }
+  toggleNode(nodeId) {
+    if (this.expandedNodes.value.has(nodeId)) {
+      this.expandedNodes.value.delete(nodeId);
+    } else {
+      this.expandedNodes.value.add(nodeId);
+    }
+    this.expandedNodes.value = new Set(this.expandedNodes.value);
+  }
+  expand(nodeId) {
+    this.expandedNodes.value.add(nodeId);
+    this.expandedNodes.value = new Set(this.expandedNodes.value);
+  }
+  collapse(nodeId) {
+    this.expandedNodes.value.delete(nodeId);
+    this.expandedNodes.value = new Set(this.expandedNodes.value);
+  }
+  expandAll() {
+    const allIds = this._staticNodes.value.filter((n) => n.hasChildren).map((n) => n.id);
+    this.expandedNodes.value = new Set(allIds);
+  }
+  collapseAll() {
+    this.expandedNodes.value = /* @__PURE__ */ new Set();
+  }
+  getNode(nodeId) {
+    const staticNode = this._nodeMap.value.get(nodeId);
+    if (!staticNode) return void 0;
+    return {
+      ...staticNode,
+      isExpanded: this.expandedByDefault ? !this.expandedNodes.value.has(nodeId) : this.expandedNodes.value.has(nodeId)
+    };
+  }
+  getChildren(nodeId) {
+    return this.treeNodes.filter((n) => n.parentId === nodeId);
+  }
+  getParent(nodeId) {
+    const node = this.getNode(nodeId);
+    if (!node || node.parentId === null) return void 0;
+    return this.getNode(node.parentId);
+  }
+}
+
+class CAPITreeClientDataProvider extends CTreeClientDataProvider {
+  apiUrl = vue.ref("");
+  contextKey = vue.ref("");
+  initialLoad = vue.ref(true);
+  requestProvider = new RequestProvider();
+  cacheStrategy = vue.ref(null);
+  cacheLifetime = vue.ref(0);
+  refreshOnMutation = vue.ref(void 0);
+  constructor(options) {
+    super(options);
+    if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy;
+    if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime;
+    if (options?.refreshOnMutation !== void 0) this.refreshOnMutation.value = options.refreshOnMutation;
+    this.requestProvider.onDataReceived((data) => {
+      if (data) {
+        this.setData(data.rows || data);
+      }
+    });
+  }
+  setContextKey(key) {
+    this.contextKey.value = key;
+    this.requestProvider.cacheKey = key;
+    if (this.cacheStrategy.value) this.requestProvider.setCacheProvider(this.cacheStrategy.value);
+    if (this.cacheLifetime.value) this.requestProvider.setCacheLifetime(this.cacheLifetime.value);
+  }
+  async refresh(hardRefresh = false) {
+    await this.refreshData({ disableCache: hardRefresh });
+  }
+  async refreshData(options) {
+    if (!this.requestProvider.hasLastUrl()) {
+      await this._initialFetch(options?.disableCache ?? false);
+      return;
+    }
+    this.loading.value = true;
+    try {
+      await this.requestProvider.refresh(options?.disableCache ?? false);
+    } finally {
+      this.loading.value = false;
+    }
+  }
+  async _initialFetch(disableCache = false) {
+    if (!this.SSR.value && undefined) return;
+    const fetcher = async () => {
+      const promise = this.requestProvider.registerRequest(this.apiUrl.value, {
+        deduplicate: this.deduplicate.value,
+        nuxtApp: this.nuxtApp,
+        disableCache
+      });
+      if (this.SSR.value && undefined) return await promise;
+      return promise;
+    };
+    const key = `${this.contextKey.value}`;
+    if (this.contextKey.value && this.initialLoad.value && !disableCache) {
+      const { data } = nuxtAppCompat.getNuxtData(key, this.nuxtApp);
+      if (data.value) {
+        const result = data.value;
+        this.setData(result.rows);
+        this.initialLoad.value = false;
+        this.loading.value = false;
+        return;
+      }
+    }
+    if (undefined && this.contextKey.value) {
+      if (disableCache) {
+        nuxtAppCompat.clearNuxtDataKey(key, this.nuxtApp);
+      }
+      const { data } = await nuxtAppCompat.getAsyncData(key, fetcher, this.nuxtApp);
+      if (data.value) {
+        const result = data.value;
+        this.setData(result.rows);
+        this.initialLoad.value = false;
+        this.loading.value = false;
+        return;
+      }
+    }
+    if (!this.SSR.value) {
+      const promise = this.requestProvider.registerRequest(this.apiUrl.value, {
+        deduplicate: this.deduplicate.value,
+        nuxtApp: this.nuxtApp,
+        disableCache
+      });
+      promise.then(() => {
+        this.initialLoad.value = false;
+        this.loading.value = false;
+      }).catch(() => {
+        this.initialLoad.value = false;
+        this.loading.value = false;
+      });
+      return;
+    }
+    await fetcher();
+    this.initialLoad.value = false;
+    this.loading.value = false;
+  }
+  async setAPIUrl(url) {
+    this.loading.value = true;
+    this.apiUrl.value = url;
+    this.setContextKey(url);
+    if (this.allData.value.length == 0)
+      await this.refreshData();
+  }
+  async create(item) {
+    if (!this.apiUrl.value) return;
+    const result = await this.requestProvider.registerRequest(this.apiUrl.value, {
+      method: "POST",
+      body: item,
+      nuxtApp: this.nuxtApp
+    });
+    if (this.refreshOnMutation.value) {
+      await this.refresh(true);
+    } else {
+      if (result && result.item) {
+        this.allData.value.push(result.item);
+      } else {
+        await this.refresh(true);
+      }
+      if (this.requestProvider.cacheProvider) {
+        await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+      }
+      if (this.contextKey.value) {
+        nuxtAppCompat.clearNuxtDataKey(this.contextKey.value, this.nuxtApp);
+      }
+    }
+  }
+  async update(item) {
+    if (!this.apiUrl.value) return;
+    const result = await this.requestProvider.registerRequest(this.apiUrl.value, {
+      method: "PUT",
+      body: item,
+      nuxtApp: this.nuxtApp
+    });
+    if (this.refreshOnMutation.value) {
+      await this.refresh(true);
+    } else {
+      const index = this.allData.value.findIndex((row) => row[this.idKey] === item[this.idKey]);
+      if (index !== -1) {
+        if (result && result.item) {
+          this.allData.value[index] = result.item;
+        } else {
+          this.allData.value[index] = { ...this.allData.value[index], ...item };
+        }
+        this.allData.value = [...this.allData.value];
+      }
+      if (this.requestProvider.cacheProvider) {
+        await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+      }
+      if (this.contextKey.value) {
+        nuxtAppCompat.clearNuxtDataKey(this.contextKey.value, this.nuxtApp);
+      }
+    }
+  }
+  async delete(items) {
+    if (!this.apiUrl.value) return;
+    if (!items || items.length === 0) return;
+    const ids = items.map((i) => i.id);
+    await this.requestProvider.registerRequest(this.apiUrl.value, {
+      method: "DELETE",
+      body: { id: ids },
+      nuxtApp: this.nuxtApp
+    });
+    if (this.refreshOnMutation.value) {
+      await this.refresh(true);
+    } else {
+      const idsToDelete = new Set(ids);
+      this.allData.value = this.allData.value.filter((row) => !idsToDelete.has(row[this.idKey]));
+      if (this.requestProvider.cacheProvider) {
+        await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+      }
+      if (this.contextKey.value) {
+        nuxtAppCompat.clearNuxtDataKey(this.contextKey.value, this.nuxtApp);
+      }
+    }
+  }
+}
+
+class CTreeServerDataProvider extends ADataProvider {
+  // Tree configuration (sent to server)
+  parentKey = "parentId";
+  idKey = "id";
+  expandedByDefault = false;
+  paginateBy = "all";
+  // Tree state - toggled nodes (sent to server for visibility calculation)
+  expandedNodes = vue.ref(/* @__PURE__ */ new Set());
+  // Server-side data handler
+  pageDataHandler = vue.ref(null);
+  contextKey = vue.ref("");
+  initialLoad = vue.ref(true);
+  constructor(options) {
+    super(options);
+    if (options?.parentKey) this.parentKey = options.parentKey;
+    if (options?.idKey) this.idKey = options.idKey;
+    if (options?.expandedByDefault) this.expandedByDefault = options.expandedByDefault;
+    if (options?.paginateBy) this.paginateBy = options.paginateBy;
+    vue.watch([this.expandedNodes, this.currentPage, this.pageSize], () => {
+      if (this.pageDataHandler.value && !this.initialLoad.value) {
+        this.loadPageData();
+      }
+    });
+  }
+  setContextKey(key) {
+    this.contextKey.value = key;
+  }
+  async setPageDataHandler(handler) {
+    this.pageDataHandler.value = handler;
+    await this.loadPageData();
+  }
+  /**
+   * Load page data from server
+   * Server handles tree building, visibility, and pagination
+   */
+  async loadPageData(options) {
+    if (!this.pageDataHandler.value || !this.SSR.value && undefined) return;
+    const expandedArray = Array.from(this.expandedNodes.value);
+    const stableStringify = (val) => JSON.stringify(val === void 0 ? "" : val);
+    const key = [
+      this.contextKey.value,
+      this.currentPage.value,
+      this.pageSize.value,
+      stableStringify(this.filter.value),
+      stableStringify(this.sortList.value),
+      stableStringify(expandedArray)
+    ].join("-");
+    const treeParams = {
+      expandedNodes: expandedArray,
+      parentKey: this.parentKey,
+      idKey: this.idKey,
+      paginateBy: this.paginateBy,
+      expandedByDefault: this.expandedByDefault
+    };
+    const fetcher = async () => await this.pageDataHandler.value(
+      this.currentPage.value,
+      this.pageSize.value,
+      this.filter.value,
+      this.sortList.value,
+      treeParams,
+      options
+    );
+    if (!options?.disableCache && this.SSR.value && this.contextKey.value && this.initialLoad.value) {
+      const { data } = nuxtAppCompat.getNuxtData(key, this.nuxtApp);
+      if (data.value) {
+        const result = data.value;
+        this.pageData.value = result.rows;
+        this.rowCount.value = result.rowCount;
+        this.initialLoad.value = false;
+        this.loading.value = false;
+        return;
+      }
+    }
+    if (this.SSR.value && this.contextKey.value && !options?.disableCache && (undefined || this.initialLoad.value)) {
+      this.loading.value = true;
+      const { data } = await nuxtAppCompat.getAsyncData(key, fetcher, this.nuxtApp);
+      if (data.value) {
+        const result = data.value;
+        this.pageData.value = result.rows;
+        this.rowCount.value = result.rowCount;
+        this.initialLoad.value = false;
+        this.loading.value = false;
+        return;
+      }
+    }
+    if (!this.SSR.value) {
+      nuxtAppCompat.onNuxtReadyCallback(() => {
+        this.loading.value = true;
+        fetcher().then((returnedData2) => {
+          this.pageData.value = returnedData2.rows;
+          this.rowCount.value = returnedData2.rowCount;
+          this.initialLoad.value = false;
+          this.loading.value = false;
+        }).catch(() => {
+          this.initialLoad.value = false;
+          this.loading.value = false;
+        });
+      });
+      return;
+    }
+    this.loading.value = true;
+    const returnedData = await fetcher();
+    this.pageData.value = returnedData.rows;
+    this.rowCount.value = returnedData.rowCount;
+    this.initialLoad.value = false;
+    this.loading.value = false;
+  }
+  async refresh(hardRefresh = false) {
+    await this.loadPageData(hardRefresh ? { disableCache: true } : void 0);
+  }
+  // ============================================
+  // Expand/Collapse API
+  // ============================================
+  toggleNode(nodeId) {
+    if (this.expandedNodes.value.has(nodeId)) {
+      this.expandedNodes.value.delete(nodeId);
+    } else {
+      this.expandedNodes.value.add(nodeId);
+    }
+    this.expandedNodes.value = new Set(this.expandedNodes.value);
+  }
+  expand(nodeId) {
+    this.expandedNodes.value.add(nodeId);
+    this.expandedNodes.value = new Set(this.expandedNodes.value);
+  }
+  collapse(nodeId) {
+    this.expandedNodes.value.delete(nodeId);
+    this.expandedNodes.value = new Set(this.expandedNodes.value);
+  }
+  collapseAll() {
+    this.expandedNodes.value = /* @__PURE__ */ new Set();
+  }
+  isExpanded(nodeId) {
+    const isToggled = this.expandedNodes.value.has(nodeId);
+    return this.expandedByDefault ? !isToggled : isToggled;
+  }
+}
+
+class CAPITreeServerDataProvider extends CTreeServerDataProvider {
+  apiUrl = vue.ref("");
+  requestProvider = new RequestProvider();
+  cacheStrategy = vue.ref(null);
+  cacheLifetime = vue.ref(0);
+  refreshOnMutation = vue.ref(true);
+  // Default true for server
+  constructor(options) {
+    super(options);
+    if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy;
+    if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime;
+    if (options?.refreshOnMutation !== void 0) this.refreshOnMutation.value = options.refreshOnMutation;
+    this.requestProvider.onDataReceived((data) => {
+      if (data) {
+        this.pageData.value = data.rows || data;
+        if (data.rowCount !== void 0) {
+          this.rowCount.value = data.rowCount;
+        }
+      }
+    });
+  }
+  async refresh(hardRefresh = false) {
+    if (hardRefresh && this.requestProvider.cacheProvider) {
+      await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+    }
+    this.loading.value = true;
+    try {
+      await this.loadPageData(hardRefresh ? { disableCache: true } : void 0);
+    } finally {
+      this.loading.value = false;
+    }
+  }
+  async refreshData(options) {
+    await this.refresh(options?.disableCache ?? false);
+  }
+  async setAPIUrl(url) {
+    this.apiUrl.value = url;
+    this.setContextKey(url);
+    if (this.cacheStrategy.value) this.requestProvider.setCacheProvider(this.cacheStrategy.value);
+    if (this.cacheLifetime.value) this.requestProvider.setCacheLifetime(this.cacheLifetime.value);
+    await this.setPageDataHandler(
+      async (currentPage, pageSize, filter, sortList, treeParams, options) => {
+        return await this.requestProvider.registerRequest(this.apiUrl.value, {
+          query: {
+            pageNumber: currentPage,
+            pageSize,
+            filter,
+            sortList,
+            // Tree-specific params for server-side processing
+            expandedNodes: JSON.stringify(treeParams.expandedNodes),
+            parentKey: treeParams.parentKey,
+            idKey: treeParams.idKey,
+            paginateBy: treeParams.paginateBy,
+            expandedByDefault: treeParams.expandedByDefault
+          },
+          deduplicate: this.deduplicate.value,
+          nuxtApp: this.nuxtApp,
+          disableCache: options?.disableCache
+        });
+      }
+    );
+  }
+  async delete(items) {
+    if (!this.apiUrl.value) return;
+    if (!items || items.length === 0) return;
+    const ids = items.map((i) => i.id);
+    await this.requestProvider.registerRequest(this.apiUrl.value, {
+      method: "DELETE",
+      body: { id: ids },
+      nuxtApp: this.nuxtApp
+    });
+    if (this.refreshOnMutation.value !== false) {
+      if (this.requestProvider.cacheProvider) {
+        await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value);
+      }
+      await this.refresh(true);
+    }
+  }
+}
+
+exports.AAPIDataProvider = AAPIDataProvider;
+exports.ADataProvider = ADataProvider;
+exports.CAPIFlatClientDataProvider = CAPIFlatClientDataProvider;
+exports.CAPIFlatServerDataProvider = CAPIFlatServerDataProvider;
+exports.CAPITreeClientDataProvider = CAPITreeClientDataProvider;
+exports.CAPITreeServerDataProvider = CAPITreeServerDataProvider;
+exports.CApplicationCache = CApplicationCache;
+exports.CCookieCache = CCookieCache;
+exports.CFlatClientDataProvider = CFlatClientDataProvider;
+exports.CFlatServerDataProvider = CFlatServerDataProvider;
+exports.CIndexedDBCache = CIndexedDBCache;
+exports.CLocalStorageCache = CLocalStorageCache;
+exports.CMemoryCache = CMemoryCache;
+exports.CSessionCache = CSessionCache;
+exports.CTreeClientDataProvider = CTreeClientDataProvider;
+exports.CTreeServerDataProvider = CTreeServerDataProvider;
+exports.CacheProviderFactory = CacheProviderFactory;
+exports.ECacheStrategy = ECacheStrategy;
+exports.EDataFilterOperator = EDataFilterOperator;
+exports.RequestProvider = RequestProvider;