clerk-solidjs/dist/start/server.js

Clerk for SolidJS

import { ClerkProvider } from '../chunk/3ZJQ455L.js';
import { createComponent, mergeProps, isServer, getRequestEvent } from 'solid-js/web';
import { destructure } from '@solid-primitives/destructure';
import { splitProps, createMemo, onMount, useTransition, createEffect, on } from 'solid-js';
import { useNavigate, useLocation } from '@solidjs/router';
import { isTruthy } from '@clerk/shared/underscore';

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));
      });
    });
  };
};
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 createComponent(ClerkProvider, mergeProps({
    get initialState() {
      return clerkSsrState();
    },
    routerPush: (to) => awaitableNavigate(to, {
      replace: false
    }),
    routerReplace: (to) => awaitableNavigate(to, {
      replace: true
    })
  }, mergedProps, {
    get children() {
      return local.children;
    }
  }));
}

export { ClerkProvider2 as ClerkProvider };