clerk-solidjs/dist/start/server.jsx

Clerk for SolidJS

import {
  ClerkProvider
} from "../chunk/7ARPN5DO.jsx";

// src/start/client/clerk-provider.tsx
import { destructure } from "@solid-primitives/destructure";
import { createMemo, onMount, splitProps } from "solid-js";
import { getRequestEvent, isServer } from "solid-js/web";

// src/start/client/use-awaitable-navigate.ts
import { useLocation, useNavigate } from "@solidjs/router";
import { createEffect, on, useTransition } from "solid-js";
var useAwaitableNavigate = () => {
  const navigate = useNavigate();
  const location = useLocation();
  const resolveFunctionsRef = [];
  const resolveAll = () => {
    resolveFunctionsRef.forEach((resolve) => resolve());
    resolveFunctionsRef.splice(0, resolveFunctionsRef.length);
  };
  const [, startTransition] = useTransition();
  createEffect(
    on(
      () => location,
      () => {
        resolveAll();
      }
    )
  );
  return (to, options) => {
    return new Promise((res) => {
      startTransition(() => {
        resolveFunctionsRef.push(res);
        res(navigate(to, options));
      });
    });
  };
};

// src/start/utils/env.ts
import { isTruthy } from "@clerk/shared/underscore";
var getEnvVariable = (name, defaultVaue = "") => {
  if (typeof process !== "undefined" && process.env && typeof process.env[name] === "string") {
    return process.env[name] || defaultVaue;
  }
  if (typeof import.meta !== "undefined" && // @ts-expect-error - Vite specific
  import.meta.env && // @ts-expect-error - Vite specific
  typeof import.meta.env[name] === "string") {
    return import.meta.env[name];
  }
  return defaultVaue;
};
var getPublicEnvVariables = () => {
  return {
    publishableKey: getEnvVariable("VITE_CLERK_PUBLISHABLE_KEY") || getEnvVariable("CLERK_PUBLISHABLE_KEY"),
    domain: getEnvVariable("VITE_CLERK_DOMAIN") || getEnvVariable("CLERK_DOMAIN"),
    isSatellite: isTruthy(getEnvVariable("VITE_CLERK_IS_SATELLITE")) || isTruthy(getEnvVariable("CLERK_IS_SATELLITE")),
    proxyUrl: getEnvVariable("VITE_CLERK_PROXY_URL") || getEnvVariable("CLERK_PROXY_URL"),
    pk: getEnvVariable("VITE_CLERK_PUBLISHABLE_KEY") || getEnvVariable("CLERK_PUBLISHABLE_KEY"),
    signInUrl: getEnvVariable("VITE_CLERK_SIGN_IN_URL") || getEnvVariable("CLERK_SIGN_IN_URL"),
    signUpUrl: getEnvVariable("VITE_CLERK_SIGN_UP_URL") || getEnvVariable("CLERK_SIGN_UP_URL"),
    clerkJsUrl: getEnvVariable("VITE_CLERK_JS_URL") || getEnvVariable("CLERK_JS"),
    clerkJsVariant: getEnvVariable("VITE_CLERK_JS_VARIANT") || getEnvVariable("CLERK_JS_VARIANT"),
    clerkJsVersion: getEnvVariable("VITE_CLERK_JS_VERSION") || getEnvVariable("CLERK_JS_VERSION"),
    telemetryDisabled: isTruthy(getEnvVariable("VITE_CLERK_TELEMETRY_DISABLED")) || isTruthy(getEnvVariable("CLERK_TELEMETRY_DISABLED")),
    telemetryDebug: isTruthy(getEnvVariable("VITE_CLERK_TELEMETRY_DEBUG")) || isTruthy(getEnvVariable("CLERK_TELEMETRY_DEBUG")),
    afterSignInUrl: getEnvVariable("VITE_CLERK_AFTER_SIGN_IN_URL") || getEnvVariable("CLERK_AFTER_SIGN_IN_URL"),
    afterSignUpUrl: getEnvVariable("VITE_CLERK_AFTER_SIGN_UP_URL") || getEnvVariable("CLERK_AFTER_SIGN_UP_URL")
  };
};

// src/start/client/utils.ts
var pickFromClerkInitState = (clerkInitState) => {
  const {
    __clerk_ssr_state,
    __publishableKey,
    __proxyUrl,
    __domain,
    __isSatellite,
    __signInUrl,
    __signUpUrl,
    __afterSignInUrl,
    __afterSignUpUrl,
    __clerkJSUrl,
    __clerkJSVersion,
    __telemetryDisabled,
    __telemetryDebug,
    __signInForceRedirectUrl,
    __signUpForceRedirectUrl,
    __signInFallbackRedirectUrl,
    __signUpFallbackRedirectUrl
  } = clerkInitState || {};
  return {
    clerkSsrState: __clerk_ssr_state,
    publishableKey: __publishableKey,
    proxyUrl: __proxyUrl,
    domain: __domain,
    isSatellite: !!__isSatellite,
    signInUrl: __signInUrl,
    signUpUrl: __signUpUrl,
    afterSignInUrl: __afterSignInUrl,
    afterSignUpUrl: __afterSignUpUrl,
    clerkJSUrl: __clerkJSUrl,
    clerkJSVersion: __clerkJSVersion,
    telemetry: {
      disabled: __telemetryDisabled,
      debug: __telemetryDebug
    },
    signInForceRedirectUrl: __signInForceRedirectUrl,
    signUpForceRedirectUrl: __signUpForceRedirectUrl,
    signInFallbackRedirectUrl: __signInFallbackRedirectUrl,
    signUpFallbackRedirectUrl: __signUpFallbackRedirectUrl
  };
};
var mergeWithPublicEnvs = (restInitState) => {
  const publicEnvVariables = getPublicEnvVariables();
  return {
    ...restInitState,
    publishableKey: restInitState.publishableKey || publicEnvVariables.publishableKey,
    domain: restInitState.domain || publicEnvVariables.domain,
    isSatellite: restInitState.isSatellite || publicEnvVariables.isSatellite,
    signInUrl: restInitState.signInUrl || publicEnvVariables.signInUrl,
    signUpUrl: restInitState.signUpUrl || publicEnvVariables.signUpUrl,
    afterSignInUrl: restInitState.afterSignInUrl || publicEnvVariables.afterSignInUrl,
    afterSignUpUrl: restInitState.afterSignUpUrl || publicEnvVariables.afterSignUpUrl,
    clerkJSUrl: restInitState.clerkJSUrl || publicEnvVariables.clerkJsUrl,
    clerkJSVersion: restInitState.clerkJSVersion || publicEnvVariables.clerkJsVersion,
    signInForceRedirectUrl: restInitState.signInForceRedirectUrl,
    clerkJSVariant: restInitState.clerkJSVariant || publicEnvVariables.clerkJsVariant
  };
};

// src/start/client/clerk-provider.tsx
function ClerkProvider2(props) {
  const [local, providerProps] = splitProps(props, ["children"]);
  const awaitableNavigate = useAwaitableNavigate();
  const clerkInitState = () => isServer ? getRequestEvent()?.locals.clerkInitialState : window.__clerk_init_state;
  const states = createMemo(
    () => pickFromClerkInitState(clerkInitState()?.__internal_clerk_state)
  );
  const { clerkSsrState } = destructure(states);
  const mergedProps = () => ({
    ...mergeWithPublicEnvs(states()),
    ...providerProps
  });
  onMount(() => {
    window.__clerk_init_state = clerkInitState();
  });
  return <ClerkProvider
    initialState={clerkSsrState()}
    routerPush={(to) => awaitableNavigate(to, {
      replace: false
    })}
    routerReplace={(to) => awaitableNavigate(to, {
      replace: true
    })}
    {...mergedProps()}
  >
      {local.children}
    </ClerkProvider>;
}
export {
  ClerkProvider2 as ClerkProvider
};