@rpcbase/client 0.288.0 → 0.289.0

package/dist/getServerApiClient-CHA4nyjq.js

@@ -0,0 +1,94 @@
+const getServerApiClient = async (app) => {
+  const callRoute = async (app2, method, path, req, res) => {
+    return new Promise((resolve, reject) => {
+      let isEnded = false;
+      const mockReq = {
+        ...req,
+        method: method.toUpperCase(),
+        url: path
+      };
+      const mockRes = {
+        ...res,
+        json: (data) => {
+          if (!isEnded) {
+            isEnded = true;
+            resolve(data);
+          }
+        },
+        status: (statusCode) => {
+          console.log("Status:", statusCode);
+          return mockRes;
+        }
+      };
+      const routerStack = app2.router.stack;
+      const firstApiMiddlewareIndex = routerStack.findIndex((layer) => layer.name === "__FIRST_API_MIDDLEWARE__");
+      if (!(firstApiMiddlewareIndex > -1)) {
+        throw new Error("middleware: __FIRST_API_MIDDLEWARE__ was not found in stack");
+      }
+      const apiStack = routerStack.slice(firstApiMiddlewareIndex + 1);
+      const processLayer = async (index) => {
+        if (index >= apiStack.length || isEnded) return;
+        const layer = apiStack[index];
+        const isNonMatchingLayer = !layer.match(path);
+        if (isNonMatchingLayer) {
+          await processLayer(index + 1);
+          return;
+        }
+        const runHandler = async (handler) => new Promise((resolveMiddleware, rejectMiddleware) => {
+          handler(mockReq, mockRes, (err) => {
+            if (err) {
+              console.error("Middleware error:", err);
+              if (!isEnded) {
+                isEnded = true;
+                rejectMiddleware(err);
+              }
+              return;
+            }
+            resolveMiddleware();
+          });
+        });
+        if (layer.route) {
+          if (!layer.route.methods[method.toLowerCase()]) {
+            await processLayer(index + 1);
+            return;
+          }
+          if (layer.route.stack.length !== 1) {
+            throw new Error(`expected only one handler per route for route: ${layer.route.path}`);
+          }
+          await runHandler(layer.route.stack[0].handle);
+        } else {
+          await runHandler(layer.handle);
+        }
+        if (!isEnded) {
+          await processLayer(index + 1);
+        }
+      };
+      processLayer(0);
+      setTimeout(() => {
+        if (!isEnded) {
+          reject("Route handler timed out");
+        }
+      }, 3e4);
+    });
+  };
+  const createMethod = (method) => {
+    return async (path, payload, ctx) => {
+      if (!ctx) {
+        throw new Error("Context must be provided in SSR mode");
+      }
+      ctx.req.body = payload;
+      return callRoute(app, method, path, ctx.req, ctx.res);
+    };
+  };
+  const apiClient = {
+    get: createMethod("get"),
+    post: createMethod("post"),
+    put: createMethod("put"),
+    delete: createMethod("delete")
+  };
+  return apiClient;
+};
+export {
+  getServerApiClient as default,
+  getServerApiClient
+};

package/dist/hooks/useThrottledMeasure.d.ts

@@ -1,4 +1,4 @@
-export declare const useThrottledMeasure: (throttleDuration?: number) => (import('react-use/lib/useMeasure.js').UseMeasureRef<Element> | {
+export declare const useThrottledMeasure: (throttleDuration?: number) => (import('react-use/esm/useMeasure.js').UseMeasureRef<Element> | {
     x: number;
     y: number;
     width: number;

package/dist/index.js

@@ -4,10 +4,16 @@ import posthog from "posthog-js";
 import { createRoutesFromElements, createBrowserRouter, RouterProvider, useLocation } from "@rpcbase/router";
 import { hydrateRoot } from "react-dom/client";
 import { PostHogProvider } from "posthog-js/react/dist/esm/index.js";
-import useMeasure from "react-use/lib/useMeasure.js";
+import useMeasure from "react-use/esm/useMeasure.js";
 let apiClient;
 const initApiClient = async (args) => {
-  {
+  if (globalThis.__rb_env__.SSR) {
+    if (!args) {
+      throw new Error("Server args must be provided in SSR mode");
+    }
+    const { getServerApiClient } = await import("./getServerApiClient-CHA4nyjq.js");
+    apiClient = await getServerApiClient(args.app);
+  } else {
     const axios = (await import("axios")).default;
     const axiosClient = axios.create({
       baseURL: "/",
@@ -48,6 +54,9 @@ const initApiClient = async (args) => {
 };
 const CLEANUP_WAIT_DELAY = 1e3;
 const cleanupURL = () => {
+  if (globalThis.__rb_env__.SSR) {
+    return;
+  }
   const runCleanup = () => {
     setTimeout(() => {
       const url = new URL(window.location.href);
@@ -68,6 +77,7 @@ const cleanupURL = () => {
     document.addEventListener("DOMContentLoaded", runCleanup, { once: true });
   }
 };
+const isProduction = globalThis.__rb_env__.MODE === "production";
 const showErrorOverlay = (err) => {
   const ErrorOverlay = customElements.get("vite-error-overlay");
   if (!ErrorOverlay) {
@@ -95,6 +105,20 @@ const initWithRoutes = async (routesElement, opts) => {
   const routes = createRoutesFromElements(routesElement);
   const router = createBrowserRouter(routes);
   const toError = (error) => error instanceof Error ? error : new Error(String(error));
+  const mentionsHydration = (value, depth = 0) => {
+    if (depth > 5) {
+      return false;
+    }
+    if (typeof value === "string") {
+      return value.toLowerCase().includes("hydrat");
+    }
+    if (value instanceof Error) {
+      const digest = value.digest;
+      const cause = value.cause;
+      return mentionsHydration(value.message, depth + 1) || mentionsHydration(digest, depth + 1) || mentionsHydration(cause, depth + 1);
+    }
+    return false;
+  };
   const phReactHandler = (react_context) => (error, errorInfo) => {
     const err = toError(error);
     posthog.captureException(err, {
@@ -105,11 +129,19 @@ const initWithRoutes = async (routesElement, opts) => {
       console.warn("Uncaught error", err, errorInfo?.componentStack);
     }
   };
-  const hydrationOptions = {
+  const hydrationOptions = isProduction ? {
     onUncaughtError: phReactHandler("uncaught"),
     onCaughtError: phReactHandler("caught"),
     onRecoverableError: phReactHandler("recoverable")
-  };
+  } : opts?.devThrowsOnHydrationErrors ? {
+    onRecoverableError(error, errorInfo) {
+      const err = toError(error);
+      if (mentionsHydration(err) || mentionsHydration(errorInfo?.componentStack)) {
+        throw err;
+      }
+      console.error(err, errorInfo?.componentStack);
+    }
+  } : void 0;
   hydrateRoot(
     document.getElementById("root"),
     /* @__PURE__ */ jsx(StrictMode, { children: /* @__PURE__ */ jsx(RouterProvider, { router }) }),
@@ -643,7 +675,23 @@ const _snakeCase = /* @__PURE__ */ getDefaultExportFromCjs(snakeCaseExports);
 const __vite_import_meta_env__ = { "BASE_URL": "/", "DEV": false, "MODE": "production", "PROD": true, "SSR": false };
 const getFeatureFlag = async (flag) => {
   const envKey = `RB_PUBLIC_FLAG_${_snakeCase(flag).toUpperCase()}`;
-  {
+  if (globalThis.__rb_env__.SSR) {
+    if (process.env[envKey] !== void 0) {
+      return process.env[envKey];
+    }
+    const startTime = performance.now();
+    const { PostHog } = await import("./index.node-f83KBCsj.js");
+    const client = new PostHog(
+      process.env.RB_PUBLIC_POSTHOG_KEY,
+      { host: "https://eu.i.posthog.com" }
+    );
+    const distinctId = "server";
+    console.log("TODO: NYI server side feature flags client distinctId");
+    const value = await client.getFeatureFlag(flag, distinctId);
+    const endTime = performance.now();
+    console.log(`SSR: Feature flag "${flag}" loaded in ${(endTime - startTime).toFixed(2)}ms`);
+    return value;
+  } else {
     let waitForFeatureFlags = function() {
       return new Promise((resolve) => {
         if (hasLoadedFeatureFlags) {