@katlux/providers 0.1.1-alpha.101 → 0.1.1-alpha.103

package/dist/index.cjs

@@ -21,7 +21,8 @@ var EDataFilterOperator = /* @__PURE__ */ ((EDataFilterOperator2) => {
 })(EDataFilterOperator || {});
 var ECacheStrategy = /* @__PURE__ */ ((ECacheStrategy2) => {
   ECacheStrategy2["Application"] = "Application";
-  ECacheStrategy2["Session"] = "Session";
+  ECacheStrategy2["ServerSession"] = "ServerSession";
+  ECacheStrategy2["BrowserSession"] = "BrowserSession";
   ECacheStrategy2["Memory"] = "Memory";
   ECacheStrategy2["LocalStorage"] = "LocalStorage";
   ECacheStrategy2["IndexedDB"] = "IndexedDB";
@@ -311,14 +312,16 @@ class ADataProvider {
       } catch {
       }
     }
+    const filterDebounceTime = typeof options?.filterDebounce === "number" ? options.filterDebounce : 300;
+    const sortDebounceTime = typeof options?.sortDebounce === "number" ? options.sortDebounce : 200;
     this._debouncedFilterLoad = useDebounce(() => {
       this._currentPage = 1;
       this.loadPageData();
-    }, 300);
+    }, filterDebounceTime);
     this._debouncedSortLoad = useDebounce(() => {
       this._currentPage = 1;
       this.loadPageData();
-    }, 200);
+    }, sortDebounceTime);
     this.setFilter = this.setFilter.bind(this);
     this.setSortList = this.setSortList.bind(this);
     this.setCurrentPage = this.setCurrentPage.bind(this);
@@ -409,14 +412,21 @@ class ADataProvider {
       selectAll: this.selectAll
     };
   }
-  setFilter(filter) {
+  setFilter(filter, immediate = false) {
     this._filter = filter;
-    this._debouncedFilterLoad();
+    this._currentPage = 1;
+    if (immediate) {
+      this._debouncedFilterLoad?.cancel?.();
+      this.loadPageData();
+    } else {
+      this._debouncedFilterLoad();
+    }
   }
   setSortList(sortList, immediate = false) {
     this._sortList = sortList;
     this._currentPage = 1;
     if (immediate) {
+      this._debouncedSortLoad?.cancel?.();
       this.loadPageData();
     } else {
       this._debouncedSortLoad();
@@ -496,22 +506,38 @@ const compareValues = (rowValue, filterValue) => {
   return String(rowValue).localeCompare(String(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;
-  });
+  if (!nested) return true;
+  const subFilters = Array.isArray(nested) ? nested : typeof nested === "object" ? Object.values(nested) : [];
+  const len = subFilters.length;
+  for (let i = 0; i < len; i++) {
+    const f = subFilters[i];
+    if (f && typeof f === "object" && "operator" in f && "field" in f) {
+      const active = f.active !== false;
+      if (active && !evaluateFilter(f, row)) {
+        return false;
+      }
+    }
+  }
+  return 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);
-  });
+  if (!nested) return true;
+  const subFilters = Array.isArray(nested) ? nested : typeof nested === "object" ? Object.values(nested) : [];
+  const len = subFilters.length;
+  let hasActive = false;
+  for (let i = 0; i < len; i++) {
+    const f = subFilters[i];
+    if (f && typeof f === "object" && "operator" in f && "field" in f) {
+      const active = f.active !== false;
+      if (active) {
+        hasActive = true;
+        if (evaluateFilter(f, row)) {
+          return true;
+        }
+      }
+    }
+  }
+  return !hasActive;
 };
 const applyOperator = (operator, rowValue, filterValue) => {
   switch (operator) {
@@ -544,20 +570,26 @@ const applyOperator = (operator, rowValue, filterValue) => {
   }
 };
 const evaluateFilter = (filter, row) => {
-  if (!filter || !filter.operator) return true;
-  if (filter.operator === EDataFilterOperator.And || filter.operator === EDataFilterOperator.Or || filter.operator === EDataFilterOperator.Nand || filter.operator === EDataFilterOperator.Nor) {
-    return !filter.active || applyOperator(filter.operator, row, filter.field);
+  if (!filter || !filter.operator || filter.active === false) return true;
+  const op = filter.operator;
+  if (op === EDataFilterOperator.And || op === EDataFilterOperator.Or || op === EDataFilterOperator.Nand || op === EDataFilterOperator.Nor) {
+    return applyOperator(op, row, filter.field);
   }
   if (filter.field && typeof filter.field === "object" && "operator" in filter.field && "field" in filter.field) {
-    return !filter.active || evaluateFilter(filter.field, row);
+    return 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);
-  });
+  if (!field || typeof field !== "object") return true;
+  for (const key in field) {
+    if (Object.prototype.hasOwnProperty.call(field, key)) {
+      const filterValue = field[key];
+      const rowValue = row ? row[key] : void 0;
+      if (!applyOperator(op, rowValue, filterValue)) {
+        return false;
+      }
+    }
+  }
+  return true;
 };
 const filterTreeData = (nodes, filter, options) => {
   const { idKey, parentKey } = options;
@@ -625,7 +657,13 @@ const filterData = (data, filter, options) => {
     );
     return { results: visibleNodes, expandedNodes };
   }
-  const results = data.filter((row) => evaluateFilter(filter, row));
+  const len = data.length;
+  const results = [];
+  for (let i = 0; i < len; i++) {
+    if (evaluateFilter(filter, data[i])) {
+      results.push(data[i]);
+    }
+  }
   return { results };
 };
 const useFilterLogic = () => {
@@ -693,16 +731,50 @@ const useSortLogic = () => {
 };
 
 class CFlatClientDataProvider extends ADataProvider {
-  allData = [];
+  _allData = [];
   filteredData = [];
+  // Reference map array holding active sorted & filtered row references
+  _rowMap = [];
+  _filterDirty = true;
+  _sortDirty = true;
   constructor(options) {
     super(options);
   }
+  get allData() {
+    return this._allData;
+  }
+  set allData(data) {
+    this._allData = Array.isArray(data) ? data : [];
+    this._filterDirty = true;
+    this._sortDirty = true;
+  }
+  get rowMap() {
+    return this._rowMap;
+  }
   setData(data) {
     this.allData = Array.isArray(data) ? data : [];
     this.loadPageData();
   }
+  setFilter(filter, immediate = false) {
+    this._filterDirty = true;
+    this._sortDirty = true;
+    super.setFilter(filter, immediate);
+  }
+  setSortList(sortList, immediate = false) {
+    this._sortDirty = true;
+    super.setSortList(sortList, immediate);
+  }
+  /**
+   * Explicitly rebuilds the reference map array if row properties inside allData were mutated in-place.
+   */
+  updateMap() {
+    this._filterDirty = true;
+    this._sortDirty = true;
+    this.loadPageData();
+  }
   async refreshData(options) {
+    this._filterDirty = true;
+    this._sortDirty = true;
     await this.loadPageData();
   }
   async refresh(hardRefresh = false) {
@@ -713,22 +785,31 @@ class CFlatClientDataProvider extends ADataProvider {
       this.loading = true;
       this.error = null;
       try {
-        if (!this.filter) {
-          this.filteredData = this.allData;
-        } else {
-          const { results } = filterData(this.allData, this.filter);
-          this.filteredData = results;
+        if (this._filterDirty) {
+          if (!this.filter || !this.filter.active) {
+            this.filteredData = this.allData;
+          } else {
+            const { results } = filterData(this.allData, this.filter);
+            this.filteredData = results;
+          }
+          this.rowCount = this.filteredData.length;
+          this._filterDirty = false;
+          this._sortDirty = true;
         }
-        this.rowCount = this.filteredData.length;
-        if (this.sortList.length > 0) {
-          this.filteredData = sortData(this.sortList, this.filteredData);
+        if (this._sortDirty) {
+          if (this.sortList.length > 0) {
+            this._rowMap = sortData(this.sortList, this.filteredData);
+          } else {
+            this._rowMap = this.filteredData;
+          }
+          this._sortDirty = false;
         }
         if (this.pageSize <= 0) {
-          this.pageData = this.filteredData;
+          this.pageData = this._rowMap;
         } else {
           const startIndex = (this.currentPage - 1) * this.pageSize;
           const endIndex = startIndex + this.pageSize;
-          this.pageData = this.filteredData.slice(startIndex, endIndex);
+          this.pageData = this._rowMap.slice(startIndex, endIndex);
         }
       } catch (err) {
         this.error = err;
@@ -746,7 +827,8 @@ class CacheProviderFactory {
   static customDrivers = /* @__PURE__ */ new Map();
   static defaultLoaders = {
     [ECacheStrategy.Application]: () => Promise.resolve().then(function () { return CApplicationCache$1; }).then((m) => m.CApplicationCache),
-    [ECacheStrategy.Session]: () => Promise.resolve().then(function () { return CSessionCache$1; }).then((m) => m.CSessionCache),
+    [ECacheStrategy.ServerSession]: () => Promise.resolve().then(function () { return CServerSessionCache$1; }).then((m) => m.CServerSessionCache),
+    [ECacheStrategy.BrowserSession]: () => Promise.resolve().then(function () { return CBrowserSessionCache$1; }).then((m) => m.CBrowserSessionCache),
     [ECacheStrategy.Memory]: () => Promise.resolve().then(function () { return CMemoryCache$1; }).then((m) => m.CMemoryCache),
     [ECacheStrategy.LocalStorage]: () => Promise.resolve().then(function () { return CLocalStorageCache$1; }).then((m) => m.CLocalStorageCache),
     [ECacheStrategy.IndexedDB]: () => Promise.resolve().then(function () { return CIndexedDBCache$1; }).then((m) => m.CIndexedDBCache),
@@ -2364,7 +2446,7 @@ class CAPIFlatClientDataProvider extends CFlatClientDataProvider {
         } else {
           this.allData[index] = { ...this.allData[index], ...item };
         }
-        this.loadPageData();
+        this.updateMap();
       }
       if (this.requestProvider.cacheProvider) {
         await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl);
@@ -2637,10 +2719,16 @@ class CTreeClientDataProvider extends CFlatClientDataProvider {
   _staticNodesCache = null;
   _nodeMapCache = null;
   _sortedNodeIdsCache = null;
+  _filteredNodesCache = null;
   invalidateStaticCache() {
     this._staticNodesCache = null;
     this._nodeMapCache = null;
     this._sortedNodeIdsCache = null;
+    this._filteredNodesCache = null;
+  }
+  setFilter(filter, immediate = false) {
+    this._filteredNodesCache = null;
+    super.setFilter(filter, immediate);
   }
   get _staticNodes() {
     if (!this._staticNodesCache) {
@@ -2853,29 +2941,32 @@ class CTreeClientDataProvider extends CFlatClientDataProvider {
     const nodeMap = this._nodeMap;
     const sortedIds = this._sortedNodeIds;
     if (this.filter && this.filter.active) {
-      const matchingNodes = this._staticNodes.filter((node) => evaluateFilter(this.filter, node.data));
-      const matchingIds = new Set(matchingNodes.map((node) => node.id));
-      const visibleIds = /* @__PURE__ */ new Set();
-      matchingIds.forEach((id) => {
-        let current = nodeMap.get(id);
-        while (current) {
-          visibleIds.add(current.id);
-          current = current.parentId != null ? nodeMap.get(current.parentId) : void 0;
-        }
-      });
-      const filterExpanded = new Set(this.expandedNodes);
-      visibleIds.forEach((id) => {
-        if (nodeMap.get(id)?.hasChildren) {
-          filterExpanded.add(id);
-        }
-      });
-      const filteredNodes = sortedIds.filter((id) => visibleIds.has(id)).map((id) => {
-        const node = nodeMap.get(id);
-        return {
-          ...node,
-          isExpanded: filterExpanded.has(id)
-        };
-      });
+      if (!this._filteredNodesCache) {
+        const matchingNodes = this._staticNodes.filter((node) => evaluateFilter(this.filter, node.data));
+        const matchingIds = new Set(matchingNodes.map((node) => node.id));
+        const visibleIds = /* @__PURE__ */ new Set();
+        matchingIds.forEach((id) => {
+          let current = nodeMap.get(id);
+          while (current) {
+            visibleIds.add(current.id);
+            current = current.parentId != null ? nodeMap.get(current.parentId) : void 0;
+          }
+        });
+        const filterExpanded = new Set(this.expandedNodes);
+        visibleIds.forEach((id) => {
+          if (nodeMap.get(id)?.hasChildren) {
+            filterExpanded.add(id);
+          }
+        });
+        this._filteredNodesCache = sortedIds.filter((id) => visibleIds.has(id)).map((id) => {
+          const node = nodeMap.get(id);
+          return {
+            ...node,
+            isExpanded: filterExpanded.has(id)
+          };
+        });
+      }
+      const filteredNodes = this._filteredNodesCache;
       this.filteredData = filteredNodes;
       const paginated = this.paginateNodes(filteredNodes);
       this.pageData = paginated.map((node) => ({
@@ -3723,16 +3814,16 @@ const CCookieCache$1 = {
 	CCookieCache: CCookieCache
 };
 
-class CSessionCache extends ACacheProvider {
+class CServerSessionCache extends ACacheProvider {
   static instance = null;
   static getInstance() {
     if (!this.instance) {
-      this.instance = new CSessionCache();
+      this.instance = new CServerSessionCache();
     }
     return this.instance;
   }
   static get storage() {
-    const globalKey = Symbol.for("Katlux_CSessionCache_Storage");
+    const globalKey = Symbol.for("Katlux_CServerSessionCache_Storage");
     const _global = globalThis;
     if (!_global[globalKey]) {
       _global[globalKey] = /* @__PURE__ */ new Map();
@@ -3751,7 +3842,7 @@ class CSessionCache extends ACacheProvider {
     const now = Date.now();
     const prefix = "cache:";
     const sessionsToDelete = [];
-    for (const [sessionId, sessionData] of CSessionCache.storage.entries()) {
+    for (const [sessionId, sessionData] of CServerSessionCache.storage.entries()) {
       const keysToDelete = [];
       for (const [key, entry] of sessionData.entries()) {
         if (key.startsWith(prefix) && now - entry.timestamp > entry.lifetime) {
@@ -3766,19 +3857,18 @@ class CSessionCache extends ACacheProvider {
       }
     }
     for (const sessionId of sessionsToDelete) {
-      CSessionCache.storage.delete(sessionId);
+      CServerSessionCache.storage.delete(sessionId);
     }
-    while (CSessionCache.storage.size >= CSessionCache.MAX_SERVER_SESSIONS && CSessionCache.storage.size > 0) {
-      const oldestSessionKey = CSessionCache.storage.keys().next().value;
+    while (CServerSessionCache.storage.size >= CServerSessionCache.MAX_SERVER_SESSIONS && CServerSessionCache.storage.size > 0) {
+      const oldestSessionKey = CServerSessionCache.storage.keys().next().value;
       if (oldestSessionKey) {
-        CSessionCache.storage.delete(oldestSessionKey);
+        CServerSessionCache.storage.delete(oldestSessionKey);
       } else {
         break;
       }
     }
   }
   sessionIdCache = null;
-  sessionId = null;
   SESSION_ID_KEY = "_session_id";
   constructor() {
     super();
@@ -3806,57 +3896,34 @@ class CSessionCache extends ACacheProvider {
     });
   }
   /**
-   * Get or create sessionId
+   * Get or create sessionId — server-only path.
+   * Returns '__no_session__' sentinel when no isolatable H3 event context is available.
    */
   async getSessionId(context) {
     const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
-    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
-    if (isServer && !event) {
+    if (!event) {
       return "__no_session__";
     }
     const contextSessionId = event?.context?.sessionId;
     if (contextSessionId) {
       return contextSessionId;
     }
-    if (!isServer && this.sessionId) {
-      return this.sessionId;
-    }
     let existingId = null;
-    if (isServer && event) {
-      const req = event.node?.req || event.req;
-      const cookieHeader = req?.headers?.cookie || "";
-      const match = cookieHeader.match(/(?:^|; )_session_id=([^;]*)/);
-      if (match) existingId = decodeURIComponent(match[1]);
-    } else if (!isServer && typeof document !== "undefined") {
-      const match = document.cookie.match(/(?:^|; )_session_id=([^;]*)/);
-      if (match) existingId = decodeURIComponent(match[1]);
-    }
+    const req = event.node?.req || event.req;
+    const cookieHeader = req?.headers?.cookie || "";
+    const match = cookieHeader.match(/(?:^|; )_session_id=([^;]*)/);
+    if (match) existingId = decodeURIComponent(match[1]);
     if (!existingId && this.sessionIdCache) {
       existingId = await this.sessionIdCache.get(this.SESSION_ID_KEY, context);
     }
     if (existingId) {
-      if (isServer) {
-        if (event) {
-          if (!event.context) event.context = {};
-          event.context.sessionId = existingId;
-        }
-      } else {
-        this.sessionId = existingId;
-      }
+      if (!event.context) event.context = {};
+      event.context.sessionId = existingId;
       return existingId;
     }
     const newId = this.generateSessionId();
-    if (isServer) {
-      if (event) {
-        if (!event.context) event.context = {};
-        event.context.sessionId = newId;
-      }
-    } else {
-      this.sessionId = newId;
-      if (typeof document !== "undefined") {
-        document.cookie = `_session_id=${encodeURIComponent(newId)}; path=/; max-age=31536000; SameSite=Lax`;
-      }
-    }
+    if (!event.context) event.context = {};
+    event.context.sessionId = newId;
     if (this.sessionIdCache) {
       await this.sessionIdCache.set(this.SESSION_ID_KEY, newId, 365 * 24 * 60 * 60 * 1e3, context);
     }
@@ -3864,71 +3931,30 @@ class CSessionCache extends ACacheProvider {
   }
   async getKeyList(context) {
     const prefix = "cache:";
-    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
-    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
-    if (isServer) {
-      const sessionId = await this.getSessionId(context);
-      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));
-    }
-    if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
-      return Object.keys(sessionStorage).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+    const sessionId = await this.getSessionId(context);
+    const sessionData = CServerSessionCache.storage.get(sessionId);
+    if (!sessionData) {
+      return [];
     }
-    return [];
+    return Array.from(sessionData.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
   }
   async get(key, context) {
     const prefixedKey = "cache:" + key;
-    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
-    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
-    if (isServer) {
-      const sessionId = await this.getSessionId(context);
-      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;
-      }
+    const sessionId = await this.getSessionId(context);
+    const sessionData = CServerSessionCache.storage.get(sessionId);
+    if (!sessionData) {
+      return null;
     }
-    if (typeof window !== "undefined" && typeof sessionStorage !== "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) {
-        console.warn("[Katlux Cache] CSessionCache parse error for key: " + key, e);
-      }
-      try {
-        const payloadData = getSSRPayload(context);
-        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) {
-        console.warn("[Katlux Cache] CSessionCache SSR payload fallback error for key: " + key, e);
-      }
+    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, context) {
     const prefixedKey = "cache:" + key;
@@ -3937,181 +3963,237 @@ class CSessionCache extends ACacheProvider {
       timestamp: Date.now(),
       lifetime
     };
-    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
-    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
-    if (isServer) {
-      try {
-        const sessionId = await this.getSessionId(context);
-        if (sessionId === "__no_session__") return;
-        if (CSessionCache.storage.size >= CSessionCache.MAX_SERVER_SESSIONS) {
-          CSessionCache.purgeExpiredServerSessions();
-        }
-        let sessionData = CSessionCache.storage.get(sessionId);
-        if (!sessionData) {
-          sessionData = /* @__PURE__ */ new Map();
-          CSessionCache.storage.set(sessionId, sessionData);
-        }
-        sessionData.set(prefixedKey, entry);
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache server session storage error for key: " + key, e);
+    try {
+      const sessionId = await this.getSessionId(context);
+      if (sessionId === "__no_session__") return;
+      if (CServerSessionCache.storage.size >= CServerSessionCache.MAX_SERVER_SESSIONS) {
+        CServerSessionCache.purgeExpiredServerSessions();
       }
-      return;
-    }
-    if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
-      try {
-        sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache sessionStorage setItem error (possible quota exceeded) for key: " + key, e);
+      let sessionData = CServerSessionCache.storage.get(sessionId);
+      if (!sessionData) {
+        sessionData = /* @__PURE__ */ new Map();
+        CServerSessionCache.storage.set(sessionId, sessionData);
       }
+      sessionData.set(prefixedKey, entry);
+    } catch (e) {
+      console.warn("[Katlux Cache] CServerSessionCache server session storage error for key: " + key, e);
     }
   }
   async remove(key, context) {
     const prefixedKey = "cache:" + key;
-    const event = context?.event ?? context?.ssrContext?.event ?? (context?.node ? context : null);
-    const isServer = typeof window === "undefined" || !!event || !!context?.ssrContext;
-    if (isServer) {
-      try {
-        const sessionId = await this.getSessionId(context);
-        const sessionData = CSessionCache.storage.get(sessionId);
-        if (sessionData) {
-          sessionData.delete(prefixedKey);
-        }
-        if (context) {
-          const payload = context.payload?.data || context.ssrContext?.payload?.data;
-          if (payload && payload[prefixedKey]) {
-            delete payload[prefixedKey];
-          }
+    try {
+      const sessionId = await this.getSessionId(context);
+      const sessionData = CServerSessionCache.storage.get(sessionId);
+      if (sessionData) {
+        sessionData.delete(prefixedKey);
+      }
+      if (context) {
+        const payload = context.payload?.data || context.ssrContext?.payload?.data;
+        if (payload && payload[prefixedKey]) {
+          delete payload[prefixedKey];
         }
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache remove error on server for key: " + key, e);
       }
-      return;
-    }
-    if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
-      sessionStorage.removeItem(prefixedKey);
+    } catch (e) {
+      console.warn("[Katlux Cache] CServerSessionCache remove error for key: " + key, e);
     }
   }
   async removeByPrefix(prefix, context) {
     const fullPrefix = "cache:" + prefix;
-    if (typeof window !== "undefined") {
-      const keysToDelete = [];
-      for (let i = 0; i < sessionStorage.length; i++) {
-        const key = sessionStorage.key(i);
-        if (key && key.startsWith(fullPrefix)) {
-          keysToDelete.push(key);
+    try {
+      const sessionId = await this.getSessionId(context);
+      const sessionData = CServerSessionCache.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);
         }
       }
-      for (const key of keysToDelete) {
-        sessionStorage.removeItem(key);
-      }
-    }
-    if (typeof window === "undefined") {
-      try {
-        const sessionId = await this.getSessionId(context);
-        const sessionData = CSessionCache.storage.get(sessionId);
-        if (sessionData) {
-          const keysToDelete = [];
-          for (const key of sessionData.keys()) {
+      if (context) {
+        const payload = context.payload?.data || context.ssrContext?.payload?.data;
+        if (payload) {
+          for (const key in payload) {
             if (key.startsWith(fullPrefix)) {
-              keysToDelete.push(key);
-            }
-          }
-          for (const key of keysToDelete) {
-            sessionData.delete(key);
-          }
-        }
-        if (context) {
-          const payload = context.payload?.data || context.ssrContext?.payload?.data;
-          if (payload) {
-            for (const key in payload) {
-              if (key.startsWith(fullPrefix)) {
-                delete payload[key];
-              }
+              delete payload[key];
             }
           }
         }
-      } catch (e) {
-        console.warn("[Katlux Cache] CSessionCache removeByPrefix error on server for prefix: " + prefix, e);
       }
+    } catch (e) {
+      console.warn("[Katlux Cache] CServerSessionCache removeByPrefix error for prefix: " + prefix, e);
     }
   }
   async getRemainingTime(key, context) {
     const prefixedKey = "cache:" + key;
-    if (typeof window !== "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) {
-        console.warn("[Katlux Cache] CSessionCache getRemainingTime parse error for key: " + key, e);
-        return null;
-      }
-    }
-    if (typeof window === "undefined") {
-      const sessionId = await this.getSessionId(context);
-      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;
+    const sessionId = await this.getSessionId(context);
+    const sessionData = CServerSessionCache.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());
   }
   async cleanupExpired() {
     const prefix = "cache:";
     const now = Date.now();
-    if (typeof window !== "undefined") {
+    const sessionsToDelete = [];
+    for (const [sessionId, sessionData] of CServerSessionCache.storage.entries()) {
       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) {
-              console.warn("[Katlux Cache] CSessionCache cleanupExpired parse error for key: " + key, e);
-              keysToDelete.push(key);
-            }
+      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) {
-        sessionStorage.removeItem(key);
+        sessionData.delete(key);
+      }
+      if (sessionData.size === 0) {
+        sessionsToDelete.push(sessionId);
       }
     }
-    if (typeof window === "undefined" || CSessionCache.storage.size > 0) {
-      const sessionsToDelete = [];
-      for (const [sessionId, sessionData] of CSessionCache.storage.entries()) {
-        const keysToDelete = [];
-        for (const [key, entry] of sessionData.entries()) {
-          if (key.startsWith(prefix)) {
+    for (const sessionId of sessionsToDelete) {
+      CServerSessionCache.storage.delete(sessionId);
+    }
+  }
+}
+
+const CServerSessionCache$1 = {
+	__proto__: null,
+	CServerSessionCache: CServerSessionCache
+};
+
+class CBrowserSessionCache extends ACacheProvider {
+  static instance = null;
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new CBrowserSessionCache();
+    }
+    return this.instance;
+  }
+  PREFIX = "bscache:";
+  async getKeyList(_context) {
+    if (typeof window === "undefined") return [];
+    return Object.keys(sessionStorage).filter((key) => key.startsWith(this.PREFIX)).map((key) => key.substring(this.PREFIX.length));
+  }
+  async get(key, context) {
+    if (typeof window === "undefined") return null;
+    const prefixedKey = this.PREFIX + key;
+    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) {
+      console.warn("[Katlux Cache] CBrowserSessionCache parse error for key: " + key, e);
+    }
+    try {
+      const payloadData = getSSRPayload(context);
+      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) {
+      console.warn("[Katlux Cache] CBrowserSessionCache SSR payload hydration error for key: " + key, e);
+    }
+    return null;
+  }
+  async set(key, data, lifetime, context) {
+    const prefixedKey = this.PREFIX + key;
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      lifetime
+    };
+    if (typeof window === "undefined") {
+      try {
+        const payload = context?.payload?.data ?? context?.ssrContext?.payload?.data;
+        if (payload) {
+          payload[prefixedKey] = entry;
+        }
+      } catch (e) {
+        console.warn("[Katlux Cache] CBrowserSessionCache SSR payload write error for key: " + key, e);
+      }
+      return;
+    }
+    try {
+      sessionStorage.setItem(prefixedKey, JSON.stringify(entry));
+    } catch (e) {
+      console.warn("[Katlux Cache] CBrowserSessionCache sessionStorage setItem error (possible quota exceeded) for key: " + key, e);
+    }
+  }
+  async remove(key, _context) {
+    if (typeof window === "undefined") return;
+    sessionStorage.removeItem(this.PREFIX + key);
+  }
+  async removeByPrefix(prefix, _context) {
+    if (typeof window === "undefined") return;
+    const fullPrefix = this.PREFIX + prefix;
+    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);
+    }
+  }
+  async getRemainingTime(key, _context) {
+    if (typeof window === "undefined") return null;
+    const stored = sessionStorage.getItem(this.PREFIX + key);
+    if (!stored) return null;
+    try {
+      const entry = JSON.parse(stored);
+      return Math.max(0, entry.timestamp + entry.lifetime - Date.now());
+    } catch (e) {
+      console.warn("[Katlux Cache] CBrowserSessionCache getRemainingTime parse error for key: " + key, e);
+      return null;
+    }
+  }
+  async cleanupExpired(_context) {
+    if (typeof window === "undefined") return;
+    const now = Date.now();
+    const keysToDelete = [];
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const key = sessionStorage.key(i);
+      if (key && key.startsWith(this.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) {
+            console.warn("[Katlux Cache] CBrowserSessionCache cleanupExpired parse error for key: " + key, e);
+            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);
       }
     }
+    for (const key of keysToDelete) {
+      sessionStorage.removeItem(key);
+    }
   }
 }
 
-const CSessionCache$1 = {
+const CBrowserSessionCache$1 = {
 	__proto__: null,
-	CSessionCache: CSessionCache
+	CBrowserSessionCache: CBrowserSessionCache
 };
 
 class CLocalStorageCache extends ACacheProvider {
@@ -4560,13 +4642,14 @@ exports.CAPIFlatServerDataProvider = CAPIFlatServerDataProvider;
 exports.CAPITreeClientDataProvider = CAPITreeClientDataProvider;
 exports.CAPITreeServerDataProvider = CAPITreeServerDataProvider;
 exports.CApplicationCache = CApplicationCache;
+exports.CBrowserSessionCache = CBrowserSessionCache;
 exports.CCookieCache = CCookieCache;
 exports.CFlatClientDataProvider = CFlatClientDataProvider;
 exports.CFlatServerDataProvider = CFlatServerDataProvider;
 exports.CIndexedDBCache = CIndexedDBCache;
 exports.CLocalStorageCache = CLocalStorageCache;
 exports.CMemoryCache = CMemoryCache;
-exports.CSessionCache = CSessionCache;
+exports.CServerSessionCache = CServerSessionCache;
 exports.CTreeClientDataProvider = CTreeClientDataProvider;
 exports.CTreeServerDataProvider = CTreeServerDataProvider;
 exports.CacheProviderFactory = CacheProviderFactory;