@prorobotech/openapi-k8s-toolkit 1.0.3 → 1.1.0-alpha.2

package/dist/openapi-k8s-toolkit.umd.js

@@ -8342,6 +8342,649 @@
     });
   };
 
+  const useK8sVerbs = ({
+    cluster,
+    group,
+    version,
+    plural,
+    isEnabled = true
+  }) => {
+    const uri = `/api/clusters/${cluster}/openapi-bff/verbs/getResourceVerbs?${new URLSearchParams({
+    ...group ? { group } : {},
+    version,
+    plural
+  }).toString()}`;
+    const { data, isError, isLoading, error } = useDirectUnknownResource({
+      uri,
+      queryKey: ["k8s-verbs", group || "", version, plural],
+      refetchInterval: false,
+      isEnabled
+    });
+    const verbs = data?.verbs || [];
+    const canList = verbs.includes("list");
+    const canWatch = verbs.includes("watch");
+    return {
+      canList,
+      canWatch,
+      isError,
+      isLoading,
+      error
+    };
+  };
+
+  const eventKey$1 = (e) => {
+    const n = e.metadata?.name ?? "";
+    const ns = e.metadata?.namespace ?? "";
+    return `${ns}/${n}`;
+  };
+  const compareRV$1 = (a, b) => {
+    if (a.length !== b.length) return a.length > b.length ? 1 : -1;
+    return a > b ? 1 : a < b ? -1 : 0;
+  };
+  const getRV$1 = (item) => item?.metadata?.resourceVersion;
+
+  const reducer$1 = (state, action) => {
+    switch (action.type) {
+      case "RESET": {
+        const order = action.items.map(eventKey$1);
+        const byKey = {};
+        action.items.forEach((it) => byKey[eventKey$1(it)] = it);
+        return { order, byKey };
+      }
+      case "APPEND_PAGE": {
+        const next = { ...state.byKey };
+        const addKeys = [];
+        action.items.forEach((it) => {
+          const k = eventKey$1(it);
+          if (!next[k]) addKeys.push(k);
+          next[k] = it;
+        });
+        return { order: [...state.order, ...addKeys], byKey: next };
+      }
+      case "UPSERT": {
+        const k = eventKey$1(action.item);
+        const exists = Boolean(state.byKey[k]);
+        const byKey = { ...state.byKey, [k]: action.item };
+        const order = exists ? state.order : [k, ...state.order];
+        return { order, byKey };
+      }
+      case "REMOVE": {
+        if (!state.byKey[action.key]) return state;
+        const byKey = { ...state.byKey };
+        delete byKey[action.key];
+        return { order: state.order.filter((k) => k !== action.key), byKey };
+      }
+      default:
+        return state;
+    }
+  };
+
+  const isRecord = (v) => typeof v === "object" && v !== null;
+  const readString = (obj, key) => {
+    const val = obj[key];
+    return typeof val === "string" ? val : void 0;
+  };
+  const itemRV = (it) => {
+    const fromUtil = getRV$1(it);
+    if (fromUtil) return fromUtil;
+    if (!isRecord(it)) return void 0;
+    const rvTop = readString(it, "resourceVersion");
+    const mdRaw = isRecord(it["metadata"]) ? it["metadata"] : void 0;
+    const rvMeta = mdRaw ? readString(mdRaw, "resourceVersion") : void 0;
+    return rvTop ?? rvMeta;
+  };
+  const getMaxRV$1 = (items) => (items ?? []).reduce((max, it) => {
+    const rv = itemRV(it);
+    return rv && (!max || compareRV$1(rv, max) > 0) ? rv : max;
+  }, void 0);
+  const makeResId = (q) => `${q.apiGroup ?? ""}|${q.apiVersion}|${q.plural}|${q.namespace ?? ""}|${q.fieldSelector ?? ""}|${q.labelSelector ?? ""}`;
+  const useListWatch = ({
+    wsUrl,
+    pageSize,
+    paused = false,
+    ignoreRemove = false,
+    onStatus,
+    onError,
+    autoDrain = false,
+    preserveStateOnUrlChange = true,
+    isEnabled = true,
+    // NEW default: socket gated by this flag
+    query
+  }) => {
+    const resId = `${query.apiGroup ?? ""}|${query.apiVersion}|${query.plural}|${query.namespace ?? ""}|${query.fieldSelector ?? ""}|${query.labelSelector ?? ""}`;
+    const resIdRef = K.useRef(resId);
+    const [state, dispatch] = K.useReducer(reducer$1, { order: [], byKey: {} });
+    const [contToken, setContToken] = K.useState();
+    const [hasMore, setHasMore] = K.useState(false);
+    const [status, setStatus] = K.useState(isEnabled ? "connecting" : "closed");
+    const [lastError, setLastError] = K.useState(void 0);
+    const [isPaused, setIsPaused] = K.useState(paused);
+    const [isRemoveIgnored, setIsRemoveIgnored] = K.useState(ignoreRemove);
+    const queryRef = K.useRef(query);
+    const wsRef = K.useRef(null);
+    const connectingRef = K.useRef(false);
+    const mountedRef = K.useRef(true);
+    const startedRef = K.useRef(false);
+    const reconnectTimerRef = K.useRef(null);
+    const backoffRef = K.useRef(750);
+    const urlRef = K.useRef(wsUrl);
+    const onMessageRef = K.useRef(() => {
+    });
+    const connectRef = K.useRef(() => {
+    });
+    const fetchingRef = K.useRef(false);
+    const anchorRVRef = K.useRef(void 0);
+    const haveAnchorRef = K.useRef(false);
+    const enabledRef = K.useRef(isEnabled);
+    const intentionalCloseRef = K.useRef(false);
+    const suppressErrorsRef = K.useRef(false);
+    const pausedRef = K.useRef(isPaused);
+    const ignoreRemoveRef = K.useRef(isRemoveIgnored);
+    K.useEffect(() => {
+      pausedRef.current = isPaused;
+    }, [isPaused]);
+    K.useEffect(() => {
+      ignoreRemoveRef.current = isRemoveIgnored;
+    }, [isRemoveIgnored]);
+    K.useEffect(() => {
+      enabledRef.current = isEnabled;
+    }, [isEnabled]);
+    const clearErrorSafe = K.useCallback(() => {
+      setLastError(void 0);
+    }, []);
+    const setStatusSafe = K.useCallback(
+      (s) => {
+        setStatus(s);
+        onStatus?.(s);
+      },
+      [onStatus]
+    );
+    const setErrorSafe = K.useCallback(
+      (msg) => {
+        setLastError(msg);
+        if (msg) onError?.(msg);
+      },
+      [onError]
+    );
+    const applyParam = (sp, key, v) => {
+      if (v === void 0 || v === null || v === "") {
+        sp.delete(key);
+        return;
+      }
+      sp.set(key, String(v));
+    };
+    const buildWsUrl = K.useCallback((raw) => {
+      let u;
+      const base = window.location.origin;
+      try {
+        const hasScheme = /^[a-z]+:/i.test(raw);
+        u = hasScheme ? new URL(raw) : new URL(raw.startsWith("/") ? raw : `/${raw}`, base);
+        if (u.protocol === "http:") u.protocol = "ws:";
+        if (u.protocol === "https:") u.protocol = "wss:";
+        if (u.protocol !== "ws:" && u.protocol !== "wss:") {
+          u = new URL(u.pathname + u.search + u.hash, base);
+          u.protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+        }
+      } catch {
+        const origin = window.location.origin.replace(/^http/, "ws");
+        u = new URL(raw.startsWith("/") ? raw : `/${raw}`, origin);
+      }
+      const q = queryRef.current;
+      applyParam(u.searchParams, "namespace", q.namespace);
+      applyParam(u.searchParams, "limit", q.initialLimit);
+      applyParam(u.searchParams, "_continue", q.initialContinue);
+      applyParam(u.searchParams, "apiGroup", q.apiGroup);
+      applyParam(u.searchParams, "apiVersion", q.apiVersion);
+      applyParam(u.searchParams, "plural", q.plural);
+      applyParam(u.searchParams, "fieldSelector", q.fieldSelector);
+      applyParam(u.searchParams, "labelSelector", q.labelSelector);
+      if (haveAnchorRef.current && anchorRVRef.current) {
+        u.searchParams.set("sinceRV", anchorRVRef.current);
+      } else {
+        u.searchParams.delete("sinceRV");
+      }
+      return u.toString();
+    }, []);
+    const closeWS = K.useCallback(() => {
+      try {
+        wsRef.current?.close();
+      } catch {
+      }
+      wsRef.current = null;
+    }, []);
+    const scheduleReconnect = K.useCallback(() => {
+      if (intentionalCloseRef.current) {
+        intentionalCloseRef.current = false;
+        return;
+      }
+      if (!enabledRef.current) {
+        setStatusSafe("closed");
+        connectingRef.current = false;
+        return;
+      }
+      setStatusSafe("closed");
+      connectingRef.current = false;
+      const baseDelay = Math.min(backoffRef.current, 8e3);
+      const jitter = Math.random() * 0.4 + 0.8;
+      const wait = Math.floor(baseDelay * jitter);
+      const next = Math.min(baseDelay * 2, 12e3);
+      backoffRef.current = next;
+      if (reconnectTimerRef.current) {
+        window.clearTimeout(reconnectTimerRef.current);
+        reconnectTimerRef.current = null;
+      }
+      reconnectTimerRef.current = window.setTimeout(() => {
+        if (!mountedRef.current || !enabledRef.current) return;
+        connectRef.current();
+      }, wait);
+    }, [setStatusSafe]);
+    const connect = K.useCallback(() => {
+      if (!mountedRef.current) return;
+      if (!enabledRef.current) {
+        setStatusSafe("closed");
+        return;
+      }
+      if (connectingRef.current) return;
+      if (wsRef.current && (wsRef.current.readyState === WebSocket.OPEN || wsRef.current.readyState === WebSocket.CONNECTING)) {
+        return;
+      }
+      connectingRef.current = true;
+      setStatusSafe("connecting");
+      setErrorSafe(void 0);
+      const url = buildWsUrl(urlRef.current);
+      console.debug("[useListWatch] connecting to", url);
+      const ws = new WebSocket(url);
+      wsRef.current = ws;
+      ws.addEventListener("open", () => {
+        if (!mountedRef.current || !enabledRef.current) return;
+        backoffRef.current = 750;
+        fetchingRef.current = false;
+        setStatusSafe("open");
+        connectingRef.current = false;
+        suppressErrorsRef.current = false;
+      });
+      ws.addEventListener("message", (ev) => onMessageRef.current(ev));
+      ws.addEventListener("close", scheduleReconnect);
+      ws.addEventListener("error", () => {
+        if (intentionalCloseRef.current || suppressErrorsRef.current) return;
+        setErrorSafe("WebSocket error");
+      });
+    }, [buildWsUrl, scheduleReconnect, setErrorSafe, setStatusSafe]);
+    K.useEffect(() => {
+      connectRef.current = connect;
+    }, [connect]);
+    const reconnect = K.useCallback(() => {
+      if (!enabledRef.current) {
+        closeWS();
+        setStatusSafe("closed");
+        return;
+      }
+      if (reconnectTimerRef.current) {
+        window.clearTimeout(reconnectTimerRef.current);
+        reconnectTimerRef.current = null;
+      }
+      intentionalCloseRef.current = true;
+      try {
+        wsRef.current?.close();
+      } catch {
+      }
+      wsRef.current = null;
+      connect();
+    }, [closeWS, connect, setStatusSafe]);
+    K.useEffect(() => {
+      if (!mountedRef.current) return;
+      if (isEnabled) {
+        connect();
+      } else {
+        if (reconnectTimerRef.current) {
+          window.clearTimeout(reconnectTimerRef.current);
+          reconnectTimerRef.current = null;
+        }
+        closeWS();
+        setStatusSafe("closed");
+      }
+    }, [isEnabled, closeWS, connect, setStatusSafe]);
+    const setUrl = K.useCallback(
+      (next) => {
+        const changed = next !== urlRef.current;
+        urlRef.current = next;
+        if (changed) {
+          clearErrorSafe();
+          suppressErrorsRef.current = true;
+          if (!preserveStateOnUrlChange) {
+            dispatch({ type: "RESET", items: [] });
+            setContToken(void 0);
+            setHasMore(false);
+            anchorRVRef.current = void 0;
+            haveAnchorRef.current = false;
+          }
+          if (enabledRef.current) reconnect();
+        }
+      },
+      [preserveStateOnUrlChange, reconnect, clearErrorSafe]
+    );
+    const setQuery = K.useCallback(
+      (q) => {
+        clearErrorSafe();
+        suppressErrorsRef.current = true;
+        const prev = queryRef.current;
+        const prevId = makeResId(prev);
+        const nextId = makeResId(q);
+        queryRef.current = q;
+        if (!preserveStateOnUrlChange) {
+          dispatch({ type: "RESET", items: [] });
+          setContToken(void 0);
+          setHasMore(false);
+        }
+        if (prevId !== nextId) {
+          anchorRVRef.current = void 0;
+          haveAnchorRef.current = false;
+        }
+        if (enabledRef.current && prevId !== nextId) {
+          reconnect();
+        }
+      },
+      [clearErrorSafe, preserveStateOnUrlChange, reconnect]
+    );
+    const total = state.order.length;
+    const continueToken = contToken;
+    K.useEffect(() => {
+      onMessageRef.current = (ev) => {
+        let frame;
+        try {
+          frame = JSON.parse(String(ev.data));
+        } catch {
+          return;
+        }
+        if (!frame) return;
+        if (frame.type === "INITIAL") {
+          dispatch({ type: "RESET", items: frame.items });
+          setContToken(frame.continue);
+          setHasMore(Boolean(frame.continue));
+          setErrorSafe(void 0);
+          fetchingRef.current = false;
+          suppressErrorsRef.current = false;
+          const snapshotRV = frame.resourceVersion || getMaxRV$1(frame.items);
+          if (snapshotRV) {
+            anchorRVRef.current = snapshotRV;
+            haveAnchorRef.current = true;
+          }
+          return;
+        }
+        if (frame.type === "PAGE") {
+          dispatch({ type: "APPEND_PAGE", items: frame.items });
+          setContToken(frame.continue);
+          setHasMore(Boolean(frame.continue));
+          fetchingRef.current = false;
+          const batchRV = getMaxRV$1(frame.items);
+          if (batchRV && (!anchorRVRef.current || compareRV$1(batchRV, anchorRVRef.current) > 0)) {
+            anchorRVRef.current = batchRV;
+          }
+          return;
+        }
+        if (frame.type === "PAGE_ERROR") {
+          setErrorSafe(frame.error || "Failed to load next page");
+          fetchingRef.current = false;
+          return;
+        }
+        if (frame.type === "ADDED" || frame.type === "MODIFIED" || frame.type === "DELETED") {
+          const rv = itemRV(frame.item);
+          if (rv && (!anchorRVRef.current || compareRV$1(rv, anchorRVRef.current) > 0)) {
+            anchorRVRef.current = rv;
+          }
+        }
+        if (!pausedRef.current) {
+          if (frame.type === "ADDED" || frame.type === "MODIFIED") {
+            dispatch({ type: "UPSERT", item: frame.item });
+          }
+          if (!ignoreRemoveRef.current && frame.type === "DELETED") {
+            dispatch({ type: "REMOVE", key: eventKey$1(frame.item) });
+          }
+        }
+      };
+    }, [setErrorSafe]);
+    K.useEffect(() => {
+      if (startedRef.current) return void 0;
+      startedRef.current = true;
+      mountedRef.current = true;
+      if (isEnabled) {
+        connect();
+      } else {
+        setStatusSafe("closed");
+      }
+      return () => {
+        mountedRef.current = false;
+        startedRef.current = false;
+        if (reconnectTimerRef.current) {
+          window.clearTimeout(reconnectTimerRef.current);
+          reconnectTimerRef.current = null;
+        }
+        closeWS();
+        wsRef.current = null;
+        connectingRef.current = false;
+      };
+    }, []);
+    K.useEffect(() => {
+      if (wsUrl !== urlRef.current) setUrl(wsUrl);
+    }, [wsUrl, setUrl]);
+    K.useEffect(() => {
+      if (resIdRef.current !== resId) {
+        clearErrorSafe();
+        suppressErrorsRef.current = true;
+        anchorRVRef.current = void 0;
+        haveAnchorRef.current = false;
+        resIdRef.current = resId;
+        queryRef.current = query;
+        if (enabledRef.current) reconnect();
+      }
+    }, [resId, query, reconnect, clearErrorSafe]);
+    const pageSizeRef = K.useRef(pageSize);
+    K.useEffect(() => {
+      pageSizeRef.current = pageSize;
+    }, [pageSize]);
+    const sendScroll = K.useCallback(() => {
+      if (!enabledRef.current) return;
+      const token = contToken;
+      if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) return;
+      if (!token || fetchingRef.current) return;
+      fetchingRef.current = true;
+      const msg = { type: "SCROLL", continue: token, limit: pageSizeRef.current };
+      wsRef.current.send(JSON.stringify(msg));
+    }, [contToken]);
+    const drainAll = K.useCallback(
+      async (opts) => {
+        if (!enabledRef.current) return 0;
+        const maxPages = opts?.maxPages ?? 999;
+        const maxItems = opts?.maxItems ?? Number.POSITIVE_INFINITY;
+        let pages = 0;
+        let added = 0;
+        const awaitOnce = () => new Promise((resolve) => {
+          const handler = (ev) => {
+            try {
+              const f = JSON.parse(String(ev.data));
+              if (f.type === "PAGE") {
+                const newCount = (f.items || []).reduce((acc, it) => {
+                  const k = eventKey$1(it);
+                  return state.byKey[k] ? acc : acc + 1;
+                }, 0);
+                added += newCount;
+                const ws2 = wsRef.current;
+                if (!ws2) {
+                  resolve("STOP");
+                  return;
+                }
+                resolve("PAGE");
+              }
+            } catch {
+            }
+          };
+          const ws = wsRef.current;
+          if (!ws) {
+            resolve("STOP");
+            return;
+          }
+          const stopCheck = () => {
+            if (!hasMore || !contToken) {
+              resolve("STOP");
+            }
+          };
+          ws.addEventListener("message", handler, { once: true });
+          setTimeout(stopCheck, 0);
+        });
+        while (pages < maxPages && hasMore && contToken && wsRef.current?.readyState === WebSocket.OPEN) {
+          if (added >= maxItems) break;
+          if (!fetchingRef.current) sendScroll();
+          const r = await awaitOnce();
+          if (r === "STOP") break;
+          pages += 1;
+        }
+        return added;
+      },
+      [contToken, hasMore, sendScroll, state.byKey]
+    );
+    K.useEffect(() => {
+      if (!autoDrain) return;
+      if (!enabledRef.current) return;
+      if (status === "open" && haveAnchorRef.current) {
+        drainAll().catch(() => {
+        });
+      }
+    }, [autoDrain, drainAll, status]);
+    return {
+      state,
+      total,
+      hasMore,
+      continueToken,
+      status,
+      lastError,
+      setPaused: setIsPaused,
+      setIgnoreRemove: setIsRemoveIgnored,
+      sendScroll,
+      drainAll,
+      reconnect,
+      setUrl,
+      setQuery
+    };
+  };
+
+  const buildApiPrefix = (group, version) => {
+    const g = (group ?? "").trim();
+    const v = (version ?? "").trim();
+    const isCore = !g || g === "core" || g === "v1";
+    return isCore ? `/api/${v}` : `/apis/${g}/${v}`;
+  };
+  const buildListUri = ({
+    cluster,
+    group,
+    version,
+    plural,
+    namespace,
+    fieldSelector,
+    labelSelector,
+    limit
+  }) => {
+    const prefix = buildApiPrefix(group, version);
+    const ns = namespace ? `/namespaces/${namespace}` : "";
+    const base = `/api/clusters/${cluster}/k8s${prefix}${ns}/${plural}/`;
+    const params = new URLSearchParams();
+    if (fieldSelector) params.append("fieldSelector", fieldSelector);
+    if (labelSelector) params.append("labelSelector", labelSelector);
+    if (limit) params.append("limit", String(limit));
+    return params.toString() ? `${base}?${params.toString()}` : base;
+  };
+  const useK8sSmartResource = ({
+    cluster,
+    group,
+    version,
+    plural,
+    namespace,
+    fieldSelector,
+    labelSelector,
+    isEnabled = true,
+    listRefetchInterval = 5e3,
+    limit,
+    mapListWatchState
+  }) => {
+    const {
+      canList,
+      canWatch,
+      isLoading: verbsLoading,
+      isError: verbsIsError,
+      error: verbsErrorObj
+    } = useK8sVerbs({
+      cluster,
+      group,
+      version,
+      plural,
+      isEnabled
+    });
+    const listUri = buildListUri({
+      cluster,
+      group,
+      version,
+      plural,
+      namespace,
+      fieldSelector,
+      labelSelector,
+      limit
+    });
+    const restEnabled = Boolean(isEnabled && canList && !canWatch && !verbsLoading && !verbsIsError);
+    const {
+      data: restData,
+      isLoading: restLoading,
+      isError: restIsError,
+      error: restError
+    } = useDirectUnknownResource({
+      uri: listUri,
+      queryKey: [
+        "k8s-list",
+        cluster,
+        group || "",
+        version,
+        namespace || "",
+        plural,
+        fieldSelector || "",
+        labelSelector || ""
+      ],
+      refetchInterval: listRefetchInterval,
+      isEnabled: restEnabled
+    });
+    const watchEnabled = Boolean(isEnabled && canList && canWatch && !verbsLoading && !verbsIsError);
+    const { state, status, lastError } = useListWatch({
+      wsUrl: `/api/clusters/${cluster}/openapi-bff-ws/listThenWatch/listWatchWs`,
+      paused: false,
+      ignoreRemove: false,
+      autoDrain: true,
+      preserveStateOnUrlChange: true,
+      isEnabled: watchEnabled,
+      pageSize: limit,
+      query: {
+        apiGroup: group,
+        apiVersion: version,
+        plural,
+        namespace,
+        fieldSelector,
+        labelSelector
+      }
+    });
+    const defaultMap = (s) => ({ items: s.order.map((k) => s.byKey[k]) });
+    const watchData = K.useMemo(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      () => watchEnabled ? (mapListWatchState ?? defaultMap)(state) : void 0,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [watchEnabled, state, mapListWatchState]
+    );
+    const used = !isEnabled ? "disabled" : verbsLoading ? "verbs-loading" : verbsIsError ? "verbs-error" : watchEnabled ? "watch" : restEnabled ? "list" : "disabled";
+    const isLoading = isEnabled && verbsLoading || used === "watch" && status === "connecting" || used === "list" && restLoading;
+    let error;
+    if (verbsIsError) error = verbsErrorObj;
+    else if (used === "watch" && status === "closed" && lastError) error = lastError;
+    else if (used === "list" && restIsError) error = restError;
+    const isError = Boolean(error);
+    const data = used === "watch" ? watchData : used === "list" ? restData : void 0;
+    return { data, isLoading, isError, error, _meta: { used } };
+  };
+
   const prepareTemplate = ({
     template,
     replaceValues
@@ -8380,7 +9023,7 @@
     replaceValues,
     idToCompare
   }) => {
-    const foundData = data.find((el) => el.id === idToCompare);
+    const foundData = data.find((el) => el?.id === idToCompare);
     if (!foundData) {
       return void 0;
     }
@@ -8479,8 +9122,10 @@
     return /* @__PURE__ */ jsxRuntimeExports.jsx(Styled$v.HeightDiv, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(CollapsibleBreadcrumb, { items: data.breadcrumbItems }) });
   };
   const ManageableBreadcrumbsWithDataProvider = ({
-    uri,
-    refetchInterval,
+    cluster,
+    apiGroup,
+    apiVersion,
+    plural,
     isEnabled,
     replaceValues,
     pathname,
@@ -8490,10 +9135,11 @@
       data: rawData,
       isError: rawDataError,
       isLoading: rawDataLoading
-    } = useDirectUnknownResource({
-      uri,
-      refetchInterval,
-      queryKey: ["breadcrumb", uri],
+    } = useK8sSmartResource({
+      cluster: cluster || "",
+      group: apiGroup,
+      version: apiVersion,
+      plural,
       isEnabled
     });
     if (rawDataError) {
@@ -8681,8 +9327,10 @@
     );
   };
   const ManageableSidebarWithDataProvider = ({
-    uri,
-    refetchInterval,
+    cluster,
+    apiGroup,
+    apiVersion,
+    plural,
     isEnabled,
     replaceValues,
     pathname,
@@ -8695,10 +9343,11 @@
       data: rawData,
       isError: rawDataError,
       isLoading: rawDataLoading
-    } = useDirectUnknownResource({
-      uri,
-      refetchInterval,
-      queryKey: ["sidebar", uri],
+    } = useK8sSmartResource({
+      cluster,
+      group: apiGroup,
+      version: apiVersion,
+      plural,
       isEnabled
     });
     if (rawDataError) {
@@ -49640,22 +50289,6 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
     }
     return `/${baseprefix}/${clusterName}/${namespace}/forms/builtin/${apiVersion}/${typeName}?backlink=${window.location.pathname}`;
   };
-  const getListPath = ({
-    clusterName,
-    namespace,
-    type,
-    typeName,
-    apiGroup,
-    apiVersion
-  }) => {
-    if (type === "crd") {
-      return `/api/clusters/${clusterName}/k8s/apis/${apiGroup}/${apiVersion}${namespace ? `/namespaces/${namespace}` : ""}/${typeName}`;
-    }
-    if (type === "nonCrd") {
-      return `/api/clusters/${clusterName}/k8s/apis/${apiGroup}/${apiVersion}${namespace ? `/namespaces/${namespace}` : ""}/${typeName}`;
-    }
-    return `/api/clusters/${clusterName}/k8s/api/v1${namespace ? `/namespaces/${namespace}` : ""}/${typeName}`;
-  };
 
   const CustomCard$4 = styled(antd.Card)`
   position: relative;
@@ -49788,19 +50421,13 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
       apiVersion,
       baseprefix
     });
-    const listUrl = addedMode && type !== "direct" ? getListPath({
-      clusterName,
+    const { data: k8sList, error: k8sListError } = useK8sSmartResource({
+      cluster: clusterName || "",
       namespace,
-      type,
-      typeName,
-      apiGroup,
-      apiVersion
-    }) : void 0;
-    const { data: k8sList, error: k8sListError } = useDirectUnknownResource({
-      uri: listUrl || "",
-      queryKey: [listUrl || ""],
-      refetchInterval: false,
-      isEnabled: addedMode && listUrl !== void 0
+      group: apiGroup,
+      version: apiVersion || "",
+      plural: type,
+      isEnabled: Boolean(apiVersion && addedMode && type !== "direct")
     });
     if (addedMode && (k8sListError || type === "direct") && !showZeroResources) {
       return null;
@@ -49934,11 +50561,12 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
       data: marketplacePanels,
       isLoading,
       error
-    } = useDirectUnknownResource({
-      uri: `/api/clusters/${clusterName}/k8s/apis/${baseApiGroup}/${baseApiVersion}/${mpResourceName}/`,
-      refetchInterval: 5e3,
-      queryKey: ["marketplacePanels", clusterName || "no-cluster"],
-      isEnabled: clusterName !== void 0
+    } = useK8sSmartResource({
+      cluster: clusterName || "",
+      group: baseApiGroup,
+      version: baseApiVersion,
+      plural: mpResourceName,
+      isEnabled: Boolean(clusterName !== void 0)
     });
     const createPermission = usePermissions({
       group: baseApiGroup,
@@ -50242,22 +50870,26 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
       data: marketplacePanels,
       isLoading: marketplaceIsLoading
       // error: marketplaceError,
-    } = useDirectUnknownResource({
-      uri: `/api/clusters/${clusterName}/k8s/apis/${baseApiGroup}/${baseApiVersion}/${mpResourceName}/`,
-      refetchInterval: 5e3,
-      queryKey: ["marketplacePanels", clusterName || "no-cluster"],
-      isEnabled: clusterName !== void 0
+    } = useK8sSmartResource({
+      cluster: clusterName || "",
+      group: baseApiGroup,
+      version: baseApiVersion,
+      plural: mpResourceName,
+      isEnabled: Boolean(clusterName !== void 0)
     });
     const {
-      data: project,
+      data: projectArr,
       isLoading,
       error
-    } = useDirectUnknownResource({
-      uri: `/api/clusters/${clusterName}/k8s/apis/${baseProjectApiGroup}/${baseProjectVersion}/${projectResourceName}/${namespace}`,
-      refetchInterval: 5e3,
-      queryKey: ["projects", clusterName || "no-cluster"],
-      isEnabled: clusterName !== void 0
+    } = useK8sSmartResource({
+      cluster: clusterName || "",
+      group: baseProjectApiGroup,
+      version: baseProjectVersion,
+      plural: projectResourceName,
+      fieldSelector: `metadata.name=${namespace}`,
+      isEnabled: Boolean(clusterName !== void 0)
     });
+    const project = projectArr && projectArr.length > 0 ? projectArr[0] : void 0;
     const [isDeleteModalOpen, setIsDeleteModalOpen] = K.useState(false);
     const updatePermission = usePermissions({
       group: baseProjectApiGroup,
@@ -52899,6 +53531,19 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
     });
   };
 
+  const useInfiniteSentinel = (sentinelRef, hasMore, onNeedMore) => {
+    K.useEffect(() => {
+      const el = sentinelRef.current;
+      if (!el) return void 0;
+      const io = new IntersectionObserver((entries) => {
+        const visible = entries.some((e) => e.isIntersecting);
+        if (visible && hasMore) onNeedMore();
+      });
+      io.observe(el);
+      return () => io.disconnect();
+    }, [sentinelRef, hasMore, onNeedMore]);
+  };
+
   exports.BackToDefaultIcon = BackToDefaultIcon;
   exports.BlackholeForm = BlackholeForm;
   exports.BlackholeFormDataProvider = BlackholeFormDataProvider;
@@ -53016,6 +53661,10 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
   exports.useCrdResourceSingle = useCrdResourceSingle;
   exports.useCrdResources = useCrdResources;
   exports.useDirectUnknownResource = useDirectUnknownResource;
+  exports.useInfiniteSentinel = useInfiniteSentinel;
+  exports.useK8sSmartResource = useK8sSmartResource;
+  exports.useK8sVerbs = useK8sVerbs;
+  exports.useListWatch = useListWatch;
   exports.usePermissions = usePermissions;
 
   Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });