better-auth-ui 3.2.5

package/dist/tanstack.js

@@ -0,0 +1,153 @@
+import {
+  AuthUIProvider
+} from "./chunk-BDFQSFBU.js";
+import "./chunk-MJPOA6PK.js";
+
+// src/lib/tanstack/auth-ui-provider-tanstack.tsx
+import { useCallback as useCallback2, useMemo as useMemo2 } from "react";
+
+// src/lib/tanstack/use-tanstack-options.ts
+import {
+  AuthQueryContext,
+  createAuthHooks
+} from "@daveyplate/better-auth-tanstack";
+import { useIsRestoring, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useContext, useMemo } from "react";
+function useTanstackOptions({
+  authClient
+}) {
+  const {
+    useUnlinkAccount,
+    useUpdateUser,
+    useDeletePasskey,
+    useRevokeSession,
+    useRevokeDeviceSession,
+    useSetActiveSession
+  } = createAuthHooks(authClient);
+  const queryClient = useQueryClient();
+  const { mutateAsync: updateUserAsync } = useUpdateUser();
+  const { mutateAsync: deletePasskeyAsync } = useDeletePasskey();
+  const { mutateAsync: unlinkAccountAsync } = useUnlinkAccount();
+  const { mutateAsync: revokeSessionAsync } = useRevokeSession();
+  const { mutateAsync: revokeDeviceSessionAsync } = useRevokeDeviceSession();
+  const { setActiveSessionAsync } = useSetActiveSession();
+  const { sessionKey } = useContext(AuthQueryContext);
+  const hooks = useMemo(
+    () => ({
+      ...createAuthHooks(authClient),
+      useIsRestoring
+    }),
+    [authClient]
+  );
+  const mutators = useMemo(
+    () => ({
+      updateUser: async (params) => {
+        const { error } = await updateUserAsync({
+          ...params,
+          fetchOptions: { throw: false }
+        });
+        if (error) throw error;
+      },
+      unlinkAccount: async (params) => {
+        const { error } = await unlinkAccountAsync({
+          ...params,
+          fetchOptions: { throw: false }
+        });
+        if (error) throw error;
+      },
+      deletePasskey: async (params) => {
+        const { error } = await deletePasskeyAsync({
+          ...params,
+          fetchOptions: { throw: false }
+        });
+        if (error) throw error;
+      },
+      revokeSession: async (params) => {
+        const { error } = await revokeSessionAsync({
+          ...params,
+          fetchOptions: { throw: false }
+        });
+        if (error) throw error;
+      },
+      setActiveSession: async (params) => {
+        const { error } = await setActiveSessionAsync({
+          ...params,
+          fetchOptions: { throw: false }
+        });
+        if (error) throw error;
+      },
+      revokeDeviceSession: async (params) => {
+        const { error } = await revokeDeviceSessionAsync({
+          ...params,
+          fetchOptions: { throw: false }
+        });
+        if (error) throw error;
+      }
+    }),
+    [
+      updateUserAsync,
+      deletePasskeyAsync,
+      unlinkAccountAsync,
+      revokeSessionAsync,
+      revokeDeviceSessionAsync,
+      setActiveSessionAsync
+    ]
+  );
+  const onSessionChange = useCallback(async () => {
+    await queryClient.refetchQueries({ queryKey: sessionKey });
+    queryClient.invalidateQueries({
+      predicate: (query) => query.queryKey !== sessionKey
+    });
+  }, [queryClient, sessionKey]);
+  return {
+    hooks,
+    mutators,
+    onSessionChange,
+    optimistic: true
+  };
+}
+
+// src/lib/tanstack/auth-ui-provider-tanstack.tsx
+import { jsx } from "react/jsx-runtime";
+function AuthUIProviderTanstack({
+  children,
+  authClient,
+  hooks: hooksProp,
+  mutators: mutatorsProp,
+  onSessionChange: onSessionChangeProp,
+  ...props
+}) {
+  const {
+    hooks: contextHooks,
+    mutators: contextMutators,
+    onSessionChange,
+    optimistic
+  } = useTanstackOptions({ authClient });
+  const hooks = useMemo2(
+    () => ({ ...contextHooks, ...hooksProp }),
+    [contextHooks, hooksProp]
+  );
+  const mutators = useMemo2(
+    () => ({ ...contextMutators, ...mutatorsProp }),
+    [contextMutators, mutatorsProp]
+  );
+  const onSessionChangeCallback = useCallback2(async () => {
+    await onSessionChange();
+    await (onSessionChangeProp == null ? void 0 : onSessionChangeProp());
+  }, [onSessionChangeProp, onSessionChange]);
+  return /* @__PURE__ */ jsx(
+    AuthUIProvider,
+    {
+      authClient,
+      hooks,
+      mutators,
+      onSessionChange: onSessionChangeCallback,
+      optimistic,
+      ...props,
+      children
+    }
+  );
+}
+export {
+  AuthUIProviderTanstack
+};

package/dist/triplit.cjs

@@ -0,0 +1,201 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/lib/triplit/use-triplit-hooks.ts
+var _react = require('react');
+
+// src/lib/triplit/model-names.ts
+var getModelName = ({
+  namespace,
+  modelNames,
+  usePlural = false
+}) => {
+  return (modelNames == null ? void 0 : modelNames[namespace]) || `${namespace}${usePlural ? "s" : ""}`;
+};
+
+// src/lib/triplit/use-conditional-query.ts
+var _react3 = require('@triplit/react');
+
+function useConditionalQuery(client, query, options) {
+  const stringifiedQuery = !(options == null ? void 0 : options.disabled) && query && JSON.stringify(query);
+  const localOnly = !!(options == null ? void 0 : options.localOnly);
+  const [remoteFulfilled, setRemoteFulfilled] = _react.useState.call(void 0, false);
+  const defaultValue = {
+    results: void 0,
+    fetching: true,
+    fetchingLocal: false,
+    fetchingRemote: false,
+    error: void 0
+  };
+  const [subscribe, snapshot] = _react.useMemo.call(void 0, 
+    () => stringifiedQuery ? _react3.createStateSubscription.call(void 0, client, query, {
+      ...options,
+      onRemoteFulfilled: () => setRemoteFulfilled(true)
+    }) : [() => () => {
+    }, () => defaultValue],
+    [stringifiedQuery, localOnly]
+  );
+  const getServerSnapshot = _react.useCallback.call(void 0, () => snapshot(), [snapshot]);
+  const { fetching, ...rest } = _react.useSyncExternalStore.call(void 0, 
+    subscribe,
+    snapshot,
+    getServerSnapshot
+  );
+  return { fetching: fetching && !remoteFulfilled, ...rest };
+}
+function useConditionalQueryOne(client, query, options) {
+  const { fetching, fetchingLocal, fetchingRemote, results, error } = useConditionalQuery(
+    client,
+    query ? { ...query, limit: 1 } : query,
+    options
+  );
+  const result = _react.useMemo.call(void 0, () => {
+    return _nullishCoalesce((results == null ? void 0 : results[0]), () => ( null));
+  }, [results]);
+  return { fetching, fetchingLocal, fetchingRemote, result, error };
+}
+
+// src/lib/triplit/use-triplit-token.ts
+
+
+function useTriplitToken(triplit) {
+  const connectionStatus = _react3.useConnectionStatus.call(void 0, triplit);
+  const payload = _react.useMemo.call(void 0, 
+    () => triplit.token ? decodeJWT(triplit.token) : void 0,
+    [connectionStatus]
+  );
+  return { token: payload && triplit.token, payload };
+}
+function decodeJWT(token) {
+  try {
+    const base64Url = token.split(".")[1];
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = decodeURIComponent(
+      atob(base64).split("").map((char) => {
+        return `%${`00${char.charCodeAt(0).toString(16)}`.slice(-2)}`;
+      }).join("")
+    );
+    return JSON.parse(jsonPayload);
+  } catch (error) {
+    console.error("Failed to decode JWT:", error);
+    return null;
+  }
+}
+
+// src/lib/triplit/use-list-accounts.ts
+function useListAccounts({
+  triplit,
+  modelNames,
+  usePlural,
+  isPending
+}) {
+  const modelName = getModelName({
+    namespace: "account",
+    modelNames,
+    usePlural
+  });
+  const { payload } = useTriplitToken(triplit);
+  const { results, error, fetching } = useConditionalQuery(
+    triplit,
+    (payload == null ? void 0 : payload.sub) && triplit.query(modelName)
+  );
+  return {
+    data: results,
+    isPending: isPending || fetching,
+    error
+  };
+}
+
+// src/lib/triplit/use-list-sessions.ts
+function useListSessions({
+  triplit,
+  modelNames,
+  usePlural,
+  isPending
+}) {
+  const modelName = getModelName({
+    namespace: "session",
+    modelNames,
+    usePlural
+  });
+  const { payload } = useTriplitToken(triplit);
+  const {
+    results: sessions,
+    error,
+    fetching
+  } = useConditionalQuery(triplit, (payload == null ? void 0 : payload.sub) && triplit.query(modelName));
+  return {
+    data: sessions,
+    isPending: isPending || fetching,
+    error
+  };
+}
+
+// src/lib/triplit/use-session.ts
+function useSession({
+  triplit,
+  sessionData,
+  isPending,
+  refetch,
+  usePlural,
+  modelNames
+}) {
+  const modelName = getModelName({
+    namespace: "user",
+    modelNames,
+    usePlural
+  });
+  const { payload } = useTriplitToken(triplit);
+  const { result: user, error } = useConditionalQueryOne(
+    triplit,
+    (payload == null ? void 0 : payload.sub) && triplit.query(modelName)
+  );
+  return {
+    data: sessionData ? {
+      session: sessionData.session,
+      user: (sessionData == null ? void 0 : sessionData.user.id) === (user == null ? void 0 : user.id) ? user : sessionData.user
+    } : null,
+    error,
+    isPending,
+    refetch: refetch || (() => {
+    })
+  };
+}
+
+// src/lib/triplit/use-triplit-hooks.ts
+function useTriplitHooks({
+  triplit,
+  usePlural = true,
+  modelNames,
+  sessionData,
+  isPending
+}) {
+  const hooks = _react.useMemo.call(void 0, () => {
+    return {
+      useSession: () => useSession({
+        triplit,
+        modelNames,
+        usePlural,
+        sessionData,
+        isPending
+      }),
+      useListAccounts: () => useListAccounts({
+        triplit,
+        modelNames,
+        usePlural,
+        sessionData,
+        isPending
+      }),
+      useListSessions: () => useListSessions({
+        triplit,
+        modelNames,
+        usePlural,
+        sessionData,
+        isPending
+      })
+    };
+  }, [triplit, modelNames, usePlural, sessionData, isPending]);
+  return {
+    hooks
+  };
+}
+
+
+exports.useTriplitHooks = useTriplitHooks;

package/dist/triplit.d.cts

@@ -0,0 +1,31 @@
+import { TriplitClient } from '@triplit/client';
+import { User } from 'better-auth';
+import { S as Session, R as Refetch, a as AuthHooks } from './auth-hooks-IOEvlYYv.cjs';
+import '@better-fetch/fetch';
+import 'better-auth/plugins/organization';
+import 'better-auth/react';
+import 'inspector';
+import 'better-auth/client/plugins';
+import 'better-auth/plugins/passkey';
+
+declare const namespaces: readonly ["user", "session", "account", "passkey"];
+type Namespace = (typeof namespaces)[number];
+type ModelNames = {
+    [key in Namespace]: string;
+};
+interface UseTriplitOptionsProps {
+    triplit: TriplitClient<any>;
+    modelNames?: Partial<ModelNames>;
+    usePlural?: boolean;
+    sessionData?: {
+        user: User;
+        session: Session;
+    } | null;
+    refetch?: Refetch;
+    isPending: boolean;
+}
+declare function useTriplitHooks({ triplit, usePlural, modelNames, sessionData, isPending }: UseTriplitOptionsProps): {
+    hooks: AuthHooks;
+};
+
+export { type UseTriplitOptionsProps, useTriplitHooks };

package/dist/triplit.d.ts

@@ -0,0 +1,31 @@
+import { TriplitClient } from '@triplit/client';
+import { User } from 'better-auth';
+import { S as Session, R as Refetch, a as AuthHooks } from './auth-hooks-IOEvlYYv.js';
+import '@better-fetch/fetch';
+import 'better-auth/plugins/organization';
+import 'better-auth/react';
+import 'inspector';
+import 'better-auth/client/plugins';
+import 'better-auth/plugins/passkey';
+
+declare const namespaces: readonly ["user", "session", "account", "passkey"];
+type Namespace = (typeof namespaces)[number];
+type ModelNames = {
+    [key in Namespace]: string;
+};
+interface UseTriplitOptionsProps {
+    triplit: TriplitClient<any>;
+    modelNames?: Partial<ModelNames>;
+    usePlural?: boolean;
+    sessionData?: {
+        user: User;
+        session: Session;
+    } | null;
+    refetch?: Refetch;
+    isPending: boolean;
+}
+declare function useTriplitHooks({ triplit, usePlural, modelNames, sessionData, isPending }: UseTriplitOptionsProps): {
+    hooks: AuthHooks;
+};
+
+export { type UseTriplitOptionsProps, useTriplitHooks };

package/dist/triplit.js

@@ -0,0 +1,201 @@
+// src/lib/triplit/use-triplit-hooks.ts
+import { useMemo as useMemo3 } from "react";
+
+// src/lib/triplit/model-names.ts
+var getModelName = ({
+  namespace,
+  modelNames,
+  usePlural = false
+}) => {
+  return (modelNames == null ? void 0 : modelNames[namespace]) || `${namespace}${usePlural ? "s" : ""}`;
+};
+
+// src/lib/triplit/use-conditional-query.ts
+import { createStateSubscription } from "@triplit/react";
+import { useCallback, useMemo, useState, useSyncExternalStore } from "react";
+function useConditionalQuery(client, query, options) {
+  const stringifiedQuery = !(options == null ? void 0 : options.disabled) && query && JSON.stringify(query);
+  const localOnly = !!(options == null ? void 0 : options.localOnly);
+  const [remoteFulfilled, setRemoteFulfilled] = useState(false);
+  const defaultValue = {
+    results: void 0,
+    fetching: true,
+    fetchingLocal: false,
+    fetchingRemote: false,
+    error: void 0
+  };
+  const [subscribe, snapshot] = useMemo(
+    () => stringifiedQuery ? createStateSubscription(client, query, {
+      ...options,
+      onRemoteFulfilled: () => setRemoteFulfilled(true)
+    }) : [() => () => {
+    }, () => defaultValue],
+    [stringifiedQuery, localOnly]
+  );
+  const getServerSnapshot = useCallback(() => snapshot(), [snapshot]);
+  const { fetching, ...rest } = useSyncExternalStore(
+    subscribe,
+    snapshot,
+    getServerSnapshot
+  );
+  return { fetching: fetching && !remoteFulfilled, ...rest };
+}
+function useConditionalQueryOne(client, query, options) {
+  const { fetching, fetchingLocal, fetchingRemote, results, error } = useConditionalQuery(
+    client,
+    query ? { ...query, limit: 1 } : query,
+    options
+  );
+  const result = useMemo(() => {
+    return (results == null ? void 0 : results[0]) ?? null;
+  }, [results]);
+  return { fetching, fetchingLocal, fetchingRemote, result, error };
+}
+
+// src/lib/triplit/use-triplit-token.ts
+import { useConnectionStatus } from "@triplit/react";
+import { useMemo as useMemo2 } from "react";
+function useTriplitToken(triplit) {
+  const connectionStatus = useConnectionStatus(triplit);
+  const payload = useMemo2(
+    () => triplit.token ? decodeJWT(triplit.token) : void 0,
+    [connectionStatus]
+  );
+  return { token: payload && triplit.token, payload };
+}
+function decodeJWT(token) {
+  try {
+    const base64Url = token.split(".")[1];
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = decodeURIComponent(
+      atob(base64).split("").map((char) => {
+        return `%${`00${char.charCodeAt(0).toString(16)}`.slice(-2)}`;
+      }).join("")
+    );
+    return JSON.parse(jsonPayload);
+  } catch (error) {
+    console.error("Failed to decode JWT:", error);
+    return null;
+  }
+}
+
+// src/lib/triplit/use-list-accounts.ts
+function useListAccounts({
+  triplit,
+  modelNames,
+  usePlural,
+  isPending
+}) {
+  const modelName = getModelName({
+    namespace: "account",
+    modelNames,
+    usePlural
+  });
+  const { payload } = useTriplitToken(triplit);
+  const { results, error, fetching } = useConditionalQuery(
+    triplit,
+    (payload == null ? void 0 : payload.sub) && triplit.query(modelName)
+  );
+  return {
+    data: results,
+    isPending: isPending || fetching,
+    error
+  };
+}
+
+// src/lib/triplit/use-list-sessions.ts
+function useListSessions({
+  triplit,
+  modelNames,
+  usePlural,
+  isPending
+}) {
+  const modelName = getModelName({
+    namespace: "session",
+    modelNames,
+    usePlural
+  });
+  const { payload } = useTriplitToken(triplit);
+  const {
+    results: sessions,
+    error,
+    fetching
+  } = useConditionalQuery(triplit, (payload == null ? void 0 : payload.sub) && triplit.query(modelName));
+  return {
+    data: sessions,
+    isPending: isPending || fetching,
+    error
+  };
+}
+
+// src/lib/triplit/use-session.ts
+function useSession({
+  triplit,
+  sessionData,
+  isPending,
+  refetch,
+  usePlural,
+  modelNames
+}) {
+  const modelName = getModelName({
+    namespace: "user",
+    modelNames,
+    usePlural
+  });
+  const { payload } = useTriplitToken(triplit);
+  const { result: user, error } = useConditionalQueryOne(
+    triplit,
+    (payload == null ? void 0 : payload.sub) && triplit.query(modelName)
+  );
+  return {
+    data: sessionData ? {
+      session: sessionData.session,
+      user: (sessionData == null ? void 0 : sessionData.user.id) === (user == null ? void 0 : user.id) ? user : sessionData.user
+    } : null,
+    error,
+    isPending,
+    refetch: refetch || (() => {
+    })
+  };
+}
+
+// src/lib/triplit/use-triplit-hooks.ts
+function useTriplitHooks({
+  triplit,
+  usePlural = true,
+  modelNames,
+  sessionData,
+  isPending
+}) {
+  const hooks = useMemo3(() => {
+    return {
+      useSession: () => useSession({
+        triplit,
+        modelNames,
+        usePlural,
+        sessionData,
+        isPending
+      }),
+      useListAccounts: () => useListAccounts({
+        triplit,
+        modelNames,
+        usePlural,
+        sessionData,
+        isPending
+      }),
+      useListSessions: () => useListSessions({
+        triplit,
+        modelNames,
+        usePlural,
+        sessionData,
+        isPending
+      })
+    };
+  }, [triplit, modelNames, usePlural, sessionData, isPending]);
+  return {
+    hooks
+  };
+}
+export {
+  useTriplitHooks
+};

package/dist/utils-C5R37WDe.d.cts

@@ -0,0 +1,3 @@
+declare function getViewByPath<T extends object>(viewPaths: T, path?: string): Extract<keyof T, string> | undefined;
+
+export { getViewByPath as g };

package/dist/utils-C5R37WDe.d.ts

@@ -0,0 +1,3 @@
+declare function getViewByPath<T extends object>(viewPaths: T, path?: string): Extract<keyof T, string> | undefined;
+
+export { getViewByPath as g };