@rpcbase/client 0.283.0 → 0.285.0

package/dist/RootProvider/index.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+type RootProviderProps = {
+    children: ReactNode;
+};
+export declare const RootProvider: ({ children }: RootProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/RootProvider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../pkg/client/src/RootProvider/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAOjC,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,cAAY,iBAAiB,4CAQzD,CAAA"}

package/dist/RootProvider/index.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import posthog from "posthog-js";
+import { PostHogProvider } from "posthog-js/react";
+import { useApplyScroll } from "../utils/useApplyScroll";
+export const RootProvider = ({ children }) => {
+    useApplyScroll();
+    return (_jsx(PostHogProvider, { client: posthog, children: children }));
+};

package/dist/apiClient/getServerApiClient.d.ts

@@ -0,0 +1,10 @@
+import { Application } from "express";
+type Ctx = any;
+export declare const getServerApiClient: (app: Application) => Promise<{
+    get: <TResponse = Record<string, unknown>>(path: string, payload: Record<string, unknown>, ctx?: Ctx) => Promise<TResponse>;
+    post: <TResponse = Record<string, unknown>>(path: string, payload: Record<string, unknown>, ctx?: Ctx) => Promise<TResponse>;
+    put: <TResponse = Record<string, unknown>>(path: string, payload: Record<string, unknown>, ctx?: Ctx) => Promise<TResponse>;
+    delete: <TResponse = Record<string, unknown>>(path: string, payload: Record<string, unknown>, ctx?: Ctx) => Promise<TResponse>;
+}>;
+export default getServerApiClient;
+//# sourceMappingURL=getServerApiClient.d.ts.map

package/dist/apiClient/getServerApiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getServerApiClient.d.ts","sourceRoot":"","sources":["../../../../../pkg/client/src/apiClient/getServerApiClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAA8B,MAAM,SAAS,CAAA;AAGjE,KAAK,GAAG,GAAG,GAAG,CAAA;AAGd,eAAO,MAAM,kBAAkB,GAAS,KAAK,WAAW;UAqGtC,SAAS,kCACf,MAAM,WACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAC1B,GAAG,KACR,OAAO,CAAC,SAAS,CAAC;WAJP,SAAS,kCACf,MAAM,WACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAC1B,GAAG,KACR,OAAO,CAAC,SAAS,CAAC;UAJP,SAAS,kCACf,MAAM,WACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAC1B,GAAG,KACR,OAAO,CAAC,SAAS,CAAC;aAJP,SAAS,kCACf,MAAM,WACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAC1B,GAAG,KACR,OAAO,CAAC,SAAS,CAAC;EAkBxB,CAAA;AAED,eAAe,kBAAkB,CAAA"}

package/dist/apiClient/getServerApiClient.js

@@ -0,0 +1,97 @@
+export const getServerApiClient = async (app) => {
+    const callRoute = async (app, 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 = app.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) {
+                    // console.log("not machthing route:", path, "to layer:", index, layer.name, layer, "reason: ", {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()]) {
+                        // console.log("not machthing route:", path, "to route layer:", index, layer.name, layer, "reason: method not matching")
+                        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);
+                }
+            };
+            // AWAIT ??
+            processLayer(0);
+            // Set a timeout to prevent hanging
+            setTimeout(() => {
+                if (!isEnded) {
+                    reject("Route handler timed out");
+                }
+            }, 30000);
+        });
+    };
+    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 default getServerApiClient;

package/dist/apiClient/index.d.ts

@@ -0,0 +1,16 @@
+import type { Application } from "express";
+type Ctx = any;
+type ServerArgs = {
+    app: Application;
+};
+type PayloadNotCtx = Record<string, unknown> & {
+    [P in keyof Ctx]?: never;
+};
+type ApiClientMethod = <TResponse = Record<string, unknown>>(path: string, payload: PayloadNotCtx, ctx?: Ctx) => Promise<TResponse>;
+export type HttpMethod = "get" | "put" | "post" | "delete";
+type MethodRecord<T> = Record<HttpMethod, T>;
+export type ApiClient = MethodRecord<ApiClientMethod>;
+declare let apiClient: ApiClient;
+export declare const initApiClient: (args?: ServerArgs) => Promise<void>;
+export { apiClient };
+//# sourceMappingURL=index.d.ts.map

package/dist/apiClient/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../pkg/client/src/apiClient/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAG1C,KAAK,GAAG,GAAG,GAAG,CAAA;AAGd,KAAK,UAAU,GAAG;IAChB,GAAG,EAAE,WAAW,CAAC;CAClB,CAAC;AAEF,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;KAC5C,CAAC,IAAI,MAAM,GAAG,CAAC,CAAC,EAAE,KAAK;CACzB,CAAC;AAEF,KAAK,eAAe,GAAG,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,aAAa,EACtB,GAAG,CAAC,EAAE,GAAG,KACN,OAAO,CAAC,SAAS,CAAC,CAAC;AAExB,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;AAC3D,KAAK,YAAY,CAAC,CAAC,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AAE7C,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC,eAAe,CAAC,CAAC;AAEtD,QAAA,IAAI,SAAS,EAAE,SAAS,CAAA;AAExB,eAAO,MAAM,aAAa,GAAU,OAAO,UAAU,kBAuDpD,CAAA;AAED,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/dist/apiClient/index.js

@@ -0,0 +1,50 @@
+let apiClient;
+export const initApiClient = async (args) => {
+    if (import.meta.env.SSR) {
+        if (!args) {
+            throw new Error("Server args must be provided in SSR mode");
+        }
+        const { getServerApiClient } = await import("./getServerApiClient");
+        apiClient = await getServerApiClient(args.app);
+    }
+    else {
+        const axios = (await import("axios")).default;
+        const axiosClient = axios.create({
+            baseURL: "/",
+            withCredentials: true,
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        const createMethod = (method) => {
+            return async (path, payload, _ctx) => {
+                const config = {
+                    method,
+                    url: path,
+                    data: payload,
+                    headers: {
+                    // ...(typeof ctxOrPath !== 'string' && {
+                    //   // 'X-Custom-Header': ctxOrPath.someHeaderValue,
+                    //   // ...ctxOrPath.additionalHeaders,
+                    // }),
+                    },
+                };
+                try {
+                    const response = await axiosClient(config);
+                    return response.data;
+                }
+                catch (error) {
+                    console.log("AXIOS API ERROR", error);
+                    throw error;
+                }
+            };
+        };
+        apiClient = {
+            get: createMethod("get"),
+            put: createMethod("put"),
+            post: createMethod("post"),
+            delete: createMethod("delete"),
+        };
+    }
+};
+export { apiClient };

package/dist/cleanupURL.d.ts

@@ -0,0 +1,2 @@
+export declare const cleanupURL: () => void;
+//# sourceMappingURL=cleanupURL.d.ts.map

package/dist/cleanupURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanupURL.d.ts","sourceRoot":"","sources":["../../../../pkg/client/src/cleanupURL.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,YA0CtB,CAAA"}

package/dist/cleanupURL.js

@@ -0,0 +1,37 @@
+const CLEANUP_WAIT_DELAY = 1000;
+// Function to clean UTM params while preserving others
+export const cleanupURL = () => {
+    if (import.meta.env.SSR) {
+        return;
+    }
+    const runCleanup = () => {
+        // Add a small delay before running cleanupURL
+        setTimeout(() => {
+            const url = new URL(window.location.href);
+            const params = new URLSearchParams(url.search);
+            // Get all current query parameter keys
+            const paramKeys = Array.from(params.keys());
+            // Remove any parameter starting with 'utm_'
+            paramKeys.forEach((key) => {
+                if (key.startsWith("utm_")) {
+                    params.delete(key);
+                }
+            });
+            // Build the new URL: keep pathname and append remaining query params (if any)
+            const cleanUrl = url.pathname +
+                (params.toString() ? "?" + params.toString() : "") +
+                url.hash;
+            // Update the browser URL without reloading
+            window.history.replaceState({}, document.title, cleanUrl);
+        }, CLEANUP_WAIT_DELAY);
+    };
+    // If DOM is already loaded, schedule the cleanup
+    if (document.readyState === "complete" ||
+        document.readyState === "interactive") {
+        runCleanup();
+    }
+    else {
+        // Otherwise wait for the DOM content to be loaded
+        document.addEventListener("DOMContentLoaded", runCleanup, { once: true });
+    }
+};

package/dist/getFeatureFlag.d.ts

@@ -0,0 +1,2 @@
+export declare const getFeatureFlag: (flag: string) => Promise<boolean | string | undefined>;
+//# sourceMappingURL=getFeatureFlag.d.ts.map

package/dist/getFeatureFlag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFeatureFlag.d.ts","sourceRoot":"","sources":["../../../../pkg/client/src/getFeatureFlag.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,KACX,OAAO,CAAC,OAAO,GAAG,MAAM,GAAG,SAAS,CAoDtC,CAAA"}

package/dist/getFeatureFlag.js

@@ -0,0 +1,43 @@
+import _snakeCase from "lodash/snakeCase";
+export const getFeatureFlag = async (flag) => {
+    const envKey = `RB_PUBLIC_FLAG_${_snakeCase(flag).toUpperCase()}`;
+    if (import.meta.env.SSR) {
+        if (process.env[envKey] !== undefined) {
+            return process.env[envKey];
+        }
+        const startTime = performance.now();
+        const { PostHog } = await import("posthog-node");
+        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 {
+        if (import.meta.env[envKey] !== undefined) {
+            return import.meta.env[envKey];
+        }
+        const startTime = performance.now();
+        const { posthog } = await import("posthog-js");
+        let hasLoadedFeatureFlags = false;
+        function waitForFeatureFlags() {
+            return new Promise((resolve) => {
+                if (hasLoadedFeatureFlags) {
+                    resolve();
+                }
+                else {
+                    posthog.onFeatureFlags(() => {
+                        hasLoadedFeatureFlags = true;
+                        resolve();
+                    });
+                }
+            });
+        }
+        await waitForFeatureFlags();
+        const endTime = performance.now();
+        console.log(`Client: Feature flag "${flag}" loaded in ${(endTime - startTime).toFixed(2)}ms`);
+        return posthog.getFeatureFlag(flag);
+    }
+};

package/dist/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./useThrottledMeasure";
+export * from "./useMediaQuery";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../pkg/client/src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,2 @@
+export * from "./useThrottledMeasure";
+export * from "./useMediaQuery";

package/dist/hooks/useMediaQuery.d.ts

@@ -0,0 +1,2 @@
+export declare const useMediaQuery: (query: string) => boolean;
+//# sourceMappingURL=useMediaQuery.d.ts.map

package/dist/hooks/useMediaQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaQuery.d.ts","sourceRoot":"","sources":["../../../../../pkg/client/src/hooks/useMediaQuery.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,OAyB7C,CAAA"}

package/dist/hooks/useMediaQuery.js

@@ -0,0 +1,24 @@
+import { useSyncExternalStore } from "react";
+const emptyUnsubscribe = () => { };
+export const useMediaQuery = (query) => {
+    const isServer = typeof window === "undefined";
+    const subscribe = (callback) => {
+        if (isServer)
+            return emptyUnsubscribe;
+        const mql = window.matchMedia(query);
+        // Modern browsers
+        if (mql.addEventListener) {
+            mql.addEventListener("change", callback);
+            return () => mql.removeEventListener("change", callback);
+        }
+        // Legacy fallback
+        mql.addListener(callback);
+        return () => mql.removeListener(callback);
+    };
+    const getSnapshot = () => {
+        if (isServer)
+            return false;
+        return window.matchMedia(query).matches;
+    };
+    return useSyncExternalStore(subscribe, getSnapshot, () => false);
+};

package/dist/hooks/useThrottledMeasure.d.ts

@@ -0,0 +1,11 @@
+export declare const useThrottledMeasure: (throttleDuration?: number) => (import("react-use/lib/useMeasure").UseMeasureRef<Element> | {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+})[];
+//# sourceMappingURL=useThrottledMeasure.d.ts.map

package/dist/hooks/useThrottledMeasure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useThrottledMeasure.d.ts","sourceRoot":"","sources":["../../../../../pkg/client/src/hooks/useThrottledMeasure.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB,GAAI,yBAAwC;;;;;;;;;IAsC3E,CAAA"}

package/dist/hooks/useThrottledMeasure.js

@@ -0,0 +1,32 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+import useMeasure from "react-use/lib/useMeasure";
+import _throttle from "lodash/throttle";
+import { deepEqual } from "fast-equals";
+const useMeasureHook = useMeasure.default ?? useMeasure;
+const DEFAULT_THROTTLE_TIME = 16;
+export const useThrottledMeasure = (throttleDuration = DEFAULT_THROTTLE_TIME) => {
+    const hasInitialMeasure = useRef(false);
+    const [ref, measuredRect] = useMeasureHook();
+    const [rect, setRect] = useState(() => {
+        return { x: 0, y: 0, width: 0, height: 0, top: 0, left: 0, bottom: 0, right: 0 };
+    });
+    const throttledSetRect = useCallback(_throttle((newRect) => {
+        setRect((current) => {
+            return deepEqual(current, newRect) ? current : newRect;
+        });
+    }, throttleDuration, { leading: true, trailing: true }), [throttleDuration]);
+    useEffect(() => {
+        if (measuredRect.width > 0 && !hasInitialMeasure.current) {
+            hasInitialMeasure.current = true;
+            setRect((current) => {
+                return deepEqual(current, measuredRect) ? current : measuredRect;
+            });
+            return;
+        }
+        throttledSetRect(measuredRect);
+        return () => {
+            throttledSetRect.cancel();
+        };
+    }, [measuredRect, throttledSetRect]);
+    return [ref, rect];
+};

package/dist/hooks.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/hooks";
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../pkg/client/hooks.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/hooks.js

@@ -0,0 +1 @@
+export * from "./src/hooks";

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./apiClient";
+export * from "./initWithRoutes";
+export * from "./types";
+export * from "./getFeatureFlag";
+export * from "./RootProvider";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../pkg/client/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,SAAS,CAAA;AACvB,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./apiClient";
+export * from "./initWithRoutes";
+export * from "./types";
+export * from "./getFeatureFlag";
+export * from "./RootProvider";

package/dist/initWithRoutes.d.ts

@@ -0,0 +1,8 @@
+import { createRoutesFromElements } from "@rpcbase/router";
+type InitWithRoutesOptions = {
+    devThrowsOnHydrationErrors?: boolean;
+};
+type RoutesElement = Parameters<typeof createRoutesFromElements>[0];
+export declare const initWithRoutes: (routesElement: RoutesElement, opts?: InitWithRoutesOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=initWithRoutes.d.ts.map

package/dist/initWithRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initWithRoutes.d.ts","sourceRoot":"","sources":["../../../../pkg/client/src/initWithRoutes.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAsB,wBAAwB,EAAiB,MAAM,iBAAiB,CAAA;AAqC7F,KAAK,qBAAqB,GAAG;IAC3B,0BAA0B,CAAC,EAAE,OAAO,CAAA;CACrC,CAAA;AAED,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,CAAA;AAEnE,eAAO,MAAM,cAAc,GACzB,eAAe,aAAa,EAC5B,OAAO,qBAAqB,kBA0E7B,CAAA"}

package/dist/initWithRoutes.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { StrictMode } from "react";
+import posthog from "posthog-js";
+import { createBrowserRouter, createRoutesFromElements, RouterProvider } from "@rpcbase/router";
+import { hydrateRoot } from "react-dom/client";
+import { initApiClient } from "./apiClient";
+import { cleanupURL } from "./cleanupURL";
+const isProduction = import.meta.env.MODE === "production";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const showErrorOverlay = (err) => {
+    const ErrorOverlay = customElements.get("vite-error-overlay");
+    // don't open outside vite environment
+    if (!ErrorOverlay) {
+        return;
+    }
+    console.log(err);
+    const overlay = new ErrorOverlay(err);
+    document.body.appendChild(overlay);
+};
+const handleServerErrors = () => {
+    if (window.__staticRouterHydrationData?.errors) {
+        const { errors } = window.__staticRouterHydrationData;
+        Object.values(errors).forEach((error) => {
+            showErrorOverlay({
+                plugin: "ssr-router",
+                ...error.reason
+            });
+        });
+    }
+};
+export const initWithRoutes = async (routesElement, opts) => {
+    await initApiClient();
+    cleanupURL();
+    handleServerErrors();
+    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);
+        // send as exception (counts toward error tracking)
+        posthog.captureException(err, {
+            react_context,
+            component_stack: errorInfo?.componentStack
+        });
+        if (react_context === "uncaught") {
+            console.warn("Uncaught error", err, errorInfo?.componentStack);
+        }
+    };
+    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;
+            }
+            // For non-hydration recoverable errors in dev, keep a visible signal.
+            console.error(err, errorInfo?.componentStack);
+        }
+    } : undefined);
+    hydrateRoot(document.getElementById("root"), _jsx(StrictMode, { children: _jsx(RouterProvider, { router: router }) }), hydrationOptions);
+};

package/dist/instrument.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=instrument.d.ts.map

package/dist/instrument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument.d.ts","sourceRoot":"","sources":["../../../pkg/client/instrument.ts"],"names":[],"mappings":""}

package/dist/instrument.js

@@ -0,0 +1,29 @@
+import posthog from "posthog-js";
+const isProduction = import.meta.env.MODE === "production";
+const posthogKey = import.meta.env.RB_PUBLIC_POSTHOG_KEY;
+if (isProduction) {
+    if (typeof posthogKey === "string" && posthogKey.length > 0) {
+        posthog.init(posthogKey, {
+            api_host: "/ingest",
+            ui_host: "https://eu.posthog.com",
+            person_profiles: "always",
+            session_recording: {
+                maskAllInputs: false
+            },
+            capture_pageview: isProduction,
+            capture_exceptions: {
+                capture_unhandled_errors: true,
+                capture_unhandled_rejections: true,
+                capture_console_errors: true,
+            },
+            autocapture: isProduction,
+            disable_session_recording: !isProduction,
+        });
+    }
+    else {
+        console.warn("missing POSTHOG_KEY");
+    }
+}
+else {
+    console.info("ℹ️ Not initializing posthog in development");
+}

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+import { Ctx } from "@rpcbase/api";
+import { Params } from "@rpcbase/router";
+export type LoaderArgs = {
+    params: Params;
+    ctx: Ctx;
+};
+export type Loader = ({ params, ctx }: LoaderArgs) => Promise<any>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../pkg/client/src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAGxC,MAAM,MAAM,UAAU,GAAG;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,GAAG,CAAA;CAAC,CAAA;AAGnD,MAAM,MAAM,MAAM,GAAG,CAAC,EAAC,MAAM,EAAE,GAAG,EAAC,EAAE,UAAU,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/useApplyScroll.d.ts

@@ -0,0 +1,2 @@
+export declare function useApplyScroll(): void;
+//# sourceMappingURL=useApplyScroll.d.ts.map

package/dist/utils/useApplyScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApplyScroll.d.ts","sourceRoot":"","sources":["../../../../../pkg/client/src/utils/useApplyScroll.ts"],"names":[],"mappings":"AAiBA,wBAAgB,cAAc,SAuJ7B"}