@clerk/chrome-extension
Version:
Clerk SDK for Chrome extensions
4,986 lines • 168 kB
JavaScript
import { __export, __export2, __reExport, buildErrorThrower, createDevOrStagingUrlCache, createClerkClient, isClerkAPIResponseError, ClerkRuntimeError, isPublishableKey } from './chunk-XNSJY45P.js';
import React8, { createContext, useContext, useMemo, useRef, useEffect, useLayoutEffect, createElement, useCallback, useDebugValue, useState } from 'react';
import { useSyncExternalStore } from 'use-sync-external-store/shim/index.js';
import { createPortal } from 'react-dom';
import { jsx } from 'react/jsx-runtime';
// ../shared/dist/chunk-E3NYSYOB.mjs
var TYPES_TO_OBJECTS = {
strict_mfa: {
afterMinutes: 10,
level: "multi_factor"
},
strict: {
afterMinutes: 10,
level: "second_factor"
},
moderate: {
afterMinutes: 60,
level: "second_factor"
},
lax: {
afterMinutes: 1440,
level: "second_factor"
}
};
var ALLOWED_LEVELS = /* @__PURE__ */ new Set(["first_factor", "second_factor", "multi_factor"]);
var ALLOWED_TYPES = /* @__PURE__ */ new Set(["strict_mfa", "strict", "moderate", "lax"]);
var isValidMaxAge = (maxAge) => typeof maxAge === "number" && maxAge > 0;
var isValidLevel = (level) => ALLOWED_LEVELS.has(level);
var isValidVerificationType = (type) => ALLOWED_TYPES.has(type);
var checkOrgAuthorization = (params, options) => {
const { orgId, orgRole, orgPermissions } = options;
if (!params.role && !params.permission) {
return null;
}
if (!orgId || !orgRole || !orgPermissions) {
return null;
}
if (params.permission) {
return orgPermissions.includes(params.permission);
}
if (params.role) {
return orgRole === params.role;
}
return null;
};
var validateReverificationConfig = (config) => {
if (!config) {
return false;
}
const convertConfigToObject = (config2) => {
if (typeof config2 === "string") {
return TYPES_TO_OBJECTS[config2];
}
return config2;
};
const isValidStringValue = typeof config === "string" && isValidVerificationType(config);
const isValidObjectValue = typeof config === "object" && isValidLevel(config.level) && isValidMaxAge(config.afterMinutes);
if (isValidStringValue || isValidObjectValue) {
return convertConfigToObject.bind(null, config);
}
return false;
};
var checkReverificationAuthorization = (params, { factorVerificationAge }) => {
if (!params.reverification || !factorVerificationAge) {
return null;
}
const isValidReverification = validateReverificationConfig(params.reverification);
if (!isValidReverification) {
return null;
}
const { level, afterMinutes } = isValidReverification();
const [factor1Age, factor2Age] = factorVerificationAge;
const isValidFactor1 = factor1Age !== -1 ? afterMinutes > factor1Age : null;
const isValidFactor2 = factor2Age !== -1 ? afterMinutes > factor2Age : null;
switch (level) {
case "first_factor":
return isValidFactor1;
case "second_factor":
return factor2Age !== -1 ? isValidFactor2 : isValidFactor1;
case "multi_factor":
return factor2Age === -1 ? isValidFactor1 : isValidFactor1 && isValidFactor2;
}
};
var createCheckAuthorization = (options) => {
return (params) => {
if (!options.userId) {
return false;
}
const orgAuthorization = checkOrgAuthorization(params, options);
const reverificationAuthorization = checkReverificationAuthorization(params, options);
if ([orgAuthorization, reverificationAuthorization].some((a) => a === null)) {
return [orgAuthorization, reverificationAuthorization].some((a) => a === true);
}
return [orgAuthorization, reverificationAuthorization].every((a) => a === true);
};
};
var EVENT_METHOD_CALLED = "METHOD_CALLED";
function eventMethodCalled(method, payload) {
return {
event: EVENT_METHOD_CALLED,
payload: {
method,
...payload
}
};
}
// ../shared/dist/chunk-IBXKDGSZ.mjs
function getCurrentOrganizationMembership(organizationMemberships, organizationId) {
return organizationMemberships.find(
(organizationMembership) => organizationMembership.organization.id === organizationId
);
}
// ../shared/dist/chunk-7FNX7RWY.mjs
var noop = (..._args) => {
};
// ../shared/dist/chunk-4S4AJ26F.mjs
var createDeferredPromise = () => {
let resolve = noop;
let reject = noop;
const promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
};
// ../shared/dist/chunk-43A5F2IE.mjs
var REVERIFICATION_REASON = "reverification-error";
var reverificationError = (missingConfig) => ({
clerk_error: {
type: "forbidden",
reason: REVERIFICATION_REASON,
metadata: {
reverification: missingConfig
}
}
});
var isReverificationHint = (result) => {
var _a, _b;
return result && typeof result === "object" && "clerk_error" in result && ((_a = result.clerk_error) == null ? void 0 : _a.type) === "forbidden" && ((_b = result.clerk_error) == null ? void 0 : _b.reason) === REVERIFICATION_REASON;
};
// ../../node_modules/.pnpm/swr@2.2.5_react@18.3.1/node_modules/swr/dist/core/index.mjs
var core_exports = {};
__export(core_exports, {
SWRConfig: () => SWRConfig2,
default: () => useSWR,
mutate: () => mutate,
preload: () => preload,
unstable_serialize: () => unstable_serialize,
useSWRConfig: () => useSWRConfig
});
var noop2 = () => {
};
var UNDEFINED = (
/*#__NOINLINE__*/
noop2()
);
var OBJECT = Object;
var isUndefined = (v) => v === UNDEFINED;
var isFunction = (v) => typeof v == "function";
var mergeObjects = (a, b) => ({
...a,
...b
});
var isPromiseLike = (x) => isFunction(x.then);
var table = /* @__PURE__ */ new WeakMap();
var counter = 0;
var stableHash = (arg) => {
const type = typeof arg;
const constructor = arg && arg.constructor;
const isDate = constructor == Date;
let result;
let index;
if (OBJECT(arg) === arg && !isDate && constructor != RegExp) {
result = table.get(arg);
if (result) return result;
result = ++counter + "~";
table.set(arg, result);
if (constructor == Array) {
result = "@";
for (index = 0; index < arg.length; index++) {
result += stableHash(arg[index]) + ",";
}
table.set(arg, result);
}
if (constructor == OBJECT) {
result = "#";
const keys = OBJECT.keys(arg).sort();
while (!isUndefined(index = keys.pop())) {
if (!isUndefined(arg[index])) {
result += index + ":" + stableHash(arg[index]) + ",";
}
}
table.set(arg, result);
}
} else {
result = isDate ? arg.toJSON() : type == "symbol" ? arg.toString() : type == "string" ? JSON.stringify(arg) : "" + arg;
}
return result;
};
var SWRGlobalState = /* @__PURE__ */ new WeakMap();
var EMPTY_CACHE = {};
var INITIAL_CACHE = {};
var STR_UNDEFINED = "undefined";
var isWindowDefined = typeof window != STR_UNDEFINED;
var isDocumentDefined = typeof document != STR_UNDEFINED;
var hasRequestAnimationFrame = () => isWindowDefined && typeof window["requestAnimationFrame"] != STR_UNDEFINED;
var createCacheHelper = (cache2, key) => {
const state = SWRGlobalState.get(cache2);
return [
// Getter
() => !isUndefined(key) && cache2.get(key) || EMPTY_CACHE,
// Setter
(info) => {
if (!isUndefined(key)) {
const prev = cache2.get(key);
if (!(key in INITIAL_CACHE)) {
INITIAL_CACHE[key] = prev;
}
state[5](key, mergeObjects(prev, info), prev || EMPTY_CACHE);
}
},
// Subscriber
state[6],
// Get server cache snapshot
() => {
if (!isUndefined(key)) {
if (key in INITIAL_CACHE) return INITIAL_CACHE[key];
}
return !isUndefined(key) && cache2.get(key) || EMPTY_CACHE;
}
];
};
var online = true;
var isOnline = () => online;
var [onWindowEvent, offWindowEvent] = isWindowDefined && window.addEventListener ? [
window.addEventListener.bind(window),
window.removeEventListener.bind(window)
] : [
noop2,
noop2
];
var isVisible = () => {
const visibilityState = isDocumentDefined && document.visibilityState;
return isUndefined(visibilityState) || visibilityState !== "hidden";
};
var initFocus = (callback) => {
if (isDocumentDefined) {
document.addEventListener("visibilitychange", callback);
}
onWindowEvent("focus", callback);
return () => {
if (isDocumentDefined) {
document.removeEventListener("visibilitychange", callback);
}
offWindowEvent("focus", callback);
};
};
var initReconnect = (callback) => {
const onOnline = () => {
online = true;
callback();
};
const onOffline = () => {
online = false;
};
onWindowEvent("online", onOnline);
onWindowEvent("offline", onOffline);
return () => {
offWindowEvent("online", onOnline);
offWindowEvent("offline", onOffline);
};
};
var preset = {
isOnline,
isVisible
};
var defaultConfigOptions = {
initFocus,
initReconnect
};
var IS_REACT_LEGACY = !React8.useId;
var IS_SERVER = !isWindowDefined || "Deno" in window;
var rAF = (f) => hasRequestAnimationFrame() ? window["requestAnimationFrame"](f) : setTimeout(f, 1);
var useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;
var navigatorConnection = typeof navigator !== "undefined" && navigator.connection;
var slowConnection = !IS_SERVER && navigatorConnection && ([
"slow-2g",
"2g"
].includes(navigatorConnection.effectiveType) || navigatorConnection.saveData);
var serialize = (key) => {
if (isFunction(key)) {
try {
key = key();
} catch (err) {
key = "";
}
}
const args = key;
key = typeof key == "string" ? key : (Array.isArray(key) ? key.length : key) ? stableHash(key) : "";
return [
key,
args
];
};
var __timestamp = 0;
var getTimestamp = () => ++__timestamp;
var FOCUS_EVENT = 0;
var RECONNECT_EVENT = 1;
var MUTATE_EVENT = 2;
var ERROR_REVALIDATE_EVENT = 3;
var events = {
__proto__: null,
ERROR_REVALIDATE_EVENT,
FOCUS_EVENT,
MUTATE_EVENT,
RECONNECT_EVENT
};
async function internalMutate(...args) {
const [cache2, _key, _data, _opts] = args;
const options = mergeObjects({
populateCache: true,
throwOnError: true
}, typeof _opts === "boolean" ? {
revalidate: _opts
} : _opts || {});
let populateCache = options.populateCache;
const rollbackOnErrorOption = options.rollbackOnError;
let optimisticData = options.optimisticData;
const rollbackOnError = (error) => {
return typeof rollbackOnErrorOption === "function" ? rollbackOnErrorOption(error) : rollbackOnErrorOption !== false;
};
const throwOnError = options.throwOnError;
if (isFunction(_key)) {
const keyFilter = _key;
const matchedKeys = [];
const it = cache2.keys();
for (const key of it) {
if (
// Skip the special useSWRInfinite and useSWRSubscription keys.
!/^\$(inf|sub)\$/.test(key) && keyFilter(cache2.get(key)._k)
) {
matchedKeys.push(key);
}
}
return Promise.all(matchedKeys.map(mutateByKey));
}
return mutateByKey(_key);
async function mutateByKey(_k) {
const [key] = serialize(_k);
if (!key) return;
const [get, set] = createCacheHelper(cache2, key);
const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache2);
const startRevalidate = () => {
const revalidators = EVENT_REVALIDATORS[key];
const revalidate = isFunction(options.revalidate) ? options.revalidate(get().data, _k) : options.revalidate !== false;
if (revalidate) {
delete FETCH[key];
delete PRELOAD[key];
if (revalidators && revalidators[0]) {
return revalidators[0](MUTATE_EVENT).then(() => get().data);
}
}
return get().data;
};
if (args.length < 3) {
return startRevalidate();
}
let data = _data;
let error;
const beforeMutationTs = getTimestamp();
MUTATION[key] = [
beforeMutationTs,
0
];
const hasOptimisticData = !isUndefined(optimisticData);
const state = get();
const displayedData = state.data;
const currentData = state._c;
const committedData = isUndefined(currentData) ? displayedData : currentData;
if (hasOptimisticData) {
optimisticData = isFunction(optimisticData) ? optimisticData(committedData, displayedData) : optimisticData;
set({
data: optimisticData,
_c: committedData
});
}
if (isFunction(data)) {
try {
data = data(committedData);
} catch (err) {
error = err;
}
}
if (data && isPromiseLike(data)) {
data = await data.catch((err) => {
error = err;
});
if (beforeMutationTs !== MUTATION[key][0]) {
if (error) throw error;
return data;
} else if (error && hasOptimisticData && rollbackOnError(error)) {
populateCache = true;
set({
data: committedData,
_c: UNDEFINED
});
}
}
if (populateCache) {
if (!error) {
if (isFunction(populateCache)) {
const populateCachedData = populateCache(data, committedData);
set({
data: populateCachedData,
error: UNDEFINED,
_c: UNDEFINED
});
} else {
set({
data,
error: UNDEFINED,
_c: UNDEFINED
});
}
}
}
MUTATION[key][1] = getTimestamp();
Promise.resolve(startRevalidate()).then(() => {
set({
_c: UNDEFINED
});
});
if (error) {
if (throwOnError) throw error;
return;
}
return data;
}
}
var revalidateAllKeys = (revalidators, type) => {
for (const key in revalidators) {
if (revalidators[key][0]) revalidators[key][0](type);
}
};
var initCache = (provider, options) => {
if (!SWRGlobalState.has(provider)) {
const opts = mergeObjects(defaultConfigOptions, options);
const EVENT_REVALIDATORS = {};
const mutate2 = internalMutate.bind(UNDEFINED, provider);
let unmount = noop2;
const subscriptions = {};
const subscribe = (key, callback) => {
const subs = subscriptions[key] || [];
subscriptions[key] = subs;
subs.push(callback);
return () => subs.splice(subs.indexOf(callback), 1);
};
const setter = (key, value, prev) => {
provider.set(key, value);
const subs = subscriptions[key];
if (subs) {
for (const fn of subs) {
fn(value, prev);
}
}
};
const initProvider = () => {
if (!SWRGlobalState.has(provider)) {
SWRGlobalState.set(provider, [
EVENT_REVALIDATORS,
{},
{},
{},
mutate2,
setter,
subscribe
]);
if (!IS_SERVER) {
const releaseFocus = opts.initFocus(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, FOCUS_EVENT)));
const releaseReconnect = opts.initReconnect(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, RECONNECT_EVENT)));
unmount = () => {
releaseFocus && releaseFocus();
releaseReconnect && releaseReconnect();
SWRGlobalState.delete(provider);
};
}
}
};
initProvider();
return [
provider,
mutate2,
initProvider,
unmount
];
}
return [
provider,
SWRGlobalState.get(provider)[4]
];
};
var onErrorRetry = (_, __, config, revalidate, opts) => {
const maxRetryCount = config.errorRetryCount;
const currentRetryCount = opts.retryCount;
const timeout = ~~((Math.random() + 0.5) * (1 << (currentRetryCount < 8 ? currentRetryCount : 8))) * config.errorRetryInterval;
if (!isUndefined(maxRetryCount) && currentRetryCount > maxRetryCount) {
return;
}
setTimeout(revalidate, timeout, opts);
};
var compare = (currentData, newData) => stableHash(currentData) == stableHash(newData);
var [cache, mutate] = initCache(/* @__PURE__ */ new Map());
var defaultConfig = mergeObjects(
{
// events
onLoadingSlow: noop2,
onSuccess: noop2,
onError: noop2,
onErrorRetry,
onDiscarded: noop2,
// switches
revalidateOnFocus: true,
revalidateOnReconnect: true,
revalidateIfStale: true,
shouldRetryOnError: true,
// timeouts
errorRetryInterval: slowConnection ? 1e4 : 5e3,
focusThrottleInterval: 5 * 1e3,
dedupingInterval: 2 * 1e3,
loadingTimeout: slowConnection ? 5e3 : 3e3,
// providers
compare,
isPaused: () => false,
cache,
mutate,
fallback: {}
},
// use web preset by default
preset
);
var mergeConfigs = (a, b) => {
const v = mergeObjects(a, b);
if (b) {
const { use: u1, fallback: f1 } = a;
const { use: u2, fallback: f2 } = b;
if (u1 && u2) {
v.use = u1.concat(u2);
}
if (f1 && f2) {
v.fallback = mergeObjects(f1, f2);
}
}
return v;
};
var SWRConfigContext = createContext({});
var SWRConfig = (props) => {
const { value } = props;
const parentConfig = useContext(SWRConfigContext);
const isFunctionalConfig = isFunction(value);
const config = useMemo(() => isFunctionalConfig ? value(parentConfig) : value, [
isFunctionalConfig,
parentConfig,
value
]);
const extendedConfig = useMemo(() => isFunctionalConfig ? config : mergeConfigs(parentConfig, config), [
isFunctionalConfig,
parentConfig,
config
]);
const provider = config && config.provider;
const cacheContextRef = useRef(UNDEFINED);
if (provider && !cacheContextRef.current) {
cacheContextRef.current = initCache(provider(extendedConfig.cache || cache), config);
}
const cacheContext = cacheContextRef.current;
if (cacheContext) {
extendedConfig.cache = cacheContext[0];
extendedConfig.mutate = cacheContext[1];
}
useIsomorphicLayoutEffect(() => {
if (cacheContext) {
cacheContext[2] && cacheContext[2]();
return cacheContext[3];
}
}, []);
return createElement(SWRConfigContext.Provider, mergeObjects(props, {
value: extendedConfig
}));
};
var INFINITE_PREFIX = "$inf$";
var enableDevtools = isWindowDefined && window.__SWR_DEVTOOLS_USE__;
var use = enableDevtools ? window.__SWR_DEVTOOLS_USE__ : [];
var setupDevTools = () => {
if (enableDevtools) {
window.__SWR_DEVTOOLS_REACT__ = React8;
}
};
var normalize = (args) => {
return isFunction(args[1]) ? [
args[0],
args[1],
args[2] || {}
] : [
args[0],
null,
(args[1] === null ? args[2] : args[1]) || {}
];
};
var useSWRConfig = () => {
return mergeObjects(defaultConfig, useContext(SWRConfigContext));
};
var preload = (key_, fetcher) => {
const [key, fnArg] = serialize(key_);
const [, , , PRELOAD] = SWRGlobalState.get(cache);
if (PRELOAD[key]) return PRELOAD[key];
const req = fetcher(fnArg);
PRELOAD[key] = req;
return req;
};
var middleware = (useSWRNext) => (key_, fetcher_, config) => {
const fetcher = fetcher_ && ((...args) => {
const [key] = serialize(key_);
const [, , , PRELOAD] = SWRGlobalState.get(cache);
if (key.startsWith(INFINITE_PREFIX)) {
return fetcher_(...args);
}
const req = PRELOAD[key];
if (isUndefined(req)) return fetcher_(...args);
delete PRELOAD[key];
return req;
});
return useSWRNext(key_, fetcher, config);
};
var BUILT_IN_MIDDLEWARE = use.concat(middleware);
var withArgs = (hook) => {
return function useSWRArgs(...args) {
const fallbackConfig = useSWRConfig();
const [key, fn, _config2] = normalize(args);
const config = mergeConfigs(fallbackConfig, _config2);
let next = hook;
const { use: use4 } = config;
const middleware2 = (use4 || []).concat(BUILT_IN_MIDDLEWARE);
for (let i = middleware2.length; i--; ) {
next = middleware2[i](next);
}
return next(key, fn || config.fetcher || null, config);
};
};
var subscribeCallback = (key, callbacks, callback) => {
const keyedRevalidators = callbacks[key] || (callbacks[key] = []);
keyedRevalidators.push(callback);
return () => {
const index = keyedRevalidators.indexOf(callback);
if (index >= 0) {
keyedRevalidators[index] = keyedRevalidators[keyedRevalidators.length - 1];
keyedRevalidators.pop();
}
};
};
var withMiddleware = (useSWR3, middleware2) => {
return (...args) => {
const [key, fn, config] = normalize(args);
const uses = (config.use || []).concat(middleware2);
return useSWR3(key, fn, {
...config,
use: uses
});
};
};
setupDevTools();
// ../../node_modules/.pnpm/swr@2.2.5_react@18.3.1/node_modules/swr/dist/core/index.mjs
var unstable_serialize = (key) => serialize(key)[0];
var use2 = React8.use || ((promise) => {
if (promise.status === "pending") {
throw promise;
} else if (promise.status === "fulfilled") {
return promise.value;
} else if (promise.status === "rejected") {
throw promise.reason;
} else {
promise.status = "pending";
promise.then((v) => {
promise.status = "fulfilled";
promise.value = v;
}, (e) => {
promise.status = "rejected";
promise.reason = e;
});
throw promise;
}
});
var WITH_DEDUPE = {
dedupe: true
};
var useSWRHandler = (_key, fetcher, config) => {
const { cache: cache2, compare: compare2, suspense, fallbackData, revalidateOnMount, revalidateIfStale, refreshInterval, refreshWhenHidden, refreshWhenOffline, keepPreviousData } = config;
const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache2);
const [key, fnArg] = serialize(_key);
const initialMountedRef = useRef(false);
const unmountedRef = useRef(false);
const keyRef = useRef(key);
const fetcherRef = useRef(fetcher);
const configRef = useRef(config);
const getConfig = () => configRef.current;
const isActive = () => getConfig().isVisible() && getConfig().isOnline();
const [getCache, setCache, subscribeCache, getInitialCache] = createCacheHelper(cache2, key);
const stateDependencies = useRef({}).current;
const fallback = isUndefined(fallbackData) ? config.fallback[key] : fallbackData;
const isEqual = (prev, current) => {
for (const _ in stateDependencies) {
const t = _;
if (t === "data") {
if (!compare2(prev[t], current[t])) {
if (!isUndefined(prev[t])) {
return false;
}
if (!compare2(returnedData, current[t])) {
return false;
}
}
} else {
if (current[t] !== prev[t]) {
return false;
}
}
}
return true;
};
const getSnapshot = useMemo(() => {
const shouldStartRequest = (() => {
if (!key) return false;
if (!fetcher) return false;
if (!isUndefined(revalidateOnMount)) return revalidateOnMount;
if (getConfig().isPaused()) return false;
if (suspense) return false;
if (!isUndefined(revalidateIfStale)) return revalidateIfStale;
return true;
})();
const getSelectedCache = (state) => {
const snapshot = mergeObjects(state);
delete snapshot._k;
if (!shouldStartRequest) {
return snapshot;
}
return {
isValidating: true,
isLoading: true,
...snapshot
};
};
const cachedData2 = getCache();
const initialData = getInitialCache();
const clientSnapshot = getSelectedCache(cachedData2);
const serverSnapshot = cachedData2 === initialData ? clientSnapshot : getSelectedCache(initialData);
let memorizedSnapshot = clientSnapshot;
return [
() => {
const newSnapshot = getSelectedCache(getCache());
const compareResult = isEqual(newSnapshot, memorizedSnapshot);
if (compareResult) {
memorizedSnapshot.data = newSnapshot.data;
memorizedSnapshot.isLoading = newSnapshot.isLoading;
memorizedSnapshot.isValidating = newSnapshot.isValidating;
memorizedSnapshot.error = newSnapshot.error;
return memorizedSnapshot;
} else {
memorizedSnapshot = newSnapshot;
return newSnapshot;
}
},
() => serverSnapshot
];
}, [
cache2,
key
]);
const cached = useSyncExternalStore(useCallback(
(callback) => subscribeCache(key, (current, prev) => {
if (!isEqual(prev, current)) callback();
}),
// eslint-disable-next-line react-hooks/exhaustive-deps
[
cache2,
key
]
), getSnapshot[0], getSnapshot[1]);
const isInitialMount = !initialMountedRef.current;
const hasRevalidator = EVENT_REVALIDATORS[key] && EVENT_REVALIDATORS[key].length > 0;
const cachedData = cached.data;
const data = isUndefined(cachedData) ? fallback : cachedData;
const error = cached.error;
const laggyDataRef = useRef(data);
const returnedData = keepPreviousData ? isUndefined(cachedData) ? laggyDataRef.current : cachedData : data;
const shouldDoInitialRevalidation = (() => {
if (hasRevalidator && !isUndefined(error)) return false;
if (isInitialMount && !isUndefined(revalidateOnMount)) return revalidateOnMount;
if (getConfig().isPaused()) return false;
if (suspense) return isUndefined(data) ? false : revalidateIfStale;
return isUndefined(data) || revalidateIfStale;
})();
const defaultValidatingState = !!(key && fetcher && isInitialMount && shouldDoInitialRevalidation);
const isValidating = isUndefined(cached.isValidating) ? defaultValidatingState : cached.isValidating;
const isLoading = isUndefined(cached.isLoading) ? defaultValidatingState : cached.isLoading;
const revalidate = useCallback(
async (revalidateOpts) => {
const currentFetcher = fetcherRef.current;
if (!key || !currentFetcher || unmountedRef.current || getConfig().isPaused()) {
return false;
}
let newData;
let startAt;
let loading = true;
const opts = revalidateOpts || {};
const shouldStartNewRequest = !FETCH[key] || !opts.dedupe;
const callbackSafeguard = () => {
if (IS_REACT_LEGACY) {
return !unmountedRef.current && key === keyRef.current && initialMountedRef.current;
}
return key === keyRef.current;
};
const finalState = {
isValidating: false,
isLoading: false
};
const finishRequestAndUpdateState = () => {
setCache(finalState);
};
const cleanupState = () => {
const requestInfo = FETCH[key];
if (requestInfo && requestInfo[1] === startAt) {
delete FETCH[key];
}
};
const initialState = {
isValidating: true
};
if (isUndefined(getCache().data)) {
initialState.isLoading = true;
}
try {
if (shouldStartNewRequest) {
setCache(initialState);
if (config.loadingTimeout && isUndefined(getCache().data)) {
setTimeout(() => {
if (loading && callbackSafeguard()) {
getConfig().onLoadingSlow(key, config);
}
}, config.loadingTimeout);
}
FETCH[key] = [
currentFetcher(fnArg),
getTimestamp()
];
}
[newData, startAt] = FETCH[key];
newData = await newData;
if (shouldStartNewRequest) {
setTimeout(cleanupState, config.dedupingInterval);
}
if (!FETCH[key] || FETCH[key][1] !== startAt) {
if (shouldStartNewRequest) {
if (callbackSafeguard()) {
getConfig().onDiscarded(key);
}
}
return false;
}
finalState.error = UNDEFINED;
const mutationInfo = MUTATION[key];
if (!isUndefined(mutationInfo) && // case 1
(startAt <= mutationInfo[0] || // case 2
startAt <= mutationInfo[1] || // case 3
mutationInfo[1] === 0)) {
finishRequestAndUpdateState();
if (shouldStartNewRequest) {
if (callbackSafeguard()) {
getConfig().onDiscarded(key);
}
}
return false;
}
const cacheData = getCache().data;
finalState.data = compare2(cacheData, newData) ? cacheData : newData;
if (shouldStartNewRequest) {
if (callbackSafeguard()) {
getConfig().onSuccess(newData, key, config);
}
}
} catch (err) {
cleanupState();
const currentConfig = getConfig();
const { shouldRetryOnError } = currentConfig;
if (!currentConfig.isPaused()) {
finalState.error = err;
if (shouldStartNewRequest && callbackSafeguard()) {
currentConfig.onError(err, key, currentConfig);
if (shouldRetryOnError === true || isFunction(shouldRetryOnError) && shouldRetryOnError(err)) {
if (!getConfig().revalidateOnFocus || !getConfig().revalidateOnReconnect || isActive()) {
currentConfig.onErrorRetry(err, key, currentConfig, (_opts) => {
const revalidators = EVENT_REVALIDATORS[key];
if (revalidators && revalidators[0]) {
revalidators[0](events.ERROR_REVALIDATE_EVENT, _opts);
}
}, {
retryCount: (opts.retryCount || 0) + 1,
dedupe: true
});
}
}
}
}
}
loading = false;
finishRequestAndUpdateState();
return true;
},
// `setState` is immutable, and `eventsCallback`, `fnArg`, and
// `keyValidating` are depending on `key`, so we can exclude them from
// the deps array.
//
// FIXME:
// `fn` and `config` might be changed during the lifecycle,
// but they might be changed every render like this.
// `useSWR('key', () => fetch('/api/'), { suspense: true })`
// So we omit the values from the deps array
// even though it might cause unexpected behaviors.
// eslint-disable-next-line react-hooks/exhaustive-deps
[
key,
cache2
]
);
const boundMutate = useCallback(
// Use callback to make sure `keyRef.current` returns latest result every time
(...args) => {
return internalMutate(cache2, keyRef.current, ...args);
},
// eslint-disable-next-line react-hooks/exhaustive-deps
[]
);
useIsomorphicLayoutEffect(() => {
fetcherRef.current = fetcher;
configRef.current = config;
if (!isUndefined(cachedData)) {
laggyDataRef.current = cachedData;
}
});
useIsomorphicLayoutEffect(() => {
if (!key) return;
const softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE);
let nextFocusRevalidatedAt = 0;
const onRevalidate = (type, opts = {}) => {
if (type == events.FOCUS_EVENT) {
const now = Date.now();
if (getConfig().revalidateOnFocus && now > nextFocusRevalidatedAt && isActive()) {
nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;
softRevalidate();
}
} else if (type == events.RECONNECT_EVENT) {
if (getConfig().revalidateOnReconnect && isActive()) {
softRevalidate();
}
} else if (type == events.MUTATE_EVENT) {
return revalidate();
} else if (type == events.ERROR_REVALIDATE_EVENT) {
return revalidate(opts);
}
return;
};
const unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);
unmountedRef.current = false;
keyRef.current = key;
initialMountedRef.current = true;
setCache({
_k: fnArg
});
if (shouldDoInitialRevalidation) {
if (isUndefined(data) || IS_SERVER) {
softRevalidate();
} else {
rAF(softRevalidate);
}
}
return () => {
unmountedRef.current = true;
unsubEvents();
};
}, [
key
]);
useIsomorphicLayoutEffect(() => {
let timer;
function next() {
const interval = isFunction(refreshInterval) ? refreshInterval(getCache().data) : refreshInterval;
if (interval && timer !== -1) {
timer = setTimeout(execute, interval);
}
}
function execute() {
if (!getCache().error && (refreshWhenHidden || getConfig().isVisible()) && (refreshWhenOffline || getConfig().isOnline())) {
revalidate(WITH_DEDUPE).then(next);
} else {
next();
}
}
next();
return () => {
if (timer) {
clearTimeout(timer);
timer = -1;
}
};
}, [
refreshInterval,
refreshWhenHidden,
refreshWhenOffline,
key
]);
useDebugValue(returnedData);
if (suspense && isUndefined(data) && key) {
if (!IS_REACT_LEGACY && IS_SERVER) {
throw new Error("Fallback data is required when using suspense in SSR.");
}
fetcherRef.current = fetcher;
configRef.current = config;
unmountedRef.current = false;
const req = PRELOAD[key];
if (!isUndefined(req)) {
const promise = boundMutate(req);
use2(promise);
}
if (isUndefined(error)) {
const promise = revalidate(WITH_DEDUPE);
if (!isUndefined(returnedData)) {
promise.status = "fulfilled";
promise.value = true;
}
use2(promise);
} else {
throw error;
}
}
return {
mutate: boundMutate,
get data() {
stateDependencies.data = true;
return returnedData;
},
get error() {
stateDependencies.error = true;
return error;
},
get isValidating() {
stateDependencies.isValidating = true;
return isValidating;
},
get isLoading() {
stateDependencies.isLoading = true;
return isLoading;
}
};
};
var SWRConfig2 = OBJECT.defineProperty(SWRConfig, "defaultValue", {
value: defaultConfig
});
var useSWR = withArgs(useSWRHandler);
var use3 = React8.use || ((promise) => {
if (promise.status === "pending") {
throw promise;
} else if (promise.status === "fulfilled") {
return promise.value;
} else if (promise.status === "rejected") {
throw promise.reason;
} else {
promise.status = "pending";
promise.then((v) => {
promise.status = "fulfilled";
promise.value = v;
}, (e) => {
promise.status = "rejected";
promise.reason = e;
});
throw promise;
}
});
var WITH_DEDUPE2 = {
dedupe: true
};
var useSWRHandler2 = (_key, fetcher, config) => {
const { cache: cache2, compare: compare2, suspense, fallbackData, revalidateOnMount, revalidateIfStale, refreshInterval, refreshWhenHidden, refreshWhenOffline, keepPreviousData } = config;
const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache2);
const [key, fnArg] = serialize(_key);
const initialMountedRef = useRef(false);
const unmountedRef = useRef(false);
const keyRef = useRef(key);
const fetcherRef = useRef(fetcher);
const configRef = useRef(config);
const getConfig = () => configRef.current;
const isActive = () => getConfig().isVisible() && getConfig().isOnline();
const [getCache, setCache, subscribeCache, getInitialCache] = createCacheHelper(cache2, key);
const stateDependencies = useRef({}).current;
const fallback = isUndefined(fallbackData) ? config.fallback[key] : fallbackData;
const isEqual = (prev, current) => {
for (const _ in stateDependencies) {
const t = _;
if (t === "data") {
if (!compare2(prev[t], current[t])) {
if (!isUndefined(prev[t])) {
return false;
}
if (!compare2(returnedData, current[t])) {
return false;
}
}
} else {
if (current[t] !== prev[t]) {
return false;
}
}
}
return true;
};
const getSnapshot = useMemo(() => {
const shouldStartRequest = (() => {
if (!key) return false;
if (!fetcher) return false;
if (!isUndefined(revalidateOnMount)) return revalidateOnMount;
if (getConfig().isPaused()) return false;
if (suspense) return false;
if (!isUndefined(revalidateIfStale)) return revalidateIfStale;
return true;
})();
const getSelectedCache = (state) => {
const snapshot = mergeObjects(state);
delete snapshot._k;
if (!shouldStartRequest) {
return snapshot;
}
return {
isValidating: true,
isLoading: true,
...snapshot
};
};
const cachedData2 = getCache();
const initialData = getInitialCache();
const clientSnapshot = getSelectedCache(cachedData2);
const serverSnapshot = cachedData2 === initialData ? clientSnapshot : getSelectedCache(initialData);
let memorizedSnapshot = clientSnapshot;
return [
() => {
const newSnapshot = getSelectedCache(getCache());
const compareResult = isEqual(newSnapshot, memorizedSnapshot);
if (compareResult) {
memorizedSnapshot.data = newSnapshot.data;
memorizedSnapshot.isLoading = newSnapshot.isLoading;
memorizedSnapshot.isValidating = newSnapshot.isValidating;
memorizedSnapshot.error = newSnapshot.error;
return memorizedSnapshot;
} else {
memorizedSnapshot = newSnapshot;
return newSnapshot;
}
},
() => serverSnapshot
];
}, [
cache2,
key
]);
const cached = useSyncExternalStore(useCallback(
(callback) => subscribeCache(key, (current, prev) => {
if (!isEqual(prev, current)) callback();
}),
// eslint-disable-next-line react-hooks/exhaustive-deps
[
cache2,
key
]
), getSnapshot[0], getSnapshot[1]);
const isInitialMount = !initialMountedRef.current;
const hasRevalidator = EVENT_REVALIDATORS[key] && EVENT_REVALIDATORS[key].length > 0;
const cachedData = cached.data;
const data = isUndefined(cachedData) ? fallback : cachedData;
const error = cached.error;
const laggyDataRef = useRef(data);
const returnedData = keepPreviousData ? isUndefined(cachedData) ? laggyDataRef.current : cachedData : data;
const shouldDoInitialRevalidation = (() => {
if (hasRevalidator && !isUndefined(error)) return false;
if (isInitialMount && !isUndefined(revalidateOnMount)) return revalidateOnMount;
if (getConfig().isPaused()) return false;
if (suspense) return isUndefined(data) ? false : revalidateIfStale;
return isUndefined(data) || revalidateIfStale;
})();
const defaultValidatingState = !!(key && fetcher && isInitialMount && shouldDoInitialRevalidation);
const isValidating = isUndefined(cached.isValidating) ? defaultValidatingState : cached.isValidating;
const isLoading = isUndefined(cached.isLoading) ? defaultValidatingState : cached.isLoading;
const revalidate = useCallback(
async (revalidateOpts) => {
const currentFetcher = fetcherRef.current;
if (!key || !currentFetcher || unmountedRef.current || getConfig().isPaused()) {
return false;
}
let newData;
let startAt;
let loading = true;
const opts = revalidateOpts || {};
const shouldStartNewRequest = !FETCH[key] || !opts.dedupe;
const callbackSafeguard = () => {
if (IS_REACT_LEGACY) {
return !unmountedRef.current && key === keyRef.current && initialMountedRef.current;
}
return key === keyRef.current;
};
const finalState = {
isValidating: false,
isLoading: false
};
const finishRequestAndUpdateState = () => {
setCache(finalState);
};
const cleanupState = () => {
const requestInfo = FETCH[key];
if (requestInfo && requestInfo[1] === startAt) {
delete FETCH[key];
}
};
const initialState = {
isValidating: true
};
if (isUndefined(getCache().data)) {
initialState.isLoading = true;
}
try {
if (shouldStartNewRequest) {
setCache(initialState);
if (config.loadingTimeout && isUndefined(getCache().data)) {
setTimeout(() => {
if (loading && callbackSafeguard()) {
getConfig().onLoadingSlow(key, config);
}
}, config.loadingTimeout);
}
FETCH[key] = [
currentFetcher(fnArg),
getTimestamp()
];
}
[newData, startAt] = FETCH[key];
newData = await newData;
if (shouldStartNewRequest) {
setTimeout(cleanupState, config.dedupingInterval);
}
if (!FETCH[key] || FETCH[key][1] !== startAt) {
if (shouldStartNewRequest) {
if (callbackSafeguard()) {
getConfig().onDiscarded(key);
}
}
return false;
}
finalState.error = UNDEFINED;
const mutationInfo = MUTATION[key];
if (!isUndefined(mutationInfo) && // case 1
(startAt <= mutationInfo[0] || // case 2
startAt <= mutationInfo[1] || // case 3
mutationInfo[1] === 0)) {
finishRequestAndUpdateState();
if (shouldStartNewRequest) {
if (callbackSafeguard()) {
getConfig().onDiscarded(key);
}
}
return false;
}
const cacheData = getCache().data;
finalState.data = compare2(cacheData, newData) ? cacheData : newData;
if (shouldStartNewRequest) {
if (callbackSafeguard()) {
getConfig().onSuccess(newData, key, config);
}
}
} catch (err) {
cleanupState();
const currentConfig = getConfig();
const { shouldRetryOnError } = currentConfig;
if (!currentConfig.isPaused()) {
finalState.error = err;
if (shouldStartNewRequest && callbackSafeguard()) {
currentConfig.onError(err, key, currentConfig);
if (shouldRetryOnError === true || isFunction(shouldRetryOnError) && shouldRetryOnError(err)) {
if (!getConfig().revalidateOnFocus || !getConfig().revalidateOnReconnect || isActive()) {
currentConfig.onErrorRetry(err, key, currentConfig, (_opts) => {
const revalidators = EVENT_REVALIDATORS[key];
if (revalidators && revalidators[0]) {
revalidators[0](events.ERROR_REVALIDATE_EVENT, _opts);
}
}, {
retryCount: (opts.retryCount || 0) + 1,
dedupe: true
});
}
}
}
}
}
loading = false;
finishRequestAndUpdateState();
return true;
},
// `setState` is immutable, and `eventsCallback`, `fnArg`, and
// `keyValidating` are depending on `key`, so we can exclude them from
// the deps array.
//
// FIXME:
// `fn` and `config` might be changed during the lifecycle,
// but they might be changed every render like this.
// `useSWR('key', () => fetch('/api/'), { suspense: true })`
// So we omit the values from the deps array
// even though it might cause unexpected behaviors.
// eslint-disable-next-line react-hooks/exhaustive-deps
[
key,
cache2
]
);
const boundMutate = useCallback(
// Use callback to make sure `keyRef.current` returns latest result every time
(...args) => {
return internalMutate(cache2, keyRef.current, ...args);
},
// eslint-disable-next-line react-hooks/exhaustive-deps
[]
);
useIsomorphicLayoutEffect(() => {
fetcherRef.current = fetcher;
configRef.current = config;
if (!isUndefined(cachedData)) {
laggyDataRef.current = cachedData;
}
});
useIsomorphicLayoutEffect(() => {
if (!key) return;
const softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE2);
let nextFocusRevalidatedAt = 0;
const onRevalidate = (type, opts = {}) => {
if (type == events.FOCUS_EVENT) {
const now = Date.now();
if (getConfig().revalidateOnFocus && now > nextFocusRevalidatedAt && isActive()) {
nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;
softRevalidate();
}
} else if (type == events.RECONNECT_EVENT) {
if (getConfig().revalidateOnReconnect && isActive()) {
softRevalidate();
}
} else if (type == events.MUTATE_EVENT) {
return revalidate();
} else if (type == events.ERROR_REVALIDATE_EVENT) {
return revalidate(opts);
}
return;
};
const unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);
unmountedRef.current = false;
keyRef.current = key;
initialMountedRef.current = true;
setCache({
_k: fnArg
});
if (shouldDoInitialRevalidation) {
if (isUndefined(data) || IS_SERVER) {
softRevalidate();
} else {
rAF(softRevalidate);
}
}
return () => {
unmountedRef.current = true;
unsubEvents();
};
}, [
key
]);
useIsomorphicLayoutEffect(() => {
let timer;
function next() {
const interval = isFunction(refreshInterval) ? refreshInterval(getCache().data) : refreshInterval;
if (interval && timer !== -1) {
timer = setTimeout(execute, interval);
}
}
function execute() {
if (!getCache().error && (refreshWhenHidden || getConfig().isVisible()) && (refreshWhenOffline || getConfig().isOnline())) {
revalidate(WITH_DEDUPE2).then(next);
} else {
next();
}
}
next();
return () => {
if (timer) {
clearTimeout(timer);
timer = -1;
}
};
}, [
refreshInterval,
refreshWhenHidden,
refreshWhenOffline,
key
]);
useDebugValue(returnedData);
if (suspense && isUndefined(data) && key) {
if (!IS_REACT_LEGACY && IS_SERVER) {
throw new Error("Fallback data is required when using suspense in SSR.");
}
fetcherRef.current = fetcher;
configRef.current = config;
unmountedRef.current = false;
const req = PRELOAD[key];
if (!isUndefined(req)) {
const promise = boundMutate(req);
use3(promise);
}
if (isUndefined(error)) {
const promise = revalidate(WITH_DEDUPE2);
if (!isUndefined(returnedData)) {
promise.status = "fulfilled";
promise.value = true;
}
use3(promise);
} else {
throw error;
}
}
return {
mutate: boundMutate,
get data() {
stateDependencies.data = true;
return returnedData;
},
get error() {
stateDependencies.error = true;
return error;
},
get isValidating() {
stateDependencies.isValidating = true;
return isValidating;
},
get isLoading() {
stateDependencies.isLoading = true;
return isLoading;
}
};
};
OBJECT.defineProperty(SWRConfig, "defaultValue", {
value: defaultConfig
});
var useSWR2 = withArgs(useSWRHandler2);
var getFirstPageKey = (getKey) => {
return serialize(getKey ? getKey(0, null) : null)[0];
};
var EMPTY_PROMISE = Promise.resolve();
var infinite = (useSWRNext) => (getKey, fn, config) => {
const didMountRef = useRef(false);
const { cache: cache$1, initialSize = 1, revalidateAll = false, persistSize = false, revalidateFirstPage = true, revalidateOnMount = false, parallel = false } = config;
const [, , , PRELOAD] = SWRGlobalState.get(cache);
let infiniteKey;
try {
infiniteKey = getFirstPageKey(getKey);
if (infiniteKey) infiniteKey = INFINITE_PREFIX + infiniteKey;
} catch (err) {
}
const [get, set, subscribeCache] = createCacheHelper(cache$1, infiniteKey);
const getSnapshot = useCallback(() => {
const size = isUndefined(get()._l) ? initialSize : get()._l;
return size;
}, [
cache$1,
infiniteKey,
initialSize
]);
useSyncExternalStore(useCallback(
(callback) => {
if (infiniteKey) return subscribeCache(infiniteKey, () => {
callback();
});
return () => {
};
},
// eslint-disable-next-line react-hooks/exhaustive-deps
[
cache$1,
infiniteKey
]
), getSnapshot, getSnapshot);
const resolvePageSize = useCallback(() => {
const cachedPageSize = get()._l;
return isUndefined(cachedPageSize) ? initialSize : cachedPageSize;
}, [
infiniteKey,
initialSize
]);
const lastPageSizeRef = useRef(resolvePageSize());
useIsomorphicLayoutEffect(() => {
if (!didMountRef.current) {
didMountRef.current = true;
return;
}
if (infiniteKey) {
set({
_l: persistSize ? lastPageSizeRef.current : resolvePageSize()
});
}
}, [
infiniteKey,
cache$1
]);
const shouldRevalidateOnMount = revalidateOnMount && !didMountRef.current;
const swr = useSWRNext(infiniteKey, async (key) => {
const forceRevalidateAll = get()._i;
const shouldRevalidatePage = get()._r;
set({
_r: UNDEFINED
});
const data = [];
const pageSize = resolvePageSize();
const [getCache] = createCacheHelper(cache$1, key);
const cacheData = getCache().data;
const revalidators = [];
let previousPageData = null;
for (let i = 0; i < pageSize; ++i) {
const [pageKey, pageArg] = serialize(getKey(i, parallel ? null : previousPageData));
if (!pageKey) {
break;
}
const [getSWRCache, setSWRCache] = createCacheHelper(cache$1, pageKey);
let pageData = getSWRCache().data;
const shouldFetchPage = revalidateAll || forceRevalidateAll || isUndefined(pageData) || revalidateFirstPage && !i && !isUndefined(cacheData) || shouldRevalidateOnMount || cacheData && !isUndefined(cacheData[i]) && !config.compare(cacheData[i], pageData);
if (fn && (typeof shouldRevalidatePage === "function" ? shouldRevalidatePage(pageData, pageArg) : shouldFetchPage)) {
const revalidate = async () => {
const hasPreloadedRequest = pageKey in PRELOAD;
if (!hasPreloadedRequest) {
pageData = await fn(pageArg);
} else {
const req = PRELOAD[pageKey];
delete PRELOAD[pageKey];
pageData = await req;
}
setSWRCache({
data: pageData,
_k: pageArg
});
data[i] = pageData;
};
if (parallel) {
revalidators.push(revalidate);
} else {
await revalidate();
}
} else {
data[i] = pageData;
}
if (!parallel) {
previousPageData = pageData;
}
}
if (parallel) {
await Promise.all(revalidators.map((r) => r()));
}
set({
_i: UNDEFINED
});
return data;
}, config);
const mutate2 = useCallback(
// eslint-disable-next-line func-names
function(data, opts) {
const options = typeof opts === "boolean" ? {
revalidate: opts
} : opts || {};
const shouldRevalidate = options.revalidate !== false;
if (!infiniteKey) return EMPTY_PROMISE;
if (shouldRevalidate) {
if (!isUndefined(data)) {
set({
_i: false,
_r: options.revalidate
});
} else {
set({
_i: true,
_r: options.revalidate
});
}
}
return arguments.length ? swr.mutate(data, {
...options,
revalidate: shouldRevalidate
}) : swr.mutate();
},
// swr.mutate is always the same reference
// eslint-disable-next-line react-hooks/exhaustive-deps
[
infiniteKey,
cache$1
]
);
const setSize = useCallback(
(arg) => {
if (!infiniteKey) return EMPTY_PROMISE;
const [, changeSize] = createCacheHelper(cache$1, infiniteKey);
let size;
if (isFunction(arg)) {
size = arg(resolvePageSize());
} else if (typeof arg == "number") {
size = arg;
}
if (typeof size != "number") return EMPTY_PROMISE;
changeSize({
_l: size
});
lastPageSizeRef.current = size;
const data = [];
const [getInfiniteCache] = createCacheHelper(cache$1, infiniteKey);
let previousPageData = null;
for (let i = 0; i < size; ++i) {
const [pageKey] = serialize(getKey(i, previousPageData));
const [getCache] = createCacheHelper(cache$1, pageKey);
const pageData = pageKey ? getCache().data : UNDEFINED;
if (isUndefined(pageData)) {
return mutate2(getInfiniteCache().data);
}
data.push(pageData);
previousPageData = pageData;
}
return mutate2(data);
},
// exclude getKey from the dependencies, which isn't allowed to change during the lifecycle
// eslint-disable-next-line react-hooks/exhaustive-deps
[
infiniteKey,
cache$1,
mutate2,
resolvePageSize
]
);
return {
size: resolvePageSize(),
setSize,
mutate: mutate2,
get data() {
return swr.data;
},
get error() {
return swr.error;
},
get isValidating() {
return swr.isValidating;
},
get isLoading() {
return swr.isLoading;
}
};
};
var useSWRInfinite = withMiddleware(useSWR2, infinite);
// ../../node_modules/.pnpm/dequal@2.0.3/node_modules/dequal/dist/index.mjs
var has = Object.prototype.hasOwnProperty;
function find(iter, tar, key) {
for (key of iter.keys()) {
if (dequal(key, tar)) return key;
}
}
function dequal(foo, bar) {
var ctor, len, tmp;
if (foo === bar) return true;
if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
if (ctor === Date) return foo.getTime() === bar.getTime();
if (ctor === RegExp) return foo.toString() === bar.toString();
if (ctor === Array) {
if ((len = foo.length) === bar.length) {
while (len-- && dequal(foo[len], bar[len])) ;
}
return len === -1;
}
if (ctor === Set) {
if (foo.size !== bar.size) {
return false;
}
for (len of foo) {
tmp = len;
if (tmp && typeof tmp === "object") {
tmp = find(bar, tmp);
if (!tmp) return false;
}
if (!bar.has(tmp)) return false;
}
return true;
}
if (ctor === Map) {
if (foo.size !== bar.size) {
return false;
}
for (len of foo) {
tmp = len[0];
if (tmp && typeof tmp === "object") {
tmp = find(bar, tmp);
if (!tmp) return false;
}
if (!dequal(len[1], bar.get(tmp))) {
return false;
}
}
return true;
}
if (ctor === ArrayBuffer) {
foo = new Uint8Array(foo);
bar = new Uint8Array(bar);
} else if (ctor === DataView) {
if ((len = foo.byteLength) === bar.byteLength) {
while (len-- && foo.getInt8(len) === bar.getInt8(len)) ;
}
return len === -1;
}
if (ArrayBuffer.isView(foo)) {
if ((len = foo.byteLength) === bar.byteLength) {
while (len-- && foo[len] === bar[len]) ;
}
return len === -1;
}
if (!ctor || typeof foo === "object") {
len = 0;
for (ctor in foo) {
if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
}
return Object.keys(bar).length === len;
}
}
return foo !== foo && bar !== bar;
}
function assertContextExists(contextVal, msgOrCtx) {
if (!contextVal) {
throw typeof msgOrCtx === "string" ? new Error(msgOrCtx) : new Error(`${msgOrCtx.displayName} not found`);
}
}
var createContextAndHook = (displayName, options) => {
const { assertCtxFn = assertContextExists } = {};
const Ctx = React8.createContext(void 0);
Ctx.displayName = displayName;
const useCtx = () => {
const ctx = React8.useContext(Ctx);
assertCtxFn(ctx, `${displayName} not found`);
return ctx.value;
};
const useCtxWithoutGuarantee = () => {
const ctx = React8.useContext(Ctx);
return ctx ? ctx.value : {};
};
return [Ctx, useCtx, useCtxWithoutGuarantee];
};
var clerk_swr_exports = {};
__export2(clerk_swr_exports, {
useSWR: () => useSWR,
useSWRInfinite: () => useSWRInfinite
});
__reExport(clerk_swr_exports, core_exports);
var [ClerkInstanceContext, useClerkInstanceContext] = createContextAndHook("ClerkInstanceContext");
var [UserContext, useUserContext] = createContextAndHook("UserContext");
var [ClientContext, useClientContext] = createContextAndHook("ClientContext");
var [SessionContext, useSessionContext] = createContextAndHook(
"SessionContext"
);
React8.createContext({});
var [OrganizationContextInternal, useOrganizationContext] = createContextAndHook("OrganizationContext");
var OrganizationProvider = ({
children,
organization,
swrConfig
}) => {
return /* @__PURE__ */ React8.createElement(clerk_swr_exports.SWRConfig, { value: swrConfig }, /* @__PURE__ */ React8.createElement(
OrganizationContextInternal.Provider,
{
value: {
value: { organization }
}
},
children
));
};
function useAssertWrappedByClerkProvider(displayNameOrFn) {
const ctx = React8.useContext(ClerkInstanceContext);
if (!ctx) {
if (typeof displayNameOrFn === "function") {
displayNameOrFn();
return;
}
throw new Error(
`${displayNameOrFn} can only be used within the <ClerkProvider /> component.
Possible fixes:
1. Ensure that the <ClerkProvider /> is correctly wrapping your application where this component is used.
2. Check for multiple versions of the \`@clerk/shared\` package in your project. Use a tool like \`npm ls @clerk/shared\` to identify multiple versions, and update your dependencies to only rely on one.
Learn more: https://clerk.com/docs/components/clerk-provider`.trim()
);
}
}
function getDifferentKeys(obj1, obj2) {
const keysSet = new Set(Object.keys(obj2));
const differentKeysObject = {};
for (const key1 of Object.keys(obj1)) {
if (!keysSet.has(key1)) {
differentKeysObject[key1] = obj1[key1];
}
}
return differentKeysObject;
}
var useWithSafeValues = (params, defaultValues) => {
var _a, _b, _c;
const shouldUseDefaults = typeof params === "boolean" && params;
const initialPageRef = useRef(
shouldUseDefaults ? defaultValues.initialPage : (_a = params == null ? void 0 : params.initialPage) != null ? _a : defaultValues.initialPage
);
const pageSizeRef = useRef(shouldUseDefaults ? defaultValues.pageSize : (_b = params == null ? void 0 : params.pageSize) != null ? _b : defaultValues.pageSize);
const newObj = {};
for (const key of Object.keys(defaultValues)) {
newObj[key] = shouldUseDefaults ? defaultValues[key] : (_c = params == null ? void 0 : params[key]) != null ? _c : defaultValues[key];
}
return {
...newObj,
initialPage: initialPageRef.current,
pageSize: pageSizeRef.current
};
};
var cachingSWROptions = {
dedupingInterval: 1e3 * 60,
focusThrottleInterval: 1e3 * 60 * 2
};
var usePagesOrInfinite = (params, fetcher, config, cacheKeys) => {
var _a, _b, _c, _d, _e, _f, _g;
const [paginatedPage, setPaginatedPage] = useState((_a = params.initialPage) != null ? _a : 1);
const initialPageRef = useRef((_b = params.initialPage) != null ? _b : 1);
const pageSizeRef = useRef((_c = params.pageSize) != null ? _c : 10);
const enabled = (_d = config.enabled) != null ? _d : true;
const triggerInfinite = (_e = config.infinite) != null ? _e : false;
const keepPreviousData = (_f = config.keepPreviousData) != null ? _f : false;
const pagesCacheKey = {
...cacheKeys,
...params,
initialPage: paginatedPage,
pageSize: pageSizeRef.current
};
const {
data: swrData,
isValidating: swrIsValidating,
isLoading: swrIsLoading,
error: swrError,
mutate: swrMutate
} = useSWR(
!triggerInfinite && !!fetcher && enabled ? pagesCacheKey : null,
(cacheKeyParams) => {
const requestParams = getDifferentKeys(cacheKeyParams, cacheKeys);
return fetcher == null ? void 0 : fetcher(requestParams);
},
{ keepPreviousData, ...cachingSWROptions }
);
const {
data: swrInfiniteData,
isLoading: swrInfiniteIsLoading,
isValidating: swrInfiniteIsValidating,
error: swrInfiniteError,
size,
setSize,
mutate: swrInfiniteMutate
} = useSWRInfinite(
(pageIndex) => {
if (!triggerInfinite || !enabled) {
return null;
}
return {
...params,
...cacheKeys,
initialPage: initialPageRef.current + pageIndex,
pageSize: pageSizeRef.current
};
},
(cacheKeyParams) => {
const requestParams = getDifferentKeys(cacheKeyParams, cacheKeys);
return fetcher == null ? void 0 : fetcher(requestParams);
},
cachingSWROptions
);
const page = useMemo(() => {
if (triggerInfinite) {
return size;
}
return paginatedPage;
}, [triggerInfinite, size, paginatedPage]);
const fetchPage = useCallback(
(numberOrgFn) => {
if (triggerInfinite) {
void setSize(numberOrgFn);
return;
}
return setPaginatedPage(numberOrgFn);
},
[setSize]
);
const data = useMemo(() => {
var _a2, _b2;
if (triggerInfinite) {
return (_a2 = swrInfiniteData == null ? void 0 : swrInfiniteData.map((a) => a == null ? void 0 : a.data).flat()) != null ? _a2 : [];
}
return (_b2 = swrData == null ? void 0 : swrData.data) != null ? _b2 : [];
}, [triggerInfinite, swrData, swrInfiniteData]);
const count = useMemo(() => {
var _a2, _b2;
if (triggerInfinite) {
return ((_a2 = swrInfiniteData == null ? void 0 : swrInfiniteData[(swrInfiniteData == null ? void 0 : swrInfiniteData.length) - 1]) == null ? void 0 : _a2.total_count) || 0;
}
return (_b2 = swrData == null ? void 0 : swrData.total_count) != null ? _b2 : 0;
}, [triggerInfinite, swrData, swrInfiniteData]);
const isLoading = triggerInfinite ? swrInfiniteIsLoading : swrIsLoading;
const isFetching = triggerInfinite ? swrInfiniteIsValidating : swrIsValidating;
const error = (_g = triggerInfinite ? swrInfiniteError : swrError) != null ? _g : null;
const isError = !!error;
const fetchNext = useCallback(() => {
fetchPage((n) => Math.max(0, n + 1));
}, [fetchPage]);
const fetchPrevious = useCallback(() => {
fetchPage((n) => Math.max(0, n - 1));
}, [fetchPage]);
const offsetCount = (initialPageRef.current - 1) * pageSizeRef.current;
const pageCount = Math.ceil((count - offsetCount) / pageSizeRef.current);
const hasNextPage = count - offsetCount * pageSizeRef.current > page * pageSizeRef.current;
const hasPreviousPage = (page - 1) * pageSizeRef.current > offsetCount * pageSizeRef.current;
const setData = triggerInfinite ? (value) => swrInfiniteMutate(value, {
revalidate: false
}) : (value) => swrMutate(value, {
revalidate: false
});
const revalidate = triggerInfinite ? () => swrInfiniteMutate() : () => swrMutate();
return {
data,
count,
error,
isLoading,
isFetching,
isError,
page,
pageCount,
fetchPage,
fetchNext,
fetchPrevious,
hasNextPage,
hasPreviousPage,
// Let the hook return type define this type
revalidate,
// Let the hook return type define this type
setData
};
};
var undefinedPaginatedResource = {
data: void 0,
count: void 0,
error: void 0,
isLoading: false,
isFetching: false,
isError: false,
page: void 0,
pageCount: void 0,
fetchPage: void 0,
fetchNext: void 0,
fetchPrevious: void 0,
hasNextPage: false,
hasPreviousPage: false,
revalidate: void 0,
setData: void 0
};
function useOrganization(params) {
var _a;
const {
domains: domainListParams,
membershipRequests: membershipRequestsListParams,
memberships: membersListParams,
invitations: invitationsListParams,
subscriptions: subscriptionsListParams
} = params || {};
useAssertWrappedByClerkProvider("useOrganization");
const { organization } = useOrganizationContext();
const session = useSessionContext();
const domainSafeValues = useWithSafeValues(domainListParams, {
initialPage: 1,
pageSize: 10,
keepPreviousData: false,
infinite: false,
enrollmentMode: void 0
});
const membershipRequestSafeValues = useWithSafeValues(membershipRequestsListParams, {
initialPage: 1,
pageSize: 10,
status: "pending",
keepPreviousData: false,
infinite: false
});
const membersSafeValues = useWithSafeValues(membersListParams, {
initialPage: 1,
pageSize: 10,
role: void 0,
keepPreviousData: false,
infinite: false,
query: void 0
});
const invitationsSafeValues = useWithSafeValues(invitationsListParams, {
initialPage: 1,
pageSize: 10,
status: ["pending"],
keepPreviousData: false,
infinite: false
});
const subscriptionsSafeValues = useWithSafeValues(subscriptionsListParams, {
initialPage: 1,
pageSize: 10,
status: void 0,
keepPreviousData: false,
infinite: false
});
const clerk = useClerkInstanceContext();
(_a = clerk.telemetry) == null ? void 0 : _a.record(eventMethodCalled("useOrganization"));
const domainParams = typeof domainListParams === "undefined" ? void 0 : {
initialPage: domainSafeValues.initialPage,
pageSize: domainSafeValues.pageSize,
enrollmentMode: domainSafeValues.enrollmentMode
};
const membershipRequestParams = typeof membershipRequestsListParams === "undefined" ? void 0 : {
initialPage: membershipRequestSafeValues.initialPage,
pageSize: membershipRequestSafeValues.pageSize,
status: membershipRequestSafeValues.status
};
const membersParams = typeof membersListParams === "undefined" ? void 0 : {
initialPage: membersSafeValues.initialPage,
pageSize: membersSafeValues.pageSize,
role: membersSafeValues.role,
query: membersSafeValues.query
};
const invitationsParams = typeof invitationsListParams === "undefined" ? void 0 : {
initialPage: invitationsSafeValues.initialPage,
pageSize: invitationsSafeValues.pageSize,
status: invitationsSafeValues.status
};
const subscriptionsParams = typeof subscriptionsListParams === "undefined" ? void 0 : {
initialPage: subscriptionsSafeValues.initialPage,
pageSize: subscriptionsSafeValues.pageSize,
status: subscriptionsSafeValues.status
};
const domains = usePagesOrInfinite(
{
...domainParams
},
organization == null ? void 0 : organization.getDomains,
{
keepPreviousData: domainSafeValues.keepPreviousData,
infinite: domainSafeValues.infinite,
enabled: !!domainParams
},
{
type: "domains",
organizationId: organization == null ? void 0 : organization.id
}
);
const membershipRequests = usePagesOrInfinite(
{
...membershipRequestParams
},
organization == null ? void 0 : organization.getMembershipRequests,
{
keepPreviousData: membershipRequestSafeValues.keepPreviousData,
infinite: membershipRequestSafeValues.infinite,
enabled: !!membershipRequestParams
},
{
type: "membershipRequests",
organizationId: organization == null ? void 0 : organization.id
}
);
const memberships = usePagesOrInfinite(
membersParams || {},
organization == null ? void 0 : organization.getMemberships,
{
keepPreviousData: membersSafeValues.keepPreviousData,
infinite: membersSafeValues.infinite,
enabled: !!membersParams
},
{
type: "members",
organizationId: organization == null ? void 0 : organization.id
}
);
const invitations = usePagesOrInfinite(
{
...invitationsParams
},
organization == null ? void 0 : organization.getInvitations,
{
keepPreviousData: invitationsSafeValues.keepPreviousData,
infinite: invitationsSafeValues.infinite,
enabled: !!invitationsParams
},
{
type: "invitations",
organizationId: organization == null ? void 0 : organization.id
}
);
const subscriptions = usePagesOrInfinite(
{
...subscriptionsParams
},
organization == null ? void 0 : organization.__experimental_getSubscriptions,
{
keepPreviousData: subscriptionsSafeValues.keepPreviousData,
infinite: subscriptionsSafeValues.infinite,
enabled: !!subscriptionsParams
},
{
type: "subscriptions",
organizationId: organization == null ? void 0 : organization.id
}
);
if (organization === void 0) {
return {
isLoaded: false,
organization: void 0,
membership: void 0,
domains: undefinedPaginatedResource,
membershipRequests: undefinedPaginatedResource,
memberships: undefinedPaginatedResource,
invitations: undefinedPaginatedResource,
subscriptions: undefinedPaginatedResource
};
}
if (organization === null) {
return {
isLoaded: true,
organization: null,
membership: null,
domains: null,
membershipRequests: null,
memberships: null,
invitations: null,
subscriptions: null
};
}
if (!clerk.loaded && organization) {
return {
isLoaded: true,
organization,
membership: void 0,
domains: undefinedPaginatedResource,
membershipRequests: undefinedPaginatedResource,
memberships: undefinedPaginatedResource,
invitations: undefinedPaginatedResource,
subscriptions: undefinedPaginatedResource
};
}
return {
isLoaded: clerk.loaded,
organization,
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
membership: getCurrentOrganizationMembership(session.user.organizationMemberships, organization.id),
// your membership in the current org
domains,
membershipRequests,
memberships,
invitations,
subscriptions
};
}
var undefinedPaginatedResource2 = {
data: void 0,
count: void 0,
error: void 0,
isLoading: false,
isFetching: false,
isError: false,
page: void 0,
pageCount: void 0,
fetchPage: void 0,
fetchNext: void 0,
fetchPrevious: void 0,
hasNextPage: false,
hasPreviousPage: false,
revalidate: void 0,
setData: void 0
};
function useOrganizationList(params) {
var _a;
const { userMemberships, userInvitations, userSuggestions } = params || {};
useAssertWrappedByClerkProvider("useOrganizationList");
const userMembershipsSafeValues = useWithSafeValues(userMemberships, {
initialPage: 1,
pageSize: 10,
keepPreviousData: false,
infinite: false
});
const userInvitationsSafeValues = useWithSafeValues(userInvitations, {
initialPage: 1,
pageSize: 10,
status: "pending",
keepPreviousData: false,
infinite: false
});
const userSuggestionsSafeValues = useWithSafeValues(userSuggestions, {
initialPage: 1,
pageSize: 10,
status: "pending",
keepPreviousData: false,
infinite: false
});
const clerk = useClerkInstanceContext();
const user = useUserContext();
(_a = clerk.telemetry) == null ? void 0 : _a.record(eventMethodCalled("useOrganizationList"));
const userMembershipsParams = typeof userMemberships === "undefined" ? void 0 : {
initialPage: userMembershipsSafeValues.initialPage,
pageSize: userMembershipsSafeValues.pageSize
};
const userInvitationsParams = typeof userInvitations === "undefined" ? void 0 : {
initialPage: userInvitationsSafeValues.initialPage,
pageSize: userInvitationsSafeValues.pageSize,
status: userInvitationsSafeValues.status
};
const userSuggestionsParams = typeof userSuggestions === "undefined" ? void 0 : {
initialPage: userSuggestionsSafeValues.initialPage,
pageSize: userSuggestionsSafeValues.pageSize,
status: userSuggestionsSafeValues.status
};
const isClerkLoaded = !!(clerk.loaded && user);
const memberships = usePagesOrInfinite(
userMembershipsParams || {},
user == null ? void 0 : user.getOrganizationMemberships,
{
keepPreviousData: userMembershipsSafeValues.keepPreviousData,
infinite: userMembershipsSafeValues.infinite,
enabled: !!userMembershipsParams
},
{
type: "userMemberships",
userId: user == null ? void 0 : user.id
}
);
const invitations = usePagesOrInfinite(
{
...userInvitationsParams
},
user == null ? void 0 : user.getOrganizationInvitations,
{
keepPreviousData: userInvitationsSafeValues.keepPreviousData,
infinite: userInvitationsSafeValues.infinite,
enabled: !!userInvitationsParams
},
{
type: "userInvitations",
userId: user == null ? void 0 : user.id
}
);
const suggestions = usePagesOrInfinite(
{
...userSuggestionsParams
},
user == null ? void 0 : user.getOrganizationSuggestions,
{
keepPreviousData: userSuggestionsSafeValues.keepPreviousData,
infinite: userSuggestionsSafeValues.infinite,
enabled: !!userSuggestionsParams
},
{
type: "userSuggestions",
userId: user == null ? void 0 : user.id
}
);
if (!isClerkLoaded) {
return {
isLoaded: false,
createOrganization: void 0,
setActive: void 0,
userMemberships: undefinedPaginatedResource2,
userInvitations: undefinedPaginatedResource2,
userSuggestions: undefinedPaginatedResource2
};
}
return {
isLoaded: isClerkLoaded,
setActive: clerk.setActive,
createOrganization: clerk.createOrganization,
userMemberships: memberships,
userInvitations: invitations,
userSuggestions: suggestions
};
}
var useSafeLayoutEffect = typeof window !== "undefined" ? React8.useLayoutEffect : React8.useEffect;
var useSession = () => {
useAssertWrappedByClerkProvider("useSession");
const session = useSessionContext();
if (session === void 0) {
return { isLoaded: false, isSignedIn: void 0, session: void 0 };
}
if (session === null) {
return { isLoaded: true, isSignedIn: false, session: null };
}
return { isLoaded: true, isSignedIn: true, session };
};
var useSessionList = () => {
useAssertWrappedByClerkProvider("useSessionList");
const isomorphicClerk = useClerkInstanceContext();
const client = useClientContext();
if (!client) {
return { isLoaded: false, sessions: void 0, setActive: void 0 };
}
return {
isLoaded: true,
sessions: client.sessions,
setActive: isomorphicClerk.setActive
};
};
function useUser() {
useAssertWrappedByClerkProvider("useUser");
const user = useUserContext();
if (user === void 0) {
return { isLoaded: false, isSignedIn: void 0, user: void 0 };
}
if (user === null) {
return { isLoaded: true, isSignedIn: false, user: null };
}
return { isLoaded: true, isSignedIn: true, user };
}
var useClerk = () => {
useAssertWrappedByClerkProvider("useClerk");
return useClerkInstanceContext();
};
var isDeeplyEqual = dequal;
var CLERK_API_REVERIFICATION_ERROR_CODE = "session_reverification_required";
async function resolveResult(result) {
try {
const r = await result;
if (r instanceof Response) {
return r.json();
}
return r;
} catch (e) {
if (isClerkAPIResponseError(e) && e.errors.find(({ code }) => code === CLERK_API_REVERIFICATION_ERROR_CODE)) {
return reverificationError();
}
throw e;
}
}
function createReverificationHandler(params) {
function assertReverification(fetcher) {
return async (...args) => {
var _a, _b, _c;
let result = await resolveResult(fetcher(...args));
if (isReverificationHint(result)) {
const resolvers = createDeferredPromise();
const isValidMetadata = validateReverificationConfig((_a = result.clerk_error.metadata) == null ? void 0 : _a.reverification);
const level = isValidMetadata ? isValidMetadata().level : void 0;
const cancel = () => {
resolvers.reject(
new ClerkRuntimeError("User cancelled attempted verification", {
code: "reverification_cancelled"
})
);
};
const complete = () => {
resolvers.resolve(true);
};
if (params.onNeedsReverification === void 0) {
(_b = params.openUIComponent) == null ? void 0 : _b.call(params, {
level,
afterVerification: complete,
afterVerificationCancelled: cancel
});
} else {
(_c = params.telemetry) == null ? void 0 : _c.record(eventMethodCalled("UserVerificationCustomUI"));
params.onNeedsReverification({
cancel,
complete,
level
});
}
await resolvers.promise;
result = await resolveResult(fetcher(...args));
}
return result;
};
}
return assertReverification;
}
var useReverification = (fetcher, options) => {
const { __internal_openReverification, telemetry } = useClerk();
const fetcherRef = useRef(fetcher);
const optionsRef = useRef(options);
const handleReverification = useMemo(() => {
const handler = createReverificationHandler({
openUIComponent: __internal_openReverification,
telemetry,
...optionsRef.current
})(fetcherRef.current);
return handler;
}, [__internal_openReverification, fetcherRef.current, optionsRef.current]);
useSafeLayoutEffect(() => {
fetcherRef.current = fetcher;
optionsRef.current = options;
});
return handleReverification;
};
// ../shared/dist/chunk-7HPDNZ3R.mjs
var isDevelopmentEnvironment = () => {
try {
return process.env.NODE_ENV === "development";
} catch {
}
return false;
};
var isTestEnvironment = () => {
try {
return process.env.NODE_ENV === "test";
} catch {
}
return false;
};
var isProductionEnvironment = () => {
try {
return process.env.NODE_ENV === "production";
} catch {
}
return false;
};
// ../shared/dist/chunk-UEY4AZIP.mjs
var displayedWarnings = /* @__PURE__ */ new Set();
var deprecated = (fnName, warning, key) => {
const hideWarning = isTestEnvironment() || isProductionEnvironment();
const messageId = fnName;
if (displayedWarnings.has(messageId) || hideWarning) {
return;
}
displayedWarnings.add(messageId);
console.warn(
`Clerk - DEPRECATION WARNING: "${fnName}" is deprecated and will be removed in the next major release.
${warning}`
);
};
var errorThrower = buildErrorThrower({ packageName: "@clerk/clerk-react" });
function setErrorThrowerOptions(options) {
errorThrower.setMessages(options).setPackageName(options);
}
var [AuthContext, useAuthContext] = createContextAndHook("AuthContext");
var IsomorphicClerkContext = ClerkInstanceContext;
var useIsomorphicClerkContext = useClerkInstanceContext;
var multipleClerkProvidersError = "You've added multiple <ClerkProvider> components in your React component tree. Wrap your components in a single <ClerkProvider>.";
var multipleChildrenInButtonComponent = (name) => `You've passed multiple children components to <${name}/>. You can only pass a single child component or text.`;
var invalidStateError = "Invalid state. Feel free to submit a bug or reach out to support here: https://clerk.com/support";
var unsupportedNonBrowserDomainOrProxyUrlFunction = "Unsupported usage of isSatellite, domain or proxyUrl. The usage of isSatellite, domain or proxyUrl as function is not supported in non-browser environments.";
var userProfilePageRenderedError = "<UserProfile.Page /> component needs to be a direct child of `<UserProfile />` or `<UserButton />`.";
var userProfileLinkRenderedError = "<UserProfile.Link /> component needs to be a direct child of `<UserProfile />` or `<UserButton />`.";
var organizationProfilePageRenderedError = "<OrganizationProfile.Page /> component needs to be a direct child of `<OrganizationProfile />` or `<OrganizationSwitcher />`.";
var organizationProfileLinkRenderedError = "<OrganizationProfile.Link /> component needs to be a direct child of `<OrganizationProfile />` or `<OrganizationSwitcher />`.";
var customPagesIgnoredComponent = (componentName) => `<${componentName} /> can only accept <${componentName}.Page /> and <${componentName}.Link /> as its children. Any other provided component will be ignored.`;
var customPageWrongProps = (componentName) => `Missing props. <${componentName}.Page /> component requires the following props: url, label, labelIcon, alongside with children to be rendered inside the page.`;
var customLinkWrongProps = (componentName) => `Missing props. <${componentName}.Link /> component requires the following props: url, label and labelIcon.`;
var userButtonIgnoredComponent = `<UserButton /> can only accept <UserButton.UserProfilePage />, <UserButton.UserProfileLink /> and <UserButton.MenuItems /> as its children. Any other provided component will be ignored.`;
var customMenuItemsIgnoredComponent = "<UserButton.MenuItems /> component can only accept <UserButton.Action /> and <UserButton.Link /> as its children. Any other provided component will be ignored.";
var userButtonMenuItemsRenderedError = "<UserButton.MenuItems /> component needs to be a direct child of `<UserButton />`.";
var userButtonMenuActionRenderedError = "<UserButton.Action /> component needs to be a direct child of `<UserButton.MenuItems />`.";
var userButtonMenuLinkRenderedError = "<UserButton.Link /> component needs to be a direct child of `<UserButton.MenuItems />`.";
var userButtonMenuItemLinkWrongProps = "Missing props. <UserButton.Link /> component requires the following props: href, label and labelIcon.";
var userButtonMenuItemsActionWrongsProps = "Missing props. <UserButton.Action /> component requires the following props: label.";
var useAssertWrappedByClerkProvider2 = (source) => {
useAssertWrappedByClerkProvider(() => {
errorThrower.throwMissingClerkProviderError({ source });
});
};
var clerkLoaded = (isomorphicClerk) => {
return new Promise((resolve) => {
if (isomorphicClerk.loaded) {
resolve();
}
isomorphicClerk.addOnLoaded(resolve);
});
};
var createGetToken = (isomorphicClerk) => {
return async (options) => {
await clerkLoaded(isomorphicClerk);
if (!isomorphicClerk.session) {
return null;
}
return isomorphicClerk.session.getToken(options);
};
};
var createSignOut = (isomorphicClerk) => {
return async (...args) => {
await clerkLoaded(isomorphicClerk);
return isomorphicClerk.signOut(...args);
};
};
var useAuth = (initialAuthState = {}) => {
useAssertWrappedByClerkProvider2("useAuth");
const authContextFromHook = useAuthContext();
let authContext = authContextFromHook;
if (authContext.sessionId === void 0 && authContext.userId === void 0) {
authContext = initialAuthState != null ? initialAuthState : {};
}
const { sessionId, userId, actor, orgId, orgRole, orgSlug, orgPermissions, factorVerificationAge } = authContext;
const isomorphicClerk = useIsomorphicClerkContext();
const getToken = useCallback(createGetToken(isomorphicClerk), [isomorphicClerk]);
const signOut = useCallback(createSignOut(isomorphicClerk), [isomorphicClerk]);
return useDerivedAuth({
sessionId,
userId,
actor,
orgId,
orgSlug,
orgRole,
getToken,
signOut,
orgPermissions,
factorVerificationAge
});
};
function useDerivedAuth(authObject) {
const {
sessionId,
userId,
actor,
orgId,
orgSlug,
orgRole,
has: has2,
signOut,
getToken,
orgPermissions,
factorVerificationAge
} = authObject != null ? authObject : {};
const derivedHas = useCallback(
(params) => {
if (has2) {
return has2(params);
}
return createCheckAuthorization({
userId,
orgId,
orgRole,
orgPermissions,
factorVerificationAge
})(params);
},
[userId, factorVerificationAge, orgId, orgRole, orgPermissions]
);
if (sessionId === void 0 && userId === void 0) {
return {
isLoaded: false,
isSignedIn: void 0,
sessionId,
userId,
actor: void 0,
orgId: void 0,
orgRole: void 0,
orgSlug: void 0,
has: void 0,
signOut,
getToken
};
}
if (sessionId === null && userId === null) {
return {
isLoaded: true,
isSignedIn: false,
sessionId,
userId,
actor: null,
orgId: null,
orgRole: null,
orgSlug: null,
has: () => false,
signOut,
getToken
};
}
if (!!sessionId && !!userId && !!orgId && !!orgRole) {
return {
isLoaded: true,
isSignedIn: true,
sessionId,
userId,
actor: actor || null,
orgId,
orgRole,
orgSlug: orgSlug || null,
has: derivedHas,
signOut,
getToken
};
}
if (!!sessionId && !!userId && !orgId) {
return {
isLoaded: true,
isSignedIn: true,
sessionId,
userId,
actor: actor || null,
orgId: null,
orgRole: null,
orgSlug: null,
has: derivedHas,
signOut,
getToken
};
}
return errorThrower.throw(invalidStateError);
}
function useEmailLink(resource) {
const { startEmailLinkFlow, cancelEmailLinkFlow } = React8.useMemo(() => resource.createEmailLinkFlow(), [resource]);
React8.useEffect(() => {
return cancelEmailLinkFlow;
}, []);
return {
startEmailLinkFlow,
cancelEmailLinkFlow
};
}
var useSignIn = () => {
var _a;
useAssertWrappedByClerkProvider2("useSignIn");
const isomorphicClerk = useIsomorphicClerkContext();
const client = useClientContext();
(_a = isomorphicClerk.telemetry) == null ? void 0 : _a.record(eventMethodCalled("useSignIn"));
if (!client) {
return { isLoaded: false, signIn: void 0, setActive: void 0 };
}
return {
isLoaded: true,
signIn: client.signIn,
setActive: isomorphicClerk.setActive
};
};
var useSignUp = () => {
var _a;
useAssertWrappedByClerkProvider2("useSignUp");
const isomorphicClerk = useIsomorphicClerkContext();
const client = useClientContext();
(_a = isomorphicClerk.telemetry) == null ? void 0 : _a.record(eventMethodCalled("useSignUp"));
if (!client) {
return { isLoaded: false, signUp: void 0, setActive: void 0 };
}
return {
isLoaded: true,
signUp: client.signUp,
setActive: isomorphicClerk.setActive
};
};
var withClerk = (Component, displayNameOrOptions) => {
const passedDisplayedName = typeof displayNameOrOptions === "string" ? displayNameOrOptions : displayNameOrOptions == null ? void 0 : displayNameOrOptions.component;
const displayName = passedDisplayedName || Component.displayName || Component.name || "Component";
Component.displayName = displayName;
const options = typeof displayNameOrOptions === "string" ? void 0 : displayNameOrOptions;
const HOC = (props) => {
useAssertWrappedByClerkProvider2(displayName || "withClerk");
const clerk = useIsomorphicClerkContext();
if (!clerk.loaded && !(options == null ? void 0 : options.renderWhileLoading)) {
return null;
}
return /* @__PURE__ */ React8.createElement(
Component,
{
...props,
component: displayName,
clerk
}
);
};
HOC.displayName = `withClerk(${displayName})`;
return HOC;
};
var SignedIn = ({ children }) => {
useAssertWrappedByClerkProvider2("SignedIn");
const { userId } = useAuthContext();
if (userId) {
return children;
}
return null;
};
var SignedOut = ({ children }) => {
useAssertWrappedByClerkProvider2("SignedOut");
const { userId } = useAuthContext();
if (userId === null) {
return children;
}
return null;
};
var ClerkLoaded = ({ children }) => {
useAssertWrappedByClerkProvider2("ClerkLoaded");
const isomorphicClerk = useIsomorphicClerkContext();
if (!isomorphicClerk.loaded) {
return null;
}
return children;
};
var ClerkLoading = ({ children }) => {
useAssertWrappedByClerkProvider2("ClerkLoading");
const isomorphicClerk = useIsomorphicClerkContext();
if (isomorphicClerk.loaded) {
return null;
}
return children;
};
var Protect = ({ children, fallback, ...restAuthorizedParams }) => {
useAssertWrappedByClerkProvider2("Protect");
const { isLoaded, has: has2, userId } = useAuth();
if (!isLoaded) {
return null;
}
const unauthorized = fallback != null ? fallback : null;
const authorized = children;
if (!userId) {
return unauthorized;
}
if (typeof restAuthorizedParams.condition === "function") {
if (restAuthorizedParams.condition(has2)) {
return authorized;
}
return unauthorized;
}
if (restAuthorizedParams.role || restAuthorizedParams.permission) {
if (has2(restAuthorizedParams)) {
return authorized;
}
return unauthorized;
}
return authorized;
};
var RedirectToSignIn = withClerk(({ clerk, ...props }) => {
const { client, session } = clerk;
const hasSignedInSessions = client.signedInSessions ? client.signedInSessions.length > 0 : (
// Compat for clerk-js<5.54.0 (which was released with the `signedInSessions` property)
client.activeSessions && client.activeSessions.length > 0
);
React8.useEffect(() => {
if (session === null && hasSignedInSessions) {
void clerk.redirectToAfterSignOut();
} else {
void clerk.redirectToSignIn(props);
}
}, []);
return null;
}, "RedirectToSignIn");
var RedirectToSignUp = withClerk(({ clerk, ...props }) => {
React8.useEffect(() => {
void clerk.redirectToSignUp(props);
}, []);
return null;
}, "RedirectToSignUp");
var RedirectToUserProfile = withClerk(({ clerk }) => {
React8.useEffect(() => {
deprecated("RedirectToUserProfile", "Use the `redirectToUserProfile()` method instead.");
void clerk.redirectToUserProfile();
}, []);
return null;
}, "RedirectToUserProfile");
var RedirectToOrganizationProfile = withClerk(({ clerk }) => {
React8.useEffect(() => {
deprecated("RedirectToOrganizationProfile", "Use the `redirectToOrganizationProfile()` method instead.");
void clerk.redirectToOrganizationProfile();
}, []);
return null;
}, "RedirectToOrganizationProfile");
var RedirectToCreateOrganization = withClerk(({ clerk }) => {
React8.useEffect(() => {
deprecated("RedirectToCreateOrganization", "Use the `redirectToCreateOrganization()` method instead.");
void clerk.redirectToCreateOrganization();
}, []);
return null;
}, "RedirectToCreateOrganization");
var AuthenticateWithRedirectCallback = withClerk(
({ clerk, ...handleRedirectCallbackParams }) => {
React8.useEffect(() => {
void clerk.handleRedirectCallback(handleRedirectCallbackParams);
}, []);
return null;
},
"AuthenticateWithRedirectCallback"
);
// ../react/dist/chunk-OANWQR3B.mjs
var __typeError = (msg) => {
throw TypeError(msg);
};
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet2 = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd2 = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet2 = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
var __privateMethod2 = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
// ../shared/dist/chunk-ZLEGTXF3.mjs
var { isDevOrStagingUrl } = createDevOrStagingUrlCache();
var errorThrower2 = buildErrorThrower({ packageName: "@clerk/shared" });
function setClerkJsLoadingErrorPackageName(packageName) {
errorThrower2.setPackageName({ packageName });
}
// ../shared/dist/chunk-3QKZJFQO.mjs
var logErrorInDevMode = (message) => {
if (isDevelopmentEnvironment()) {
console.error(`Clerk: ${message}`);
}
};
// ../shared/dist/chunk-O32JQBM6.mjs
function handleValueOrFn(value, url, defaultValue) {
if (typeof value === "function") {
return value(url);
}
if (typeof value !== "undefined") {
return value;
}
if (typeof defaultValue !== "undefined") {
return defaultValue;
}
return void 0;
}
// ../shared/dist/chunk-CFXQSUF6.mjs
var without = (obj, ...props) => {
const copy = { ...obj };
for (const prop of props) {
delete copy[prop];
}
return copy;
};
// ../shared/dist/chunk-2GBZREM5.mjs
var deriveState = (clerkLoaded2, state, initialState) => {
if (!clerkLoaded2 && initialState) {
return deriveFromSsrInitialState(initialState);
}
return deriveFromClientSideState(state);
};
var deriveFromSsrInitialState = (initialState) => {
const userId = initialState.userId;
const user = initialState.user;
const sessionId = initialState.sessionId;
const sessionStatus = initialState.sessionStatus;
const session = initialState.session;
const organization = initialState.organization;
const orgId = initialState.orgId;
const orgRole = initialState.orgRole;
const orgPermissions = initialState.orgPermissions;
const orgSlug = initialState.orgSlug;
const actor = initialState.actor;
const factorVerificationAge = initialState.factorVerificationAge;
return {
userId,
user,
sessionId,
session,
sessionStatus,
organization,
orgId,
orgRole,
orgPermissions,
orgSlug,
actor,
factorVerificationAge
};
};
var deriveFromClientSideState = (state) => {
var _a, _b;
const userId = state.user ? state.user.id : state.user;
const user = state.user;
const sessionId = state.session ? state.session.id : state.session;
const session = state.session;
const sessionStatus = (_a = state.session) == null ? void 0 : _a.status;
const factorVerificationAge = state.session ? state.session.factorVerificationAge : null;
const actor = session == null ? void 0 : session.actor;
const organization = state.organization;
const orgId = state.organization ? state.organization.id : state.organization;
const orgSlug = organization == null ? void 0 : organization.slug;
const membership = organization ? (_b = user == null ? void 0 : user.organizationMemberships) == null ? void 0 : _b.find((om) => om.organization.id === orgId) : organization;
const orgPermissions = membership ? membership.permissions : membership;
const orgRole = membership ? membership.role : membership;
return {
userId,
user,
sessionId,
session,
sessionStatus,
organization,
orgId,
orgRole,
orgSlug,
orgPermissions,
actor,
factorVerificationAge
};
};
// ../shared/dist/chunk-JKSAJ6AV.mjs
function inBrowser() {
return typeof window !== "undefined";
}
// ../react/dist/index.mjs
if (typeof window !== "undefined" && !window.global) {
window.global = typeof global === "undefined" ? window : global;
}
var assertSingleChild = (children) => (name) => {
try {
return React8.Children.only(children);
} catch {
return errorThrower.throw(multipleChildrenInButtonComponent(name));
}
};
var normalizeWithDefaultValue = (children, defaultText) => {
if (!children) {
children = defaultText;
}
if (typeof children === "string") {
children = /* @__PURE__ */ React8.createElement("button", null, children);
}
return children;
};
var safeExecute = (cb) => (...args) => {
if (cb && typeof cb === "function") {
return cb(...args);
}
};
function isConstructor(f) {
return typeof f === "function";
}
var counts = /* @__PURE__ */ new Map();
function useMaxAllowedInstancesGuard(name, error, maxCount = 1) {
React8.useEffect(() => {
const count = counts.get(name) || 0;
if (count == maxCount) {
return errorThrower.throw(error);
}
counts.set(name, count + 1);
return () => {
counts.set(name, (counts.get(name) || 1) - 1);
};
}, []);
}
function withMaxAllowedInstancesGuard(WrappedComponent, name, error) {
const displayName = WrappedComponent.displayName || WrappedComponent.name || name || "Component";
const Hoc = (props) => {
useMaxAllowedInstancesGuard(name, error);
return /* @__PURE__ */ React8.createElement(WrappedComponent, { ...props });
};
Hoc.displayName = `withMaxAllowedInstancesGuard(${displayName})`;
return Hoc;
}
var useCustomElementPortal = (elements) => {
const initialState = Array(elements.length).fill(null);
const [nodes, setNodes] = useState(initialState);
return elements.map((el, index) => ({
id: el.id,
mount: (node) => setNodes((prevState) => prevState.map((n, i) => i === index ? node : n)),
unmount: () => setNodes((prevState) => prevState.map((n, i) => i === index ? null : n)),
portal: () => /* @__PURE__ */ React8.createElement(React8.Fragment, null, nodes[index] ? createPortal(el.component, nodes[index]) : null)
}));
};
var isThatComponent = (v, component) => {
return !!v && React8.isValidElement(v) && (v == null ? void 0 : v.type) === component;
};
var useUserProfileCustomPages = (children, options) => {
const reorderItemsLabels = ["account", "security"];
return useCustomPages(
{
children,
reorderItemsLabels,
LinkComponent: UserProfileLink,
PageComponent: UserProfilePage,
MenuItemsComponent: MenuItems,
componentName: "UserProfile"
},
options
);
};
var useOrganizationProfileCustomPages = (children, options) => {
const reorderItemsLabels = ["general", "members"];
return useCustomPages(
{
children,
reorderItemsLabels,
LinkComponent: OrganizationProfileLink,
PageComponent: OrganizationProfilePage,
componentName: "OrganizationProfile"
},
options
);
};
var useSanitizedChildren = (children) => {
const sanitizedChildren = [];
const excludedComponents = [
OrganizationProfileLink,
OrganizationProfilePage,
MenuItems,
UserProfilePage,
UserProfileLink
];
React8.Children.forEach(children, (child) => {
if (!excludedComponents.some((component) => isThatComponent(child, component))) {
sanitizedChildren.push(child);
}
});
return sanitizedChildren;
};
var useCustomPages = (params, options) => {
const { children, LinkComponent, PageComponent, MenuItemsComponent, reorderItemsLabels, componentName } = params;
const { allowForAnyChildren = false } = options || {};
const validChildren = [];
React8.Children.forEach(children, (child) => {
if (!isThatComponent(child, PageComponent) && !isThatComponent(child, LinkComponent) && !isThatComponent(child, MenuItemsComponent)) {
if (child && !allowForAnyChildren) {
logErrorInDevMode(customPagesIgnoredComponent(componentName));
}
return;
}
const { props } = child;
const { children: children2, label, url, labelIcon } = props;
if (isThatComponent(child, PageComponent)) {
if (isReorderItem(props, reorderItemsLabels)) {
validChildren.push({ label });
} else if (isCustomPage(props)) {
validChildren.push({ label, labelIcon, children: children2, url });
} else {
logErrorInDevMode(customPageWrongProps(componentName));
return;
}
}
if (isThatComponent(child, LinkComponent)) {
if (isExternalLink(props)) {
validChildren.push({ label, labelIcon, url });
} else {
logErrorInDevMode(customLinkWrongProps(componentName));
return;
}
}
});
const customPageContents = [];
const customPageLabelIcons = [];
const customLinkLabelIcons = [];
validChildren.forEach((cp, index) => {
if (isCustomPage(cp)) {
customPageContents.push({ component: cp.children, id: index });
customPageLabelIcons.push({ component: cp.labelIcon, id: index });
return;
}
if (isExternalLink(cp)) {
customLinkLabelIcons.push({ component: cp.labelIcon, id: index });
}
});
const customPageContentsPortals = useCustomElementPortal(customPageContents);
const customPageLabelIconsPortals = useCustomElementPortal(customPageLabelIcons);
const customLinkLabelIconsPortals = useCustomElementPortal(customLinkLabelIcons);
const customPages = [];
const customPagesPortals = [];
validChildren.forEach((cp, index) => {
if (isReorderItem(cp, reorderItemsLabels)) {
customPages.push({ label: cp.label });
return;
}
if (isCustomPage(cp)) {
const {
portal: contentPortal,
mount,
unmount
} = customPageContentsPortals.find((p) => p.id === index);
const {
portal: labelPortal,
mount: mountIcon,
unmount: unmountIcon
} = customPageLabelIconsPortals.find((p) => p.id === index);
customPages.push({ label: cp.label, url: cp.url, mount, unmount, mountIcon, unmountIcon });
customPagesPortals.push(contentPortal);
customPagesPortals.push(labelPortal);
return;
}
if (isExternalLink(cp)) {
const {
portal: labelPortal,
mount: mountIcon,
unmount: unmountIcon
} = customLinkLabelIconsPortals.find((p) => p.id === index);
customPages.push({ label: cp.label, url: cp.url, mountIcon, unmountIcon });
customPagesPortals.push(labelPortal);
return;
}
});
return { customPages, customPagesPortals };
};
var isReorderItem = (childProps, validItems) => {
const { children, label, url, labelIcon } = childProps;
return !children && !url && !labelIcon && validItems.some((v) => v === label);
};
var isCustomPage = (childProps) => {
const { children, label, url, labelIcon } = childProps;
return !!children && !!url && !!labelIcon && !!label;
};
var isExternalLink = (childProps) => {
const { children, label, url, labelIcon } = childProps;
return !children && !!url && !!labelIcon && !!label;
};
var useUserButtonCustomMenuItems = (children) => {
const reorderItemsLabels = ["manageAccount", "signOut"];
return useCustomMenuItems({
children,
reorderItemsLabels,
MenuItemsComponent: MenuItems,
MenuActionComponent: MenuAction,
MenuLinkComponent: MenuLink,
UserProfileLinkComponent: UserProfileLink,
UserProfilePageComponent: UserProfilePage
});
};
var useCustomMenuItems = ({
children,
MenuItemsComponent,
MenuActionComponent,
MenuLinkComponent,
UserProfileLinkComponent,
UserProfilePageComponent,
reorderItemsLabels
}) => {
const validChildren = [];
const customMenuItems = [];
const customMenuItemsPortals = [];
React8.Children.forEach(children, (child) => {
if (!isThatComponent(child, MenuItemsComponent) && !isThatComponent(child, UserProfileLinkComponent) && !isThatComponent(child, UserProfilePageComponent)) {
if (child) {
logErrorInDevMode(userButtonIgnoredComponent);
}
return;
}
if (isThatComponent(child, UserProfileLinkComponent) || isThatComponent(child, UserProfilePageComponent)) {
return;
}
const { props } = child;
React8.Children.forEach(props.children, (child2) => {
if (!isThatComponent(child2, MenuActionComponent) && !isThatComponent(child2, MenuLinkComponent)) {
if (child2) {
logErrorInDevMode(customMenuItemsIgnoredComponent);
}
return;
}
const { props: props2 } = child2;
const { label, labelIcon, href, onClick, open } = props2;
if (isThatComponent(child2, MenuActionComponent)) {
if (isReorderItem2(props2, reorderItemsLabels)) {
validChildren.push({ label });
} else if (isCustomMenuItem(props2)) {
const baseItem = {
label,
labelIcon
};
if (onClick !== void 0) {
validChildren.push({
...baseItem,
onClick
});
} else if (open !== void 0) {
validChildren.push({
...baseItem,
open: open.startsWith("/") ? open : `/${open}`
});
} else {
logErrorInDevMode("Custom menu item must have either onClick or open property");
return;
}
} else {
logErrorInDevMode(userButtonMenuItemsActionWrongsProps);
return;
}
}
if (isThatComponent(child2, MenuLinkComponent)) {
if (isExternalLink2(props2)) {
validChildren.push({ label, labelIcon, href });
} else {
logErrorInDevMode(userButtonMenuItemLinkWrongProps);
return;
}
}
});
});
const customMenuItemLabelIcons = [];
const customLinkLabelIcons = [];
validChildren.forEach((mi, index) => {
if (isCustomMenuItem(mi)) {
customMenuItemLabelIcons.push({ component: mi.labelIcon, id: index });
}
if (isExternalLink2(mi)) {
customLinkLabelIcons.push({ component: mi.labelIcon, id: index });
}
});
const customMenuItemLabelIconsPortals = useCustomElementPortal(customMenuItemLabelIcons);
const customLinkLabelIconsPortals = useCustomElementPortal(customLinkLabelIcons);
validChildren.forEach((mi, index) => {
if (isReorderItem2(mi, reorderItemsLabels)) {
customMenuItems.push({
label: mi.label
});
}
if (isCustomMenuItem(mi)) {
const {
portal: iconPortal,
mount: mountIcon,
unmount: unmountIcon
} = customMenuItemLabelIconsPortals.find((p) => p.id === index);
const menuItem = {
label: mi.label,
mountIcon,
unmountIcon
};
if ("onClick" in mi) {
menuItem.onClick = mi.onClick;
} else if ("open" in mi) {
menuItem.open = mi.open;
}
customMenuItems.push(menuItem);
customMenuItemsPortals.push(iconPortal);
}
if (isExternalLink2(mi)) {
const {
portal: iconPortal,
mount: mountIcon,
unmount: unmountIcon
} = customLinkLabelIconsPortals.find((p) => p.id === index);
customMenuItems.push({
label: mi.label,
href: mi.href,
mountIcon,
unmountIcon
});
customMenuItemsPortals.push(iconPortal);
}
});
return { customMenuItems, customMenuItemsPortals };
};
var isReorderItem2 = (childProps, validItems) => {
const { children, label, onClick, labelIcon } = childProps;
return !children && !onClick && !labelIcon && validItems.some((v) => v === label);
};
var isCustomMenuItem = (childProps) => {
const { label, labelIcon, onClick, open } = childProps;
return !!labelIcon && !!label && (typeof onClick === "function" || typeof open === "string");
};
var isExternalLink2 = (childProps) => {
const { label, href, labelIcon } = childProps;
return !!href && !!labelIcon && !!label;
};
function waitForElementChildren(options) {
const { root = document == null ? void 0 : document.body, selector, timeout = 0 } = options;
return new Promise((resolve, reject) => {
if (!root) {
reject(new Error("No root element provided"));
return;
}
let elementToWatch = root;
if (selector) {
elementToWatch = root == null ? void 0 : root.querySelector(selector);
}
const isElementAlreadyPresent = (elementToWatch == null ? void 0 : elementToWatch.childElementCount) && elementToWatch.childElementCount > 0;
if (isElementAlreadyPresent) {
resolve();
return;
}
const observer = new MutationObserver((mutationsList) => {
for (const mutation of mutationsList) {
if (mutation.type === "childList") {
if (!elementToWatch && selector) {
elementToWatch = root == null ? void 0 : root.querySelector(selector);
}
if ((elementToWatch == null ? void 0 : elementToWatch.childElementCount) && elementToWatch.childElementCount > 0) {
observer.disconnect();
resolve();
return;
}
}
}
});
observer.observe(root, { childList: true, subtree: true });
if (timeout > 0) {
setTimeout(() => {
observer.disconnect();
reject(new Error(`Timeout waiting for element children`));
}, timeout);
}
});
}
function useWaitForComponentMount(component) {
const watcherRef = useRef();
const [status, setStatus] = useState("rendering");
useEffect(() => {
if (!component) {
throw new Error("Clerk: no component name provided, unable to detect mount.");
}
if (typeof window !== "undefined" && !watcherRef.current) {
watcherRef.current = waitForElementChildren({ selector: `[data-clerk-component="${component}"]` }).then(() => {
setStatus("rendered");
}).catch(() => {
setStatus("error");
});
}
}, [component]);
return status;
}
var isMountProps = (props) => {
return "mount" in props;
};
var isOpenProps = (props) => {
return "open" in props;
};
var stripMenuItemIconHandlers = (menuItems) => {
return menuItems == null ? void 0 : menuItems.map(({ mountIcon, unmountIcon, ...rest }) => rest);
};
var ClerkHostRenderer = class extends React8.PureComponent {
constructor() {
super(...arguments);
this.rootRef = React8.createRef();
}
componentDidUpdate(_prevProps) {
var _a, _b, _c, _d;
if (!isMountProps(_prevProps) || !isMountProps(this.props)) {
return;
}
const prevProps = without(_prevProps.props, "customPages", "customMenuItems", "children");
const newProps = without(this.props.props, "customPages", "customMenuItems", "children");
const customPagesChanged = ((_a = prevProps.customPages) == null ? void 0 : _a.length) !== ((_b = newProps.customPages) == null ? void 0 : _b.length);
const customMenuItemsChanged = ((_c = prevProps.customMenuItems) == null ? void 0 : _c.length) !== ((_d = newProps.customMenuItems) == null ? void 0 : _d.length);
const prevMenuItemsWithoutHandlers = stripMenuItemIconHandlers(_prevProps.props.customMenuItems);
const newMenuItemsWithoutHandlers = stripMenuItemIconHandlers(this.props.props.customMenuItems);
if (!isDeeplyEqual(prevProps, newProps) || !isDeeplyEqual(prevMenuItemsWithoutHandlers, newMenuItemsWithoutHandlers) || customPagesChanged || customMenuItemsChanged) {
if (this.rootRef.current) {
this.props.updateProps({ node: this.rootRef.current, props: this.props.props });
}
}
}
componentDidMount() {
if (this.rootRef.current) {
if (isMountProps(this.props)) {
this.props.mount(this.rootRef.current, this.props.props);
}
if (isOpenProps(this.props)) {
this.props.open(this.props.props);
}
}
}
componentWillUnmount() {
if (this.rootRef.current) {
if (isMountProps(this.props)) {
this.props.unmount(this.rootRef.current);
}
if (isOpenProps(this.props)) {
this.props.close();
}
}
}
render() {
const { hideRootHtmlElement = false } = this.props;
const rootAttributes = {
ref: this.rootRef,
...this.props.rootProps,
...this.props.component && { "data-clerk-component": this.props.component }
};
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, !hideRootHtmlElement && /* @__PURE__ */ React8.createElement("div", { ...rootAttributes }), this.props.children);
}
};
var CustomPortalsRenderer = (props) => {
var _a, _b;
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, (_a = props == null ? void 0 : props.customPagesPortals) == null ? void 0 : _a.map((portal, index) => createElement(portal, { key: index })), (_b = props == null ? void 0 : props.customMenuItemsPortals) == null ? void 0 : _b.map((portal, index) => createElement(portal, { key: index })));
};
var SignIn = withClerk(
({ clerk, component, fallback, ...props }) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
mount: clerk.mountSignIn,
unmount: clerk.unmountSignIn,
updateProps: clerk.__unstable__updateProps,
props,
rootProps: rendererRootProps
}
));
},
{ component: "SignIn", renderWhileLoading: true }
);
var SignUp = withClerk(
({ clerk, component, fallback, ...props }) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
mount: clerk.mountSignUp,
unmount: clerk.unmountSignUp,
updateProps: clerk.__unstable__updateProps,
props,
rootProps: rendererRootProps
}
));
},
{ component: "SignUp", renderWhileLoading: true }
);
function UserProfilePage({ children }) {
logErrorInDevMode(userProfilePageRenderedError);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, children);
}
function UserProfileLink({ children }) {
logErrorInDevMode(userProfileLinkRenderedError);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, children);
}
var _UserProfile = withClerk(
({
clerk,
component,
fallback,
...props
}) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
const { customPages, customPagesPortals } = useUserProfileCustomPages(props.children);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
mount: clerk.mountUserProfile,
unmount: clerk.unmountUserProfile,
updateProps: clerk.__unstable__updateProps,
props: { ...props, customPages },
rootProps: rendererRootProps
},
/* @__PURE__ */ React8.createElement(CustomPortalsRenderer, { customPagesPortals })
));
},
{ component: "UserProfile", renderWhileLoading: true }
);
var UserProfile = Object.assign(_UserProfile, {
Page: UserProfilePage,
Link: UserProfileLink
});
var UserButtonContext = createContext({
mount: () => {
},
unmount: () => {
},
updateProps: () => {
}
});
var _UserButton = withClerk(
({
clerk,
component,
fallback,
...props
}) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
const { customPages, customPagesPortals } = useUserProfileCustomPages(props.children, {
allowForAnyChildren: !!props.__experimental_asProvider
});
const userProfileProps = Object.assign(props.userProfileProps || {}, { customPages });
const { customMenuItems, customMenuItemsPortals } = useUserButtonCustomMenuItems(props.children);
const sanitizedChildren = useSanitizedChildren(props.children);
const passableProps = {
mount: clerk.mountUserButton,
unmount: clerk.unmountUserButton,
updateProps: clerk.__unstable__updateProps,
props: { ...props, userProfileProps, customMenuItems }
};
const portalProps = {
customPagesPortals,
customMenuItemsPortals
};
return /* @__PURE__ */ React8.createElement(UserButtonContext.Provider, { value: passableProps }, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
...passableProps,
hideRootHtmlElement: !!props.__experimental_asProvider,
rootProps: rendererRootProps
},
props.__experimental_asProvider ? sanitizedChildren : null,
/* @__PURE__ */ React8.createElement(CustomPortalsRenderer, { ...portalProps })
));
},
{ component: "UserButton", renderWhileLoading: true }
);
function MenuItems({ children }) {
logErrorInDevMode(userButtonMenuItemsRenderedError);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, children);
}
function MenuAction({ children }) {
logErrorInDevMode(userButtonMenuActionRenderedError);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, children);
}
function MenuLink({ children }) {
logErrorInDevMode(userButtonMenuLinkRenderedError);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, children);
}
function UserButtonOutlet(outletProps) {
const providerProps = useContext(UserButtonContext);
const portalProps = {
...providerProps,
props: {
...providerProps.props,
...outletProps
}
};
return /* @__PURE__ */ React8.createElement(ClerkHostRenderer, { ...portalProps });
}
var UserButton = Object.assign(_UserButton, {
UserProfilePage,
UserProfileLink,
MenuItems,
Action: MenuAction,
Link: MenuLink,
__experimental_Outlet: UserButtonOutlet
});
function OrganizationProfilePage({ children }) {
logErrorInDevMode(organizationProfilePageRenderedError);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, children);
}
function OrganizationProfileLink({ children }) {
logErrorInDevMode(organizationProfileLinkRenderedError);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, children);
}
var _OrganizationProfile = withClerk(
({
clerk,
component,
fallback,
...props
}) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
const { customPages, customPagesPortals } = useOrganizationProfileCustomPages(props.children);
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
mount: clerk.mountOrganizationProfile,
unmount: clerk.unmountOrganizationProfile,
updateProps: clerk.__unstable__updateProps,
props: { ...props, customPages },
rootProps: rendererRootProps
},
/* @__PURE__ */ React8.createElement(CustomPortalsRenderer, { customPagesPortals })
));
},
{ component: "OrganizationProfile", renderWhileLoading: true }
);
var OrganizationProfile = Object.assign(_OrganizationProfile, {
Page: OrganizationProfilePage,
Link: OrganizationProfileLink
});
var CreateOrganization = withClerk(
({ clerk, component, fallback, ...props }) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
mount: clerk.mountCreateOrganization,
unmount: clerk.unmountCreateOrganization,
updateProps: clerk.__unstable__updateProps,
props,
rootProps: rendererRootProps
}
));
},
{ component: "CreateOrganization", renderWhileLoading: true }
);
var OrganizationSwitcherContext = createContext({
mount: () => {
},
unmount: () => {
},
updateProps: () => {
}
});
var _OrganizationSwitcher = withClerk(
({
clerk,
component,
fallback,
...props
}) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
const { customPages, customPagesPortals } = useOrganizationProfileCustomPages(props.children, {
allowForAnyChildren: !!props.__experimental_asProvider
});
const organizationProfileProps = Object.assign(props.organizationProfileProps || {}, { customPages });
const sanitizedChildren = useSanitizedChildren(props.children);
const passableProps = {
mount: clerk.mountOrganizationSwitcher,
unmount: clerk.unmountOrganizationSwitcher,
updateProps: clerk.__unstable__updateProps,
props: { ...props, organizationProfileProps },
rootProps: rendererRootProps,
component
};
clerk.__experimental_prefetchOrganizationSwitcher();
return /* @__PURE__ */ React8.createElement(OrganizationSwitcherContext.Provider, { value: passableProps }, /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
...passableProps,
hideRootHtmlElement: !!props.__experimental_asProvider
},
props.__experimental_asProvider ? sanitizedChildren : null,
/* @__PURE__ */ React8.createElement(CustomPortalsRenderer, { customPagesPortals })
)));
},
{ component: "OrganizationSwitcher", renderWhileLoading: true }
);
function OrganizationSwitcherOutlet(outletProps) {
const providerProps = useContext(OrganizationSwitcherContext);
const portalProps = {
...providerProps,
props: {
...providerProps.props,
...outletProps
}
};
return /* @__PURE__ */ React8.createElement(ClerkHostRenderer, { ...portalProps });
}
var OrganizationSwitcher = Object.assign(_OrganizationSwitcher, {
OrganizationProfilePage,
OrganizationProfileLink,
__experimental_Outlet: OrganizationSwitcherOutlet
});
var OrganizationList = withClerk(
({ clerk, component, fallback, ...props }) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
mount: clerk.mountOrganizationList,
unmount: clerk.unmountOrganizationList,
updateProps: clerk.__unstable__updateProps,
props,
rootProps: rendererRootProps
}
));
},
{ component: "OrganizationList", renderWhileLoading: true }
);
var GoogleOneTap = withClerk(
({ clerk, component, fallback, ...props }) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
open: clerk.openGoogleOneTap,
close: clerk.closeGoogleOneTap,
updateProps: clerk.__unstable__updateProps,
props,
rootProps: rendererRootProps
}
));
},
{ component: "GoogleOneTap", renderWhileLoading: true }
);
var Waitlist = withClerk(
({ clerk, component, fallback, ...props }) => {
const mountingStatus = useWaitForComponentMount(component);
const shouldShowFallback = mountingStatus === "rendering" || !clerk.loaded;
const rendererRootProps = {
...shouldShowFallback && fallback && { style: { display: "none" } }
};
return /* @__PURE__ */ React8.createElement(React8.Fragment, null, shouldShowFallback && fallback, clerk.loaded && /* @__PURE__ */ React8.createElement(
ClerkHostRenderer,
{
component,
mount: clerk.mountWaitlist,
unmount: clerk.unmountWaitlist,
updateProps: clerk.__unstable__updateProps,
props,
rootProps: rendererRootProps
}
));
},
{ component: "Waitlist", renderWhileLoading: true }
);
var SignInButton = withClerk(
({ clerk, children, ...props }) => {
const {
signUpFallbackRedirectUrl,
forceRedirectUrl,
fallbackRedirectUrl,
signUpForceRedirectUrl,
mode,
initialValues,
withSignUp,
oauthFlow,
...rest
} = props;
children = normalizeWithDefaultValue(children, "Sign in");
const child = assertSingleChild(children)("SignInButton");
const clickHandler = () => {
const opts = {
forceRedirectUrl,
fallbackRedirectUrl,
signUpFallbackRedirectUrl,
signUpForceRedirectUrl,
initialValues,
withSignUp,
oauthFlow
};
if (mode === "modal") {
return clerk.openSignIn({ ...opts, appearance: props.appearance });
}
return clerk.redirectToSignIn({
...opts,
signInFallbackRedirectUrl: fallbackRedirectUrl,
signInForceRedirectUrl: forceRedirectUrl
});
};
const wrappedChildClickHandler = async (e) => {
if (child && typeof child === "object" && "props" in child) {
await safeExecute(child.props.onClick)(e);
}
return clickHandler();
};
const childProps = { ...rest, onClick: wrappedChildClickHandler };
return React8.cloneElement(child, childProps);
},
{ component: "SignInButton", renderWhileLoading: true }
);
var SignUpButton = withClerk(
({ clerk, children, ...props }) => {
const {
fallbackRedirectUrl,
forceRedirectUrl,
signInFallbackRedirectUrl,
signInForceRedirectUrl,
mode,
unsafeMetadata,
initialValues,
oauthFlow,
...rest
} = props;
children = normalizeWithDefaultValue(children, "Sign up");
const child = assertSingleChild(children)("SignUpButton");
const clickHandler = () => {
const opts = {
fallbackRedirectUrl,
forceRedirectUrl,
signInFallbackRedirectUrl,
signInForceRedirectUrl,
unsafeMetadata,
initialValues,
oauthFlow
};
if (mode === "modal") {
return clerk.openSignUp({ ...opts, appearance: props.appearance });
}
return clerk.redirectToSignUp({
...opts,
signUpFallbackRedirectUrl: fallbackRedirectUrl,
signUpForceRedirectUrl: forceRedirectUrl
});
};
const wrappedChildClickHandler = async (e) => {
if (child && typeof child === "object" && "props" in child) {
await safeExecute(child.props.onClick)(e);
}
return clickHandler();
};
const childProps = { ...rest, onClick: wrappedChildClickHandler };
return React8.cloneElement(child, childProps);
},
{ component: "SignUpButton", renderWhileLoading: true }
);
var SignOutButton = withClerk(
({ clerk, children, ...props }) => {
const { redirectUrl = "/", signOutOptions, ...rest } = props;
children = normalizeWithDefaultValue(children, "Sign out");
const child = assertSingleChild(children)("SignOutButton");
const clickHandler = () => clerk.signOut({ redirectUrl, ...signOutOptions });
const wrappedChildClickHandler = async (e) => {
await safeExecute(child.props.onClick)(e);
return clickHandler();
};
const childProps = { ...rest, onClick: wrappedChildClickHandler };
return React8.cloneElement(child, childProps);
},
{ component: "SignOutButton", renderWhileLoading: true }
);
var SignInWithMetamaskButton = withClerk(
({ clerk, children, ...props }) => {
const { redirectUrl, ...rest } = props;
children = normalizeWithDefaultValue(children, "Sign in with Metamask");
const child = assertSingleChild(children)("SignInWithMetamaskButton");
const clickHandler = async () => {
async function authenticate() {
await clerk.authenticateWithMetamask({ redirectUrl: redirectUrl || void 0 });
}
void authenticate();
};
const wrappedChildClickHandler = async (e) => {
await safeExecute(child.props.onClick)(e);
return clickHandler();
};
const childProps = { ...rest, onClick: wrappedChildClickHandler };
return React8.cloneElement(child, childProps);
},
{ component: "SignInWithMetamask", renderWhileLoading: true }
);
if (typeof globalThis.__BUILD_DISABLE_RHC__ === "undefined") {
globalThis.__BUILD_DISABLE_RHC__ = false;
}
var SDK_METADATA = {
name: "@clerk/clerk-react",
version: "5.25.5",
environment: process.env.NODE_ENV
};
var _loaded;
var _domain;
var _proxyUrl;
var _publishableKey;
var _instance;
var _IsomorphicClerk_instances;
var waitForClerkJS_fn;
var _IsomorphicClerk = class _IsomorphicClerk2 {
constructor(options) {
__privateAdd2(this, _IsomorphicClerk_instances);
this.clerkjs = null;
this.preopenOneTap = null;
this.preopenUserVerification = null;
this.preopenSignIn = null;
this.preopenSignUp = null;
this.preopenUserProfile = null;
this.preopenOrganizationProfile = null;
this.preopenCreateOrganization = null;
this.preOpenWaitlist = null;
this.premountSignInNodes = /* @__PURE__ */ new Map();
this.premountSignUpNodes = /* @__PURE__ */ new Map();
this.premountUserProfileNodes = /* @__PURE__ */ new Map();
this.premountUserButtonNodes = /* @__PURE__ */ new Map();
this.premountOrganizationProfileNodes = /* @__PURE__ */ new Map();
this.premountCreateOrganizationNodes = /* @__PURE__ */ new Map();
this.premountOrganizationSwitcherNodes = /* @__PURE__ */ new Map();
this.premountOrganizationListNodes = /* @__PURE__ */ new Map();
this.premountMethodCalls = /* @__PURE__ */ new Map();
this.premountWaitlistNodes = /* @__PURE__ */ new Map();
this.premountPricingTableNodes = /* @__PURE__ */ new Map();
this.premountAddListenerCalls = /* @__PURE__ */ new Map();
this.loadedListeners = [];
__privateAdd2(this, _loaded, false);
__privateAdd2(this, _domain);
__privateAdd2(this, _proxyUrl);
__privateAdd2(this, _publishableKey);
this.buildSignInUrl = (opts) => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildSignInUrl(opts)) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildSignInUrl", callback);
}
};
this.buildSignUpUrl = (opts) => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildSignUpUrl(opts)) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildSignUpUrl", callback);
}
};
this.buildAfterSignInUrl = (...args) => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildAfterSignInUrl(...args)) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildAfterSignInUrl", callback);
}
};
this.buildAfterSignUpUrl = (...args) => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildAfterSignUpUrl(...args)) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildAfterSignUpUrl", callback);
}
};
this.buildAfterSignOutUrl = () => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildAfterSignOutUrl()) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildAfterSignOutUrl", callback);
}
};
this.buildAfterMultiSessionSingleSignOutUrl = () => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildAfterMultiSessionSingleSignOutUrl()) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildAfterMultiSessionSingleSignOutUrl", callback);
}
};
this.buildUserProfileUrl = () => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildUserProfileUrl()) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildUserProfileUrl", callback);
}
};
this.buildCreateOrganizationUrl = () => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildCreateOrganizationUrl()) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildCreateOrganizationUrl", callback);
}
};
this.buildOrganizationProfileUrl = () => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildOrganizationProfileUrl()) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildOrganizationProfileUrl", callback);
}
};
this.buildWaitlistUrl = () => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildWaitlistUrl()) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildWaitlistUrl", callback);
}
};
this.buildUrlWithAuth = (to) => {
const callback = () => {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.buildUrlWithAuth(to)) || "";
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("buildUrlWithAuth", callback);
}
};
this.handleUnauthenticated = async () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.handleUnauthenticated();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
void callback();
} else {
this.premountMethodCalls.set("handleUnauthenticated", callback);
}
};
this.addOnLoaded = (cb) => {
this.loadedListeners.push(cb);
if (this.loaded) {
this.emitLoaded();
}
};
this.emitLoaded = () => {
this.loadedListeners.forEach((cb) => cb());
this.loadedListeners = [];
};
this.hydrateClerkJS = (clerkjs) => {
if (!clerkjs) {
throw new Error("Failed to hydrate latest Clerk JS");
}
this.clerkjs = clerkjs;
this.premountMethodCalls.forEach((cb) => cb());
this.premountAddListenerCalls.forEach((listenerHandlers, listener) => {
listenerHandlers.nativeUnsubscribe = clerkjs.addListener(listener);
});
if (this.preopenSignIn !== null) {
clerkjs.openSignIn(this.preopenSignIn);
}
if (this.preopenSignUp !== null) {
clerkjs.openSignUp(this.preopenSignUp);
}
if (this.preopenUserProfile !== null) {
clerkjs.openUserProfile(this.preopenUserProfile);
}
if (this.preopenUserVerification !== null) {
clerkjs.__internal_openReverification(this.preopenUserVerification);
}
if (this.preopenOneTap !== null) {
clerkjs.openGoogleOneTap(this.preopenOneTap);
}
if (this.preopenOrganizationProfile !== null) {
clerkjs.openOrganizationProfile(this.preopenOrganizationProfile);
}
if (this.preopenCreateOrganization !== null) {
clerkjs.openCreateOrganization(this.preopenCreateOrganization);
}
if (this.preOpenWaitlist !== null) {
clerkjs.openWaitlist(this.preOpenWaitlist);
}
this.premountSignInNodes.forEach((props, node) => {
clerkjs.mountSignIn(node, props);
});
this.premountSignUpNodes.forEach((props, node) => {
clerkjs.mountSignUp(node, props);
});
this.premountUserProfileNodes.forEach((props, node) => {
clerkjs.mountUserProfile(node, props);
});
this.premountUserButtonNodes.forEach((props, node) => {
clerkjs.mountUserButton(node, props);
});
this.premountOrganizationListNodes.forEach((props, node) => {
clerkjs.mountOrganizationList(node, props);
});
this.premountWaitlistNodes.forEach((props, node) => {
clerkjs.mountWaitlist(node, props);
});
this.premountPricingTableNodes.forEach((props, node) => {
clerkjs.__experimental_mountPricingTable(node, props);
});
__privateSet2(this, _loaded, true);
this.emitLoaded();
return this.clerkjs;
};
this.__unstable__updateProps = async (props) => {
const clerkjs = await __privateMethod2(this, _IsomorphicClerk_instances, waitForClerkJS_fn).call(this);
if (clerkjs && "__unstable__updateProps" in clerkjs) {
return clerkjs.__unstable__updateProps(props);
}
};
this.__experimental_nextTask = async (params) => {
if (this.clerkjs) {
return this.clerkjs.__experimental_nextTask(params);
} else {
return Promise.reject();
}
};
this.setActive = (params) => {
if (this.clerkjs) {
return this.clerkjs.setActive(params);
} else {
return Promise.reject();
}
};
this.openSignIn = (props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.openSignIn(props);
} else {
this.preopenSignIn = props;
}
};
this.closeSignIn = () => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.closeSignIn();
} else {
this.preopenSignIn = null;
}
};
this.__internal_openReverification = (props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.__internal_openReverification(props);
} else {
this.preopenUserVerification = props;
}
};
this.__internal_closeReverification = () => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.__internal_closeReverification();
} else {
this.preopenUserVerification = null;
}
};
this.openGoogleOneTap = (props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.openGoogleOneTap(props);
} else {
this.preopenOneTap = props;
}
};
this.closeGoogleOneTap = () => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.closeGoogleOneTap();
} else {
this.preopenOneTap = null;
}
};
this.openUserProfile = (props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.openUserProfile(props);
} else {
this.preopenUserProfile = props;
}
};
this.closeUserProfile = () => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.closeUserProfile();
} else {
this.preopenUserProfile = null;
}
};
this.openOrganizationProfile = (props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.openOrganizationProfile(props);
} else {
this.preopenOrganizationProfile = props;
}
};
this.closeOrganizationProfile = () => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.closeOrganizationProfile();
} else {
this.preopenOrganizationProfile = null;
}
};
this.openCreateOrganization = (props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.openCreateOrganization(props);
} else {
this.preopenCreateOrganization = props;
}
};
this.closeCreateOrganization = () => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.closeCreateOrganization();
} else {
this.preopenCreateOrganization = null;
}
};
this.openWaitlist = (props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.openWaitlist(props);
} else {
this.preOpenWaitlist = props;
}
};
this.closeWaitlist = () => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.closeWaitlist();
} else {
this.preOpenWaitlist = null;
}
};
this.openSignUp = (props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.openSignUp(props);
} else {
this.preopenSignUp = props;
}
};
this.closeSignUp = () => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.closeSignUp();
} else {
this.preopenSignUp = null;
}
};
this.mountSignIn = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountSignIn(node, props);
} else {
this.premountSignInNodes.set(node, props);
}
};
this.unmountSignIn = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountSignIn(node);
} else {
this.premountSignInNodes.delete(node);
}
};
this.__experimental_mountPricingTable = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.__experimental_mountPricingTable(node, props);
} else {
this.premountPricingTableNodes.set(node, props);
}
};
this.__experimental_unmountPricingTable = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.__experimental_unmountPricingTable(node);
} else {
this.premountPricingTableNodes.delete(node);
}
};
this.mountSignUp = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountSignUp(node, props);
} else {
this.premountSignUpNodes.set(node, props);
}
};
this.unmountSignUp = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountSignUp(node);
} else {
this.premountSignUpNodes.delete(node);
}
};
this.mountUserProfile = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountUserProfile(node, props);
} else {
this.premountUserProfileNodes.set(node, props);
}
};
this.unmountUserProfile = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountUserProfile(node);
} else {
this.premountUserProfileNodes.delete(node);
}
};
this.mountOrganizationProfile = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountOrganizationProfile(node, props);
} else {
this.premountOrganizationProfileNodes.set(node, props);
}
};
this.unmountOrganizationProfile = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountOrganizationProfile(node);
} else {
this.premountOrganizationProfileNodes.delete(node);
}
};
this.mountCreateOrganization = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountCreateOrganization(node, props);
} else {
this.premountCreateOrganizationNodes.set(node, props);
}
};
this.unmountCreateOrganization = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountCreateOrganization(node);
} else {
this.premountCreateOrganizationNodes.delete(node);
}
};
this.mountOrganizationSwitcher = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountOrganizationSwitcher(node, props);
} else {
this.premountOrganizationSwitcherNodes.set(node, props);
}
};
this.unmountOrganizationSwitcher = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountOrganizationSwitcher(node);
} else {
this.premountOrganizationSwitcherNodes.delete(node);
}
};
this.__experimental_prefetchOrganizationSwitcher = () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.__experimental_prefetchOrganizationSwitcher();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
void callback();
} else {
this.premountMethodCalls.set("__experimental_prefetchOrganizationSwitcher", callback);
}
};
this.mountOrganizationList = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountOrganizationList(node, props);
} else {
this.premountOrganizationListNodes.set(node, props);
}
};
this.unmountOrganizationList = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountOrganizationList(node);
} else {
this.premountOrganizationListNodes.delete(node);
}
};
this.mountUserButton = (node, userButtonProps) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountUserButton(node, userButtonProps);
} else {
this.premountUserButtonNodes.set(node, userButtonProps);
}
};
this.unmountUserButton = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountUserButton(node);
} else {
this.premountUserButtonNodes.delete(node);
}
};
this.mountWaitlist = (node, props) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.mountWaitlist(node, props);
} else {
this.premountWaitlistNodes.set(node, props);
}
};
this.unmountWaitlist = (node) => {
if (this.clerkjs && __privateGet2(this, _loaded)) {
this.clerkjs.unmountWaitlist(node);
} else {
this.premountWaitlistNodes.delete(node);
}
};
this.addListener = (listener) => {
if (this.clerkjs) {
return this.clerkjs.addListener(listener);
} else {
const unsubscribe = () => {
var _a;
const listenerHandlers = this.premountAddListenerCalls.get(listener);
if (listenerHandlers) {
(_a = listenerHandlers.nativeUnsubscribe) == null ? void 0 : _a.call(listenerHandlers);
this.premountAddListenerCalls.delete(listener);
}
};
this.premountAddListenerCalls.set(listener, { unsubscribe, nativeUnsubscribe: void 0 });
return unsubscribe;
}
};
this.navigate = (to) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.navigate(to);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
void callback();
} else {
this.premountMethodCalls.set("navigate", callback);
}
};
this.redirectWithAuth = async (...args) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectWithAuth(...args);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("redirectWithAuth", callback);
return;
}
};
this.redirectToSignIn = async (opts) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToSignIn(opts);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("redirectToSignIn", callback);
return;
}
};
this.redirectToSignUp = async (opts) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToSignUp(opts);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("redirectToSignUp", callback);
return;
}
};
this.redirectToUserProfile = async () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToUserProfile();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("redirectToUserProfile", callback);
return;
}
};
this.redirectToAfterSignUp = () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToAfterSignUp();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("redirectToAfterSignUp", callback);
}
};
this.redirectToAfterSignIn = () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToAfterSignIn();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
callback();
} else {
this.premountMethodCalls.set("redirectToAfterSignIn", callback);
}
};
this.redirectToAfterSignOut = () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToAfterSignOut();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
callback();
} else {
this.premountMethodCalls.set("redirectToAfterSignOut", callback);
}
};
this.redirectToOrganizationProfile = async () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToOrganizationProfile();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("redirectToOrganizationProfile", callback);
return;
}
};
this.redirectToCreateOrganization = async () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToCreateOrganization();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("redirectToCreateOrganization", callback);
return;
}
};
this.redirectToWaitlist = async () => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.redirectToWaitlist();
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("redirectToWaitlist", callback);
return;
}
};
this.handleRedirectCallback = async (params) => {
var _a;
const callback = () => {
var _a2;
return (_a2 = this.clerkjs) == null ? void 0 : _a2.handleRedirectCallback(params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
void ((_a = callback()) == null ? void 0 : _a.catch(() => {
}));
} else {
this.premountMethodCalls.set("handleRedirectCallback", callback);
}
};
this.handleGoogleOneTapCallback = async (signInOrUp, params) => {
var _a;
const callback = () => {
var _a2;
return (_a2 = this.clerkjs) == null ? void 0 : _a2.handleGoogleOneTapCallback(signInOrUp, params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
void ((_a = callback()) == null ? void 0 : _a.catch(() => {
}));
} else {
this.premountMethodCalls.set("handleGoogleOneTapCallback", callback);
}
};
this.handleEmailLinkVerification = async (params) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.handleEmailLinkVerification(params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("handleEmailLinkVerification", callback);
}
};
this.authenticateWithMetamask = async (params) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.authenticateWithMetamask(params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("authenticateWithMetamask", callback);
}
};
this.authenticateWithCoinbaseWallet = async (params) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.authenticateWithCoinbaseWallet(params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("authenticateWithCoinbaseWallet", callback);
}
};
this.authenticateWithOKXWallet = async (params) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.authenticateWithOKXWallet(params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("authenticateWithOKXWallet", callback);
}
};
this.authenticateWithWeb3 = async (params) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.authenticateWithWeb3(params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("authenticateWithWeb3", callback);
}
};
this.authenticateWithGoogleOneTap = async (params) => {
const clerkjs = await __privateMethod2(this, _IsomorphicClerk_instances, waitForClerkJS_fn).call(this);
return clerkjs.authenticateWithGoogleOneTap(params);
};
this.createOrganization = async (params) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.createOrganization(params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("createOrganization", callback);
}
};
this.getOrganization = async (organizationId) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.getOrganization(organizationId);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("getOrganization", callback);
}
};
this.joinWaitlist = async (params) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.joinWaitlist(params);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("joinWaitlist", callback);
}
};
this.signOut = async (...args) => {
const callback = () => {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.signOut(...args);
};
if (this.clerkjs && __privateGet2(this, _loaded)) {
return callback();
} else {
this.premountMethodCalls.set("signOut", callback);
}
};
const { Clerk = null, publishableKey } = options || {};
__privateSet2(this, _publishableKey, publishableKey);
__privateSet2(this, _proxyUrl, options == null ? void 0 : options.proxyUrl);
__privateSet2(this, _domain, options == null ? void 0 : options.domain);
this.options = options;
this.Clerk = Clerk;
this.mode = inBrowser() ? "browser" : "server";
if (!this.options.sdkMetadata) {
this.options.sdkMetadata = SDK_METADATA;
}
if (__privateGet2(this, _publishableKey)) {
void this.loadClerkJS();
}
}
get publishableKey() {
return __privateGet2(this, _publishableKey);
}
get loaded() {
return __privateGet2(this, _loaded);
}
static getOrCreateInstance(options) {
if (!inBrowser() || !__privateGet2(this, _instance) || options.Clerk && __privateGet2(this, _instance).Clerk !== options.Clerk || // Allow hot swapping PKs on the client
__privateGet2(this, _instance).publishableKey !== options.publishableKey) {
__privateSet2(this, _instance, new _IsomorphicClerk2(options));
}
return __privateGet2(this, _instance);
}
static clearInstance() {
__privateSet2(this, _instance, null);
}
get domain() {
if (typeof window !== "undefined" && window.location) {
return handleValueOrFn(__privateGet2(this, _domain), new URL(window.location.href), "");
}
if (typeof __privateGet2(this, _domain) === "function") {
return errorThrower.throw(unsupportedNonBrowserDomainOrProxyUrlFunction);
}
return __privateGet2(this, _domain) || "";
}
get proxyUrl() {
if (typeof window !== "undefined" && window.location) {
return handleValueOrFn(__privateGet2(this, _proxyUrl), new URL(window.location.href), "");
}
if (typeof __privateGet2(this, _proxyUrl) === "function") {
return errorThrower.throw(unsupportedNonBrowserDomainOrProxyUrlFunction);
}
return __privateGet2(this, _proxyUrl) || "";
}
__internal_getOption(key) {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.__internal_getOption(key);
}
get sdkMetadata() {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.sdkMetadata) || this.options.sdkMetadata || void 0;
}
get instanceType() {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.instanceType;
}
get frontendApi() {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.frontendApi) || "";
}
get isStandardBrowser() {
var _a;
return ((_a = this.clerkjs) == null ? void 0 : _a.isStandardBrowser) || this.options.standardBrowser || false;
}
get isSatellite() {
if (typeof window !== "undefined" && window.location) {
return handleValueOrFn(this.options.isSatellite, new URL(window.location.href), false);
}
if (typeof this.options.isSatellite === "function") {
return errorThrower.throw(unsupportedNonBrowserDomainOrProxyUrlFunction);
}
return false;
}
async loadClerkJS() {
var _a;
if (this.mode !== "browser" || __privateGet2(this, _loaded)) {
return;
}
if (typeof window !== "undefined") {
window.__clerk_publishable_key = __privateGet2(this, _publishableKey);
window.__clerk_proxy_url = this.proxyUrl;
window.__clerk_domain = this.domain;
}
try {
if (this.Clerk) {
let c;
if (isConstructor(this.Clerk)) {
c = new this.Clerk(__privateGet2(this, _publishableKey), {
proxyUrl: this.proxyUrl,
domain: this.domain
});
await c.load(this.options);
} else {
c = this.Clerk;
if (!c.loaded) {
await c.load(this.options);
}
}
global.Clerk = c;
} else if (false) ;
if ((_a = global.Clerk) == null ? void 0 : _a.loaded) {
return this.hydrateClerkJS(global.Clerk);
}
return;
} catch (err) {
const error = err;
if (process.env.NODE_ENV === "production") {
console.error(error.stack || error.message || error);
} else {
throw err;
}
return;
}
}
get version() {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.version;
}
get client() {
if (this.clerkjs) {
return this.clerkjs.client;
} else {
return void 0;
}
}
get session() {
if (this.clerkjs) {
return this.clerkjs.session;
} else {
return void 0;
}
}
get user() {
if (this.clerkjs) {
return this.clerkjs.user;
} else {
return void 0;
}
}
get organization() {
if (this.clerkjs) {
return this.clerkjs.organization;
} else {
return void 0;
}
}
get telemetry() {
if (this.clerkjs) {
return this.clerkjs.telemetry;
} else {
return void 0;
}
}
get __unstable__environment() {
if (this.clerkjs) {
return this.clerkjs.__unstable__environment;
} else {
return void 0;
}
}
get isSignedIn() {
if (this.clerkjs) {
return this.clerkjs.isSignedIn;
} else {
return false;
}
}
get __experimental_commerce() {
var _a;
return (_a = this.clerkjs) == null ? void 0 : _a.__experimental_commerce;
}
__unstable__setEnvironment(...args) {
if (this.clerkjs && "__unstable__setEnvironment" in this.clerkjs) {
this.clerkjs.__unstable__setEnvironment(args);
} else {
return void 0;
}
}
};
_loaded = /* @__PURE__ */ new WeakMap();
_domain = /* @__PURE__ */ new WeakMap();
_proxyUrl = /* @__PURE__ */ new WeakMap();
_publishableKey = /* @__PURE__ */ new WeakMap();
_instance = /* @__PURE__ */ new WeakMap();
_IsomorphicClerk_instances = /* @__PURE__ */ new WeakSet();
waitForClerkJS_fn = function() {
return new Promise((resolve) => {
this.addOnLoaded(() => resolve(this.clerkjs));
});
};
__privateAdd2(_IsomorphicClerk, _instance);
var IsomorphicClerk = _IsomorphicClerk;
function ClerkContextProvider(props) {
const { isomorphicClerkOptions, initialState, children } = props;
const { isomorphicClerk: clerk, loaded: clerkLoaded2 } = useLoadedIsomorphicClerk(isomorphicClerkOptions);
const [state, setState] = React8.useState({
client: clerk.client,
session: clerk.session,
user: clerk.user,
organization: clerk.organization
});
React8.useEffect(() => {
return clerk.addListener((e) => setState({ ...e }));
}, []);
const derivedState = deriveState(clerkLoaded2, state, initialState);
const clerkCtx = React8.useMemo(() => ({ value: clerk }), [clerkLoaded2]);
const clientCtx = React8.useMemo(() => ({ value: state.client }), [state.client]);
const {
sessionId,
sessionStatus,
session,
userId,
user,
orgId,
actor,
organization,
orgRole,
orgSlug,
orgPermissions,
factorVerificationAge
} = derivedState;
const authCtx = React8.useMemo(() => {
const value = {
sessionId,
sessionStatus,
userId,
actor,
orgId,
orgRole,
orgSlug,
orgPermissions,
factorVerificationAge
};
return { value };
}, [sessionId, sessionStatus, userId, actor, orgId, orgRole, orgSlug, factorVerificationAge]);
const sessionCtx = React8.useMemo(() => ({ value: session }), [sessionId, session]);
const userCtx = React8.useMemo(() => ({ value: user }), [userId, user]);
const organizationCtx = React8.useMemo(() => {
const value = {
organization
};
return { value };
}, [orgId, organization]);
return (
// @ts-expect-error value passed is of type IsomorphicClerk where the context expects LoadedClerk
/* @__PURE__ */ React8.createElement(IsomorphicClerkContext.Provider, { value: clerkCtx }, /* @__PURE__ */ React8.createElement(ClientContext.Provider, { value: clientCtx }, /* @__PURE__ */ React8.createElement(SessionContext.Provider, { value: sessionCtx }, /* @__PURE__ */ React8.createElement(OrganizationProvider, { ...organizationCtx.value }, /* @__PURE__ */ React8.createElement(AuthContext.Provider, { value: authCtx }, /* @__PURE__ */ React8.createElement(UserContext.Provider, { value: userCtx }, children))))))
);
}
var useLoadedIsomorphicClerk = (options) => {
const [loaded, setLoaded] = React8.useState(false);
const isomorphicClerk = React8.useMemo(() => IsomorphicClerk.getOrCreateInstance(options), []);
React8.useEffect(() => {
void isomorphicClerk.__unstable__updateProps({ appearance: options.appearance });
}, [options.appearance]);
React8.useEffect(() => {
void isomorphicClerk.__unstable__updateProps({ options });
}, [options.localization]);
React8.useEffect(() => {
isomorphicClerk.addOnLoaded(() => setLoaded(true));
}, []);
React8.useEffect(() => {
return () => {
IsomorphicClerk.clearInstance();
setLoaded(false);
};
}, []);
return { isomorphicClerk, loaded };
};
function ClerkProviderBase(props) {
const { initialState, children, __internal_bypassMissingPublishableKey, ...restIsomorphicClerkOptions } = props;
const { publishableKey = "", Clerk: userInitialisedClerk } = restIsomorphicClerkOptions;
if (!userInitialisedClerk && !__internal_bypassMissingPublishableKey) {
if (!publishableKey) {
errorThrower.throwMissingPublishableKeyError();
} else if (publishableKey && !isPublishableKey(publishableKey)) {
errorThrower.throwInvalidPublishableKeyError({ key: publishableKey });
}
}
return /* @__PURE__ */ React8.createElement(
ClerkContextProvider,
{
initialState,
isomorphicClerkOptions: restIsomorphicClerkOptions
},
children
);
}
var ClerkProvider = withMaxAllowedInstancesGuard(ClerkProviderBase, "ClerkProvider", multipleClerkProvidersError);
ClerkProvider.displayName = "ClerkProvider";
setErrorThrowerOptions({ packageName: "@clerk/clerk-react" });
setClerkJsLoadingErrorPackageName("@clerk/clerk-react");
function ClerkProvider2(props) {
const { children, storageCache, syncHost, __experimental_syncHostListener, ...rest } = props;
const { publishableKey = "" } = props;
const [clerkInstance, setClerkInstance] = React8.useState(null);
React8.useEffect(() => {
void (async () => {
setClerkInstance(
await createClerkClient({ publishableKey, storageCache, syncHost, __experimental_syncHostListener })
);
})();
}, [publishableKey, storageCache, syncHost, __experimental_syncHostListener]);
if (!clerkInstance) {
return null;
}
return /* @__PURE__ */ jsx(
ClerkProvider,
{
...rest,
Clerk: clerkInstance,
standardBrowser: !syncHost,
children
}
);
}
export { AuthenticateWithRedirectCallback, ClerkLoaded, ClerkLoading, ClerkProvider2 as ClerkProvider, CreateOrganization, GoogleOneTap, OrganizationList, OrganizationProfile, OrganizationSwitcher, Protect, RedirectToCreateOrganization, RedirectToOrganizationProfile, RedirectToSignIn, RedirectToSignUp, RedirectToUserProfile, SignIn, SignInButton, SignInWithMetamaskButton, SignOutButton, SignUp, SignUpButton, SignedIn, SignedOut, UserButton, UserProfile, Waitlist, setErrorThrowerOptions, useAuth, useClerk, useEmailLink, useOrganization, useOrganizationList, useReverification, useSession, useSessionList, useSignIn, useSignUp, useUser };
//# sourceMappingURL=chunk-U22VNNCY.js.map
//# sourceMappingURL=chunk-U22VNNCY.js.map