@terreno/rtk 0.14.0 → 0.14.2

package/src/useFeatureFlags.ts

@@ -1,7 +1,49 @@
 import type {Api} from "@reduxjs/toolkit/query/react";
-import {useCallback, useEffect, useMemo, useRef} from "react";
+import {useCallback, useEffect, useRef} from "react";
 
-type FlagValues = Record<string, boolean | string | null>;
+interface FlagValues {
+  [key: string]: boolean | string | null;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: RTK Query API generic typing is intentionally flexible here.
+type FlagsApi = Api<any, any, any, any>;
+
+// biome-ignore lint/suspicious/noExplicitAny: Endpoint hook is injected dynamically by RTK Query.
+type EnhancedFlagsApi = FlagsApi & {useEvaluateFeatureFlagsQuery: any};
+
+/**
+ * Cache the enhanced api per (api, basePath). `injectEndpoints` logs a console
+ * error in development whenever an endpoint with the same name is re-injected
+ * with `overrideExisting: false`, so calling it on every render of every
+ * consumer would flood the console. WeakMap-by-api lets the GC reclaim entries
+ * when the api object is unreachable.
+ */
+const enhancedApiCache = new WeakMap<FlagsApi, Map<string, EnhancedFlagsApi>>();
+
+const getEnhancedApi = (api: FlagsApi, basePath: string): EnhancedFlagsApi => {
+  let byBase = enhancedApiCache.get(api);
+  if (!byBase) {
+    byBase = new Map();
+    enhancedApiCache.set(api, byBase);
+  }
+  const cached = byBase.get(basePath);
+  if (cached) {
+    return cached;
+  }
+  const enhanced = api.injectEndpoints({
+    endpoints: (builder) => ({
+      evaluateFeatureFlags: builder.query<FlagValues, void>({
+        query: () => ({
+          method: "GET",
+          url: `${basePath}/evaluate`,
+        }),
+      }),
+    }),
+    overrideExisting: false,
+  }) as EnhancedFlagsApi;
+  byBase.set(basePath, enhanced);
+  return enhanced;
+};
 
 interface UseFeatureFlagsResult {
   flags: FlagValues;
@@ -65,30 +107,13 @@ export const resolveFeatureFlagsOptions = (
 // Overloaded signature preserves backwards compatibility with callers that
 // pass a string basePath as the second argument.
 export function useFeatureFlags(
-  // biome-ignore lint/suspicious/noExplicitAny: RTK Query API generic typing is intentionally flexible here.
-  api: Api<any, any, any, any>,
+  api: FlagsApi,
   basePathOrOptions?: string | UseFeatureFlagsOptions
 ): UseFeatureFlagsResult {
   const {basePath, skip} = resolveFeatureFlagsOptions(basePathOrOptions);
 
-  const enhancedApi = useMemo(
-    () =>
-      api.injectEndpoints({
-        endpoints: (builder) => ({
-          evaluateFeatureFlags: builder.query<FlagValues, void>({
-            query: () => ({
-              method: "GET",
-              url: `${basePath}/evaluate`,
-            }),
-          }),
-        }),
-        overrideExisting: false,
-      }),
-    [api, basePath]
-  );
-
-  // biome-ignore lint/suspicious/noExplicitAny: Endpoint hook is injected dynamically by RTK Query.
-  const useEvaluateQuery = (enhancedApi as any).useEvaluateFeatureFlagsQuery;
+  const enhancedApi = getEnhancedApi(api, basePath);
+  const useEvaluateQuery = enhancedApi.useEvaluateFeatureFlagsQuery;
   const {data, isLoading, error, refetch} = useEvaluateQuery(undefined, {skip});
   const evaluateStartedAtRef = useRef<number | null>(null);
 

package/src/useServerStatus.ts

@@ -96,7 +96,7 @@ export const useServerStatus = (options: ServerStatusOptions = {}): ServerStatus
 
   // Also respond to browser online/offline events for instant detection
   useEffect(() => {
-    if (skip || typeof window === "undefined") {
+    if (skip || typeof window === "undefined" || typeof window.addEventListener !== "function") {
       return;
     }