@rpcbase/client 0.287.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;