jazz-react-native 0.8.14 → 0.8.16

package/src/provider.tsx

@@ -1,307 +1,298 @@
 import React, { useEffect, useState } from "react";
 
 import {
-    Account,
-    AccountClass,
-    AnonymousJazzAgent,
-    AuthMethod,
-    CoValue,
-    CoValueClass,
-    DeeplyLoaded,
-    DepthsIn,
-    ID,
-    subscribeToCoValue,
+  Account,
+  AccountClass,
+  AnonymousJazzAgent,
+  AuthMethod,
+  CoValue,
+  CoValueClass,
+  DeeplyLoaded,
+  DepthsIn,
+  ID,
+  subscribeToCoValue,
 } from "jazz-tools";
+import { Linking } from "react-native";
 import {
-    BrowserContext,
-    BrowserGuestContext,
-    createJazzRNContext,
-    KvStoreContext,
-    parseInviteLink,
+  BrowserContext,
+  BrowserGuestContext,
+  KvStoreContext,
+  createJazzRNContext,
+  parseInviteLink,
 } from "./index.js";
-import { Linking } from "react-native";
 import { ExpoSecureStoreAdapter } from "./storage/expo-secure-store-adapter.js";
 
 /** @category Context & Hooks */
 export function createJazzRNApp<Acc extends Account>({
-    kvStore = new ExpoSecureStoreAdapter(),
-    AccountSchema = Account as unknown as AccountClass<Acc>,
+  kvStore = new ExpoSecureStoreAdapter(),
+  AccountSchema = Account as unknown as AccountClass<Acc>,
 } = {}): JazzReactApp<Acc> {
-    const JazzContext = React.createContext<
-        BrowserContext<Acc> | BrowserGuestContext | undefined
-    >(undefined);
-
-    if (!kvStore) {
-        throw new Error("kvStore is required");
+  const JazzContext = React.createContext<
+    BrowserContext<Acc> | BrowserGuestContext | undefined
+  >(undefined);
+
+  if (!kvStore) {
+    throw new Error("kvStore is required");
+  }
+
+  KvStoreContext.getInstance().initialize(kvStore);
+
+  function Provider({
+    children,
+    auth,
+    peer,
+    storage,
+  }: {
+    children: React.ReactNode;
+    auth: AuthMethod | "guest";
+    peer: `wss://${string}` | `ws://${string}`;
+    storage?: "indexedDB" | "singleTabOPFS";
+  }) {
+    const [ctx, setCtx] = useState<
+      BrowserContext<Acc> | BrowserGuestContext | undefined
+    >();
+
+    const [sessionCount, setSessionCount] = useState(0);
+
+    useEffect(() => {
+      const promiseWithDoneCallback = createJazzRNContext<Acc>(
+        auth === "guest"
+          ? {
+              peer,
+              storage,
+            }
+          : {
+              AccountSchema,
+              auth: auth,
+              peer,
+              storage,
+            },
+      ).then((context) => {
+        setCtx({
+          ...context,
+          logOut: () => {
+            context.logOut();
+            setCtx(undefined);
+            setSessionCount(sessionCount + 1);
+          },
+        });
+        return context.done;
+      });
+
+      return () => {
+        void promiseWithDoneCallback.then((done) => done());
+      };
+    }, [AccountSchema, auth, peer, storage, sessionCount]);
+
+    return (
+      <JazzContext.Provider value={ctx}>{ctx && children}</JazzContext.Provider>
+    );
+  }
+
+  function useAccount(): { me: Acc; logOut: () => void };
+  function useAccount<D extends DepthsIn<Acc>>(
+    depth: D,
+  ): { me: DeeplyLoaded<Acc, D> | undefined; logOut: () => void };
+  function useAccount<D extends DepthsIn<Acc>>(
+    depth?: D,
+  ): { me: Acc | DeeplyLoaded<Acc, D> | undefined; logOut: () => void } {
+    const context = React.useContext(JazzContext);
+
+    if (!context) {
+      throw new Error("useAccount must be used within a JazzProvider");
     }
 
-    KvStoreContext.getInstance().initialize(kvStore);
-
-    function Provider({
-        children,
-        auth,
-        peer,
-        storage,
-    }: {
-        children: React.ReactNode;
-        auth: AuthMethod | "guest";
-        peer: `wss://${string}` | `ws://${string}`;
-        storage?: "indexedDB" | "singleTabOPFS";
-    }) {
-        const [ctx, setCtx] = useState<
-            BrowserContext<Acc> | BrowserGuestContext | undefined
-        >();
-
-        const [sessionCount, setSessionCount] = useState(0);
-
-        useEffect(() => {
-            const promiseWithDoneCallback = createJazzRNContext<Acc>(
-                auth === "guest"
-                    ? {
-                          peer,
-                          storage,
-                      }
-                    : {
-                          AccountSchema,
-                          auth: auth,
-                          peer,
-                          storage,
-                      },
-            ).then((context) => {
-                setCtx({
-                    ...context,
-                    logOut: () => {
-                        context.logOut();
-                        setCtx(undefined);
-                        setSessionCount(sessionCount + 1);
-                    },
-                });
-                return context.done;
-            });
-
-            return () => {
-                void promiseWithDoneCallback.then((done) => done());
-            };
-        }, [AccountSchema, auth, peer, storage, sessionCount]);
-
-        return (
-            <JazzContext.Provider value={ctx}>
-                {ctx && children}
-            </JazzContext.Provider>
-        );
+    if (!("me" in context)) {
+      throw new Error(
+        "useAccount can't be used in a JazzProvider with auth === 'guest' - consider using useAccountOrGuest()",
+      );
     }
 
-    function useAccount(): { me: Acc; logOut: () => void };
-    function useAccount<D extends DepthsIn<Acc>>(
-        depth: D,
-    ): { me: DeeplyLoaded<Acc, D> | undefined; logOut: () => void };
-    function useAccount<D extends DepthsIn<Acc>>(
-        depth?: D,
-    ): { me: Acc | DeeplyLoaded<Acc, D> | undefined; logOut: () => void } {
-        const context = React.useContext(JazzContext);
-
-        if (!context) {
-            throw new Error("useAccount must be used within a JazzProvider");
-        }
-
-        if (!("me" in context)) {
-            throw new Error(
-                "useAccount can't be used in a JazzProvider with auth === 'guest' - consider using useAccountOrGuest()",
-            );
-        }
+    const me = useCoState<Acc, D>(
+      context?.me.constructor as CoValueClass<Acc>,
+      context?.me.id,
+      depth,
+    );
 
-        const me = useCoState<Acc, D>(
-            context?.me.constructor as CoValueClass<Acc>,
-            context?.me.id,
-            depth,
-        );
-
-        return {
-            me: depth === undefined ? me || context.me : me,
-            logOut: context.logOut,
-        };
+    return {
+      me: depth === undefined ? me || context.me : me,
+      logOut: context.logOut,
+    };
+  }
+
+  function useAccountOrGuest(): { me: Acc | AnonymousJazzAgent };
+  function useAccountOrGuest<D extends DepthsIn<Acc>>(
+    depth: D,
+  ): { me: DeeplyLoaded<Acc, D> | undefined | AnonymousJazzAgent };
+  function useAccountOrGuest<D extends DepthsIn<Acc>>(
+    depth?: D,
+  ): { me: Acc | DeeplyLoaded<Acc, D> | undefined | AnonymousJazzAgent } {
+    const context = React.useContext(JazzContext);
+
+    if (!context) {
+      throw new Error("useAccountOrGuest must be used within a JazzProvider");
     }
 
-    function useAccountOrGuest(): { me: Acc | AnonymousJazzAgent };
-    function useAccountOrGuest<D extends DepthsIn<Acc>>(
-        depth: D,
-    ): { me: DeeplyLoaded<Acc, D> | undefined | AnonymousJazzAgent };
-    function useAccountOrGuest<D extends DepthsIn<Acc>>(
-        depth?: D,
-    ): { me: Acc | DeeplyLoaded<Acc, D> | undefined | AnonymousJazzAgent } {
-        const context = React.useContext(JazzContext);
-
-        if (!context) {
-            throw new Error(
-                "useAccountOrGuest must be used within a JazzProvider",
-            );
-        }
-
-        const contextMe = "me" in context ? context.me : undefined;
+    const contextMe = "me" in context ? context.me : undefined;
 
-        const me = useCoState<Acc, D>(
-            contextMe?.constructor as CoValueClass<Acc>,
-            contextMe?.id,
-            depth,
-        );
+    const me = useCoState<Acc, D>(
+      contextMe?.constructor as CoValueClass<Acc>,
+      contextMe?.id,
+      depth,
+    );
 
-        if ("me" in context) {
-            return {
-                me: depth === undefined ? me || context.me : me,
-            };
-        } else {
-            return { me: context.guest };
-        }
+    if ("me" in context) {
+      return {
+        me: depth === undefined ? me || context.me : me,
+      };
+    } else {
+      return { me: context.guest };
     }
-
-    function useCoState<V extends CoValue, D>(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Schema: CoValueClass<V>,
-        id: ID<V> | undefined,
-        depth: D & DepthsIn<V> = [] as D & DepthsIn<V>,
-    ): DeeplyLoaded<V, D> | undefined {
-        const [state, setState] = useState<{
-            value: DeeplyLoaded<V, D> | undefined;
-        }>({ value: undefined });
-        const context = React.useContext(JazzContext);
-
-        if (!context) {
-            throw new Error("useCoState must be used within a JazzProvider");
-        }
-
-        useEffect(() => {
-            if (!id) return;
-
-            return subscribeToCoValue(
-                Schema,
-                id,
-                "me" in context ? context.me : context.guest,
-                depth,
-                (value) => {
-                    setState({ value });
-                },
-            );
-        }, [Schema, id, context]);
-
-        return state.value;
+  }
+
+  function useCoState<V extends CoValue, D>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Schema: CoValueClass<V>,
+    id: ID<V> | undefined,
+    depth: D & DepthsIn<V> = [] as D & DepthsIn<V>,
+  ): DeeplyLoaded<V, D> | undefined {
+    const [state, setState] = useState<{
+      value: DeeplyLoaded<V, D> | undefined;
+    }>({ value: undefined });
+    const context = React.useContext(JazzContext);
+
+    if (!context) {
+      throw new Error("useCoState must be used within a JazzProvider");
     }
 
-    function useAcceptInvite<V extends CoValue>({
-        invitedObjectSchema,
-        onAccept,
-        forValueHint,
-    }: {
-        invitedObjectSchema: CoValueClass<V>;
-        onAccept: (projectID: ID<V>) => void;
-        forValueHint?: string;
-    }): void {
-        const context = React.useContext(JazzContext);
-
-        if (!context) {
-            throw new Error(
-                "useAcceptInvite must be used within a JazzProvider",
-            );
-        }
-
-        if (!("me" in context)) {
-            throw new Error(
-                "useAcceptInvite can't be used in a JazzProvider with auth === 'guest'.",
-            );
-        }
-
-        useEffect(() => {
-            const handleDeepLink = ({ url }: { url: string }) => {
-                const result = parseInviteLink<V>(url);
-                if (result && result.valueHint === forValueHint) {
-                    context.me
-                        .acceptInvite(
-                            result.valueID,
-                            result.inviteSecret,
-                            invitedObjectSchema,
-                        )
-                        .then(() => {
-                            onAccept(result.valueID);
-                        })
-                        .catch((e) => {
-                            console.error("Failed to accept invite", e);
-                        });
-                }
-            };
-
-            const linkingListener = Linking.addEventListener(
-                "url",
-                handleDeepLink,
-            );
-
-            void Linking.getInitialURL().then((url) => {
-                if (url) handleDeepLink({ url });
-            });
+    useEffect(() => {
+      if (!id) return;
+
+      return subscribeToCoValue(
+        Schema,
+        id,
+        "me" in context ? context.me : context.guest,
+        depth,
+        (value) => {
+          setState({ value });
+        },
+      );
+    }, [Schema, id, context]);
+
+    return state.value;
+  }
+
+  function useAcceptInvite<V extends CoValue>({
+    invitedObjectSchema,
+    onAccept,
+    forValueHint,
+  }: {
+    invitedObjectSchema: CoValueClass<V>;
+    onAccept: (projectID: ID<V>) => void;
+    forValueHint?: string;
+  }): void {
+    const context = React.useContext(JazzContext);
+
+    if (!context) {
+      throw new Error("useAcceptInvite must be used within a JazzProvider");
+    }
 
-            return () => {
-                linkingListener.remove();
-            };
-        }, [context, onAccept, invitedObjectSchema, forValueHint]);
+    if (!("me" in context)) {
+      throw new Error(
+        "useAcceptInvite can't be used in a JazzProvider with auth === 'guest'.",
+      );
     }
 
-    return {
-        Provider,
-        useAccount,
-        useAccountOrGuest,
-        useCoState,
-        useAcceptInvite,
-    };
+    useEffect(() => {
+      const handleDeepLink = ({ url }: { url: string }) => {
+        const result = parseInviteLink<V>(url);
+        if (result && result.valueHint === forValueHint) {
+          context.me
+            .acceptInvite(
+              result.valueID,
+              result.inviteSecret,
+              invitedObjectSchema,
+            )
+            .then(() => {
+              onAccept(result.valueID);
+            })
+            .catch((e) => {
+              console.error("Failed to accept invite", e);
+            });
+        }
+      };
+
+      const linkingListener = Linking.addEventListener("url", handleDeepLink);
+
+      void Linking.getInitialURL().then((url) => {
+        if (url) handleDeepLink({ url });
+      });
+
+      return () => {
+        linkingListener.remove();
+      };
+    }, [context, onAccept, invitedObjectSchema, forValueHint]);
+  }
+
+  return {
+    Provider,
+    useAccount,
+    useAccountOrGuest,
+    useCoState,
+    useAcceptInvite,
+  };
 }
 
 /** @category Context & Hooks */
 export interface JazzReactApp<Acc extends Account> {
-    /** @category Provider Component */
-    Provider: React.FC<{
-        children: React.ReactNode;
-        auth: AuthMethod | "guest";
-        peer: `wss://${string}` | `ws://${string}`;
-        storage?: "indexedDB" | "singleTabOPFS";
-    }>;
-
-    /** @category Hooks */
-    useAccount(): {
-        me: Acc;
-        logOut: () => void;
-    };
-    /** @category Hooks */
-    useAccount<D extends DepthsIn<Acc>>(
-        depth: D,
-    ): {
-        me: DeeplyLoaded<Acc, D> | undefined;
-        logOut: () => void;
-    };
-
-    /** @category Hooks */
-    useAccountOrGuest(): {
-        me: Acc | AnonymousJazzAgent;
-    };
-    useAccountOrGuest<D extends DepthsIn<Acc>>(
-        depth: D,
-    ): {
-        me: DeeplyLoaded<Acc, D> | undefined | AnonymousJazzAgent;
-    };
-    /** @category Hooks */
-    useCoState<V extends CoValue, D>(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Schema: { new (...args: any[]): V } & CoValueClass,
-        id: ID<V> | undefined,
-        depth?: D & DepthsIn<V>,
-    ): DeeplyLoaded<V, D> | undefined;
-
-    /** @category Hooks */
-    useAcceptInvite<V extends CoValue>({
-        invitedObjectSchema,
-        onAccept,
-        forValueHint,
-    }: {
-        invitedObjectSchema: CoValueClass<V>;
-        onAccept: (projectID: ID<V>) => void;
-        forValueHint?: string;
-    }): void;
+  /** @category Provider Component */
+  Provider: React.FC<{
+    children: React.ReactNode;
+    auth: AuthMethod | "guest";
+    peer: `wss://${string}` | `ws://${string}`;
+    storage?: "indexedDB" | "singleTabOPFS";
+  }>;
+
+  /** @category Hooks */
+  useAccount(): {
+    me: Acc;
+    logOut: () => void;
+  };
+  /** @category Hooks */
+  useAccount<D extends DepthsIn<Acc>>(
+    depth: D,
+  ): {
+    me: DeeplyLoaded<Acc, D> | undefined;
+    logOut: () => void;
+  };
+
+  /** @category Hooks */
+  useAccountOrGuest(): {
+    me: Acc | AnonymousJazzAgent;
+  };
+  useAccountOrGuest<D extends DepthsIn<Acc>>(
+    depth: D,
+  ): {
+    me: DeeplyLoaded<Acc, D> | undefined | AnonymousJazzAgent;
+  };
+  /** @category Hooks */
+  useCoState<V extends CoValue, D>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Schema: { new (...args: any[]): V } & CoValueClass,
+    id: ID<V> | undefined,
+    depth?: D & DepthsIn<V>,
+  ): DeeplyLoaded<V, D> | undefined;
+
+  /** @category Hooks */
+  useAcceptInvite<V extends CoValue>({
+    invitedObjectSchema,
+    onAccept,
+    forValueHint,
+  }: {
+    invitedObjectSchema: CoValueClass<V>;
+    onAccept: (projectID: ID<V>) => void;
+    forValueHint?: string;
+  }): void;
 }
 
 export * from "./media.js";

package/src/storage/expo-secure-store-adapter.ts

@@ -2,28 +2,28 @@ import * as SecureStore from "expo-secure-store";
 import type { KvStore } from "./kv-store-context.js";
 
 export class ExpoSecureStoreAdapter implements KvStore {
-    get(key: string): Promise<string | null> {
-        return SecureStore.getItemAsync(key, {
-            requireAuthentication: SecureStore.canUseBiometricAuthentication(),
-            keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK,
-        });
-    }
+  get(key: string): Promise<string | null> {
+    return SecureStore.getItemAsync(key, {
+      requireAuthentication: SecureStore.canUseBiometricAuthentication(),
+      keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK,
+    });
+  }
 
-    async set(key: string, value: string): Promise<void> {
-        return SecureStore.setItemAsync(key, value, {
-            requireAuthentication: SecureStore.canUseBiometricAuthentication(),
-            keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK,
-        });
-    }
+  async set(key: string, value: string): Promise<void> {
+    return SecureStore.setItemAsync(key, value, {
+      requireAuthentication: SecureStore.canUseBiometricAuthentication(),
+      keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK,
+    });
+  }
 
-    async delete(key: string): Promise<void> {
-        return SecureStore.deleteItemAsync(key, {
-            requireAuthentication: SecureStore.canUseBiometricAuthentication(),
-            keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK,
-        });
-    }
+  async delete(key: string): Promise<void> {
+    return SecureStore.deleteItemAsync(key, {
+      requireAuthentication: SecureStore.canUseBiometricAuthentication(),
+      keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK,
+    });
+  }
 
-    async clearAll(): Promise<void> {
-        throw new Error("Not implemented");
-    }
+  async clearAll(): Promise<void> {
+    throw new Error("Not implemented");
+  }
 }

package/src/storage/kv-store-context.ts

@@ -1,35 +1,35 @@
 export interface KvStore {
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string): Promise<void>;
-    delete(key: string): Promise<void>;
-    clearAll(): Promise<void>;
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  delete(key: string): Promise<void>;
+  clearAll(): Promise<void>;
 }
 
 export class KvStoreContext {
-    private static instance: KvStoreContext;
-    private storageInstance: KvStore | null = null;
+  private static instance: KvStoreContext;
+  private storageInstance: KvStore | null = null;
 
-    private constructor() {}
+  private constructor() {}
 
-    public static getInstance(): KvStoreContext {
-        if (!KvStoreContext.instance) {
-            KvStoreContext.instance = new KvStoreContext();
-        }
-        return KvStoreContext.instance;
+  public static getInstance(): KvStoreContext {
+    if (!KvStoreContext.instance) {
+      KvStoreContext.instance = new KvStoreContext();
     }
+    return KvStoreContext.instance;
+  }
 
-    public initialize(store: KvStore): void {
-        if (!this.storageInstance) {
-            this.storageInstance = store;
-        }
+  public initialize(store: KvStore): void {
+    if (!this.storageInstance) {
+      this.storageInstance = store;
     }
+  }
 
-    public getStorage(): KvStore {
-        if (!this.storageInstance) {
-            throw new Error("Storage instance is not initialized.");
-        }
-        return this.storageInstance;
+  public getStorage(): KvStore {
+    if (!this.storageInstance) {
+      throw new Error("Storage instance is not initialized.");
     }
+    return this.storageInstance;
+  }
 }
 
 export default KvStoreContext;