@multiplatform.one/keycloak 7.6.2 → 7.7.0

package/dist/cjs/index.native.cjs

@@ -58,8 +58,128 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// ../platform/src/platform/platformBase.ts
+var import_constants = require("@tamagui/constants");
+var platformOrder = [
+  "Ios",
+  "Android",
+  // Gnome outranks Native: the GTK target reports isNative (it is not a
+  // browser) but "gnome" is the precise answer callers want.
+  "Gnome",
+  "Native",
+  // Tauri outranks Desktop/Web the same way: the webview host reports isWeb
+  // and isDesktop, but "tauri" is the precise answer.
+  "Tauri",
+  "Desktop",
+  "ChromeExtension",
+  "FirefoxExtension",
+  "WebExtension",
+  "Next",
+  "Expo",
+  "Chrome",
+  "Firefox",
+  "Web",
+  "Browser",
+  "Client",
+  "Server",
+  "Iframe",
+  "Storybook"
+];
+var platformBase = {
+  isAndroid: false,
+  isBrowser: false,
+  isChrome: import_constants.isChrome,
+  isChromeExtension: false,
+  isClient: import_constants.isClient,
+  isDesktop: false,
+  isExpo: false,
+  isFirefox: false,
+  isFirefoxExtension: false,
+  isGnome: false,
+  isIframe: false,
+  isIos: false,
+  isNative: false,
+  isNext: false,
+  isServer: import_constants.isServer,
+  isStorybook: import_constants.isWindowDefined && typeof window.__STORYBOOK_ADDONS_PREVIEW === "object",
+  isTauri: false,
+  isTouchable: import_constants.isTouchable,
+  isWeb: import_constants.isWeb,
+  isWebExtension: false,
+  isWebTouchable: import_constants.isWebTouchable,
+  isWindowDefined: import_constants.isWindowDefined,
+  preciseName: "unknown",
+  broadName: "unknown"
+};
+function getPreciseName(platform2) {
+  const flags = platform2;
+  for (const name of platformOrder) {
+    if (flags[`is${name}`]) {
+      return `${name[0].toLowerCase()}${name.slice(1)}`;
+    }
+  }
+  return "unknown";
+}
+function getBroadName(platform2) {
+  const flags = platform2;
+  for (const name of platformOrder.slice().reverse()) {
+    if (flags[`is${name}`]) {
+      return `${name[0].toLowerCase()}${name.slice(1)}`;
+    }
+  }
+  return "unknown";
+}
+
+// ../platform/src/platform/index.ts
+var isIframe = (() => {
+  if (!platformBase.isWindowDefined) return false;
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+})();
+var isWebExtension = !!(typeof chrome !== "undefined" && !!chrome?.runtime?.id || typeof browser !== "undefined" && !!browser?.runtime?.id);
+var platform = {
+  ...platformBase,
+  isChromeExtension: typeof chrome !== "undefined" && !!chrome?.runtime?.id,
+  isFirefoxExtension: typeof browser !== "undefined" && !!browser?.runtime?.id,
+  isIframe,
+  isWebExtension,
+  isBrowser: !!(platformBase.isWeb && platformBase.isWindowDefined && !isWebExtension),
+  isNext: platformBase.isWeb && (!platformBase.isWindowDefined || typeof window.__NEXT_DATA__ === "object"),
+  isFirefox: platformBase.isWindowDefined && !!(window?.navigator?.userAgent?.toLowerCase().indexOf("firefox") > -1)
+};
+platform.preciseName = getPreciseName(platform);
+platform.broadName = getBroadName(platform);
+
+// ../platform/src/index.ts
+var {
+  isAndroid,
+  isBrowser,
+  isChrome: isChrome2,
+  isChromeExtension,
+  isClient: isClient2,
+  isExpo,
+  isFirefox,
+  isFirefoxExtension,
+  isGnome,
+  isIframe: isIframe2,
+  isIos,
+  isNative,
+  isNext,
+  isServer: isServer2,
+  isStorybook,
+  isTauri,
+  isDesktop,
+  isTouchable: isTouchable2,
+  isWeb: isWeb2,
+  isWebExtension: isWebExtension2,
+  isWebTouchable: isWebTouchable2,
+  isWindowDefined: isWindowDefined2
+} = platform;
+
 // src/Authenticated.tsx
-var import_platform3 = require("@multiplatform.one/platform");
 var import_react7 = require("react");
 var import_react_native = require("react-native");
 
@@ -79,16 +199,155 @@ function useAuthConfig() {
 // src/hooks/useTokensFromQuery/index.native.ts
 var useTokensFromQuery = () => false;
 
+// ../store/src/createStore.ts
+var import_store2 = require("@tanstack/store");
+
+// ../store/src/persist.ts
+var import_store = require("@tanstack/store");
+function createPersistStore(initialState, persistOptions) {
+  const { key, storage: storage2, serialize = JSON.stringify, deserialize = JSON.parse } = persistOptions;
+  let hydrated = false;
+  const store = new import_store.Store(initialState);
+  store.subscribe(() => {
+    if (hydrated) {
+      const serialized = serialize(store.state);
+      void Promise.resolve(storage2.setItem(key, serialized));
+    }
+  });
+  const rehydrate = async () => {
+    const raw = await Promise.resolve(storage2.getItem(key));
+    if (raw !== null) {
+      const deserialized = deserialize(raw);
+      store.setState(() => deserialized);
+    }
+    hydrated = true;
+  };
+  const clearPersistedState = async () => {
+    await Promise.resolve(storage2.removeItem(key));
+  };
+  void rehydrate();
+  const persistStore = store;
+  persistStore.rehydrate = rehydrate;
+  persistStore.clearPersistedState = clearPersistedState;
+  return persistStore;
+}
+
+// ../store/src/storage/index.native.ts
+var defaultLoaders = {
+  // Literal require(...) calls on purpose: metro resolves them natively and
+  // vxrn/rolldown rewrites literal requires into bundled module inits (a
+  // passed-around `require` reference would survive as a bare identifier and
+  // crash). Lazy so a genuinely missing native module throws HERE — inside
+  // the try/catch — instead of at bundle evaluation.
+  loadMMKV: () => require("react-native-mmkv"),
+  loadAsyncStorage: () => require("@react-native-async-storage/async-storage")
+};
+function resolveNativeStorage(loaders = defaultLoaders) {
+  const errors = {};
+  try {
+    const mmkvModule = loaders.loadMMKV();
+    if (typeof mmkvModule?.createMMKV !== "function") {
+      throw new Error("no createMMKV() export (react-native-mmkv v4 API expected)");
+    }
+    const mmkv = mmkvModule.createMMKV();
+    return {
+      backend: "mmkv",
+      errors,
+      storage: {
+        getItem: (name) => mmkv.getString(name) ?? null,
+        setItem: (name, value) => {
+          mmkv.set(name, value);
+        },
+        removeItem: (name) => {
+          mmkv.remove(name);
+        }
+      }
+    };
+  } catch (err) {
+    errors.mmkv = err;
+  }
+  try {
+    const asyncStorageModule = loaders.loadAsyncStorage();
+    const asyncStorage = asyncStorageModule?.default;
+    if (!asyncStorage || typeof asyncStorage.getItem !== "function") {
+      throw new Error("no usable default export on @react-native-async-storage/async-storage");
+    }
+    return {
+      backend: "async-storage",
+      errors,
+      storage: {
+        getItem: (name) => asyncStorage.getItem(name),
+        setItem: (name, value) => asyncStorage.setItem(name, value),
+        removeItem: (name) => asyncStorage.removeItem(name)
+      }
+    };
+  } catch (err) {
+    errors.asyncStorage = err;
+  }
+  const map = /* @__PURE__ */ new Map();
+  return {
+    backend: "memory",
+    errors,
+    storage: {
+      getItem: (name) => map.get(name) ?? null,
+      setItem: (name, value) => {
+        map.set(name, value);
+      },
+      removeItem: (name) => {
+        map.delete(name);
+      }
+    }
+  };
+}
+function describeError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function logNativeStorageResolution(resolution2, logger2 = console) {
+  if (resolution2.backend === "mmkv") {
+    logger2.info("[@multiplatform.one/store] native storage backend: mmkv");
+    return;
+  }
+  const causes = [`react-native-mmkv unavailable: ${describeError(resolution2.errors.mmkv)}`];
+  if (resolution2.backend === "memory") {
+    causes.push(`async-storage unavailable: ${describeError(resolution2.errors.asyncStorage)}`);
+  }
+  logger2.warn(
+    `[@multiplatform.one/store] native storage fell back to ${resolution2.backend}` + (resolution2.backend === "memory" ? " \u2014 persisted state will NOT survive app restarts" : "") + ` (${causes.join("; ")})`
+  );
+}
+var resolution = resolveNativeStorage();
+if (process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test") {
+  logNativeStorageResolution(resolution);
+}
+var storage = resolution.storage;
+
+// ../store/src/createStore.ts
+function createStore(initialState, options) {
+  if (options?.persist) {
+    return createPersistStore(initialState, {
+      key: options.name,
+      storage: options.storage ?? storage
+    });
+  }
+  return new import_store2.Store(initialState);
+}
+
+// ../store/src/index.ts
+var import_store3 = require("@tanstack/store");
+var import_react_store = require("@tanstack/react-store");
+var import_react_store2 = require("@tanstack/react-store");
+function useStore2(store, selector) {
+  return (0, import_react_store2.useStore)(store, selector ?? ((s) => s));
+}
+
 // src/state.ts
-var import_store = require("@multiplatform.one/store");
-var import_platform = require("@multiplatform.one/platform");
-var persist = import_platform.isIframe || !import_platform.isBrowser && !import_platform.isServer;
-var authStore = (0, import_store.createStore)(
+var persist = isIframe2 || !isBrowser && !isServer2;
+var authStore = createStore(
   { idToken: "", refreshToken: "", token: "" },
   { name: "auth", persist }
 );
 function useAuthStore() {
-  const state2 = (0, import_store.useStore)(authStore);
+  const state2 = useStore2(authStore);
   return {
     ...state2,
     setIdToken: (idToken) => authStore.setState((prev) => ({ ...prev, idToken })),
@@ -151,7 +410,6 @@ function useTokensFromStore() {
 }
 
 // src/keycloak/index.native.ts
-var import_platform2 = require("@multiplatform.one/platform");
 var import_react6 = require("react");
 
 // src/keycloak/base.ts
@@ -301,7 +559,7 @@ function useKeycloak() {
   const { disabled } = useAuthConfig();
   if (disabled) return null;
   if (keycloak) return keycloak;
-  if (import_platform2.isStorybook) {
+  if (isStorybook) {
     return new Keycloak(keycloakConfig, {
       email: "storybook@example.com",
       username: "storybook"
@@ -321,7 +579,7 @@ function Authenticated({
   const keycloak = useKeycloak();
   const tokensFromQuery = useTokensFromQuery();
   (0, import_react7.useEffect)(() => {
-    if (!keycloak || !authConfig.iframeSso && import_platform3.isIframe || import_platform3.isServer || keycloak.authenticated || tokensFromQuery) {
+    if (!keycloak || !authConfig.iframeSso && isIframe2 || isServer2 || keycloak.authenticated || tokensFromQuery) {
       return;
     }
     keycloak?.login({
@@ -342,8 +600,86 @@ function withAuthenticated(Component, options = {}) {
   return (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Authenticated, { ...options, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ...props }) });
 }
 
+// ../logger/src/base.ts
+var import_loglevel = __toESM(require("loglevel"));
+var defaultLoggerConfig = {
+  name: "default",
+  type: "pretty",
+  level: process.env.NODE_ENV === "development" ? 1 /* Debug */ : 2 /* Info */
+};
+var BaseLogger = class {
+  constructor(config = {}) {
+    const { metadata, name, level } = typeof config === "string" ? { metadata: void 0, name: config, level: void 0 } : config;
+    this.metadata = metadata || {};
+    this.name = name || "default";
+    this.logger = name ? import_loglevel.default.getLogger(name) : import_loglevel.default;
+    if (level !== void 0) this.logger.setLevel(level);
+    this.transport = this.createTransport?.();
+  }
+  trace(...args) {
+    this.logger.trace(...args);
+    this.sendToTransport(0 /* Trace */, args);
+  }
+  debug(...args) {
+    this.logger.debug(...args);
+    this.sendToTransport(1 /* Debug */, args);
+  }
+  info(...args) {
+    this.logger.info(...args);
+    this.sendToTransport(2 /* Info */, args);
+  }
+  warn(...args) {
+    this.logger.warn(...args);
+    this.sendToTransport(3 /* Warn */, args);
+  }
+  error(...args) {
+    this.logger.error(...args);
+    this.sendToTransport(4 /* Error */, args);
+  }
+  log(...args) {
+    this.logger.debug(...args);
+    this.sendToTransport(1 /* Debug */, args);
+  }
+  sendToTransport(level, args) {
+    if (this.transport) {
+      this.transport.send({
+        level,
+        message: args[0],
+        args: args.slice(1),
+        platform: platform.preciseName,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  getSubLogger(input) {
+    const subConfig = typeof input === "string" ? {
+      name: input,
+      metadata: this.metadata,
+      level: this.logger.getLevel()
+    } : {
+      ...input,
+      metadata: { ...this.metadata, ...input.metadata }
+    };
+    return new this.constructor(subConfig);
+  }
+};
+
+// ../logger/src/index.ts
+var Logger = class extends BaseLogger {
+  constructor(config = {}) {
+    const metadata = {
+      platform: platform.preciseName
+    };
+    super({
+      name: metadata.platform,
+      ...typeof config === "string" ? { name: config } : config,
+      metadata
+    });
+  }
+};
+var logger = new Logger();
+
 // src/provider/AfterAuth.tsx
-var import_logger = require("@multiplatform.one/logger");
 var import_react8 = require("react");
 
 // src/frappeToken.native.ts
@@ -354,6 +690,35 @@ var import_react_native2 = require("react-native");
 var Linking = __toESM(require("expo-linking"));
 var SecureStore = __toESM(require("expo-secure-store"));
 var WebBrowser = __toESM(require("expo-web-browser"));
+
+// src/betterAuth/accountSelection.ts
+var validationErrorCode = "VALIDATION_ERROR";
+var known;
+function currentSelection(userId) {
+  return userId ? { useAccountCookie: true, userId } : { useAccountCookie: true };
+}
+function legacySelection(providerId, userId) {
+  return userId ? { providerId, userId } : { providerId };
+}
+function isBodyRefusal(res) {
+  return res.status === 400 && res.body?.code === validationErrorCode;
+}
+async function requestAccessToken(providerId, send, userId) {
+  const current = () => currentSelection(userId);
+  const legacy = () => legacySelection(providerId, userId);
+  if (known === "legacy") return send(legacy());
+  if (known === "current") return send(current());
+  const first = await send(current());
+  if (!isBodyRefusal(first)) {
+    if (first.status !== 400) known = "current";
+    return first;
+  }
+  const second = await send(legacy());
+  if (!isBodyRefusal(second)) known = "legacy";
+  return second;
+}
+
+// src/betterAuth/expoAuthFlow.native.ts
 try {
   WebBrowser.maybeCompleteAuthSession?.();
 } catch {
@@ -567,12 +932,17 @@ function createExpoAuthFlow(baseURL, scheme) {
       return data && Object.keys(data).length ? data : null;
     },
     async getAccessToken(providerId) {
-      const res = await authFetch("/get-access-token", {
-        method: "POST",
-        body: JSON.stringify({ providerId })
+      let payload = null;
+      const res = await requestAccessToken(providerId, async (body) => {
+        const response = await authFetch("/get-access-token", {
+          method: "POST",
+          body: JSON.stringify(body)
+        });
+        payload = await response.json().catch(() => null);
+        return { status: response.status, body: payload };
       });
-      if (!res.ok) return null;
-      return await res.json().catch(() => null);
+      if (res.status < 200 || res.status >= 300) return null;
+      return payload;
     }
   };
   activeFlow = flow;
@@ -657,27 +1027,27 @@ function AfterAuth({ children, loadingComponent: _loadingComponent }) {
   ]);
   (0, import_react8.useEffect)(() => {
     if (authConfig.debug && keycloak?.token) {
-      import_logger.logger.debug("token", keycloak.token);
+      logger.debug("token", keycloak.token);
     }
   }, [authConfig.debug, keycloak?.token]);
   (0, import_react8.useEffect)(() => {
     if (authConfig.debug && keycloak?.idToken) {
-      import_logger.logger.debug("idToken", keycloak.idToken);
+      logger.debug("idToken", keycloak.idToken);
     }
   }, [authConfig.debug, keycloak?.idToken]);
   (0, import_react8.useEffect)(() => {
     if (authConfig.debug && keycloak?.refreshToken) {
-      import_logger.logger.debug("refreshToken", keycloak.refreshToken);
+      logger.debug("refreshToken", keycloak.refreshToken);
     }
   }, [authConfig.debug, keycloak?.refreshToken]);
   (0, import_react8.useEffect)(() => {
     if (authConfig.debug && keycloak?.authenticated) {
-      import_logger.logger.debug("authenticated", keycloak.authenticated);
+      logger.debug("authenticated", keycloak.authenticated);
     }
   }, [authConfig.debug, keycloak?.authenticated]);
   (0, import_react8.useEffect)(() => {
     if (authConfig.debug && keycloak === null) {
-      import_logger.logger.debug("keycloak disabled");
+      logger.debug("keycloak disabled");
     }
   }, [authConfig.debug, keycloak]);
   (0, import_react8.useEffect)(() => watchKeycloakBearerTokenRevalidate(), []);