jazz-react-native 0.8.14 → 0.8.16

package/src/index.ts

@@ -1,25 +1,25 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import {
-    CoValue,
-    ID,
-    AgentID,
-    SessionID,
-    cojsonInternals,
-    InviteSecret,
-    Account,
-    CoValueClass,
-    CryptoProvider,
-    AuthMethod,
-    createJazzContext,
-    AnonymousJazzAgent,
+  Account,
+  AgentID,
+  AnonymousJazzAgent,
+  AuthMethod,
+  CoValue,
+  CoValueClass,
+  CryptoProvider,
+  ID,
+  InviteSecret,
+  SessionID,
+  cojsonInternals,
+  createJazzContext,
 } from "jazz-tools";
 
-import { PureJSCrypto } from "jazz-tools/native";
+import NetInfo from "@react-native-community/netinfo";
 import { RawAccountID } from "cojson";
 import { createWebSocketPeer } from "cojson-transport-ws";
-import NetInfo from "@react-native-community/netinfo";
 import * as Linking from "expo-linking";
+import { PureJSCrypto } from "jazz-tools/native";
 
 export { RNDemoAuth } from "./auth/DemoAuthMethod.js";
 
@@ -27,244 +27,240 @@ import { KvStoreContext } from "./storage/kv-store-context.js";
 
 /** @category Context Creation */
 export type BrowserContext<Acc extends Account> = {
-    me: Acc;
-    logOut: () => void;
-    // TODO: Symbol.dispose?
-    done: () => void;
+  me: Acc;
+  logOut: () => void;
+  // TODO: Symbol.dispose?
+  done: () => void;
 };
 
 export type BrowserGuestContext = {
-    guest: AnonymousJazzAgent;
-    logOut: () => void;
-    done: () => void;
+  guest: AnonymousJazzAgent;
+  logOut: () => void;
+  done: () => void;
 };
 
 export type BrowserContextOptions<Acc extends Account> = {
-    auth: AuthMethod;
-    AccountSchema: CoValueClass<Acc> & {
-        fromNode: (typeof Account)["fromNode"];
-    };
+  auth: AuthMethod;
+  AccountSchema: CoValueClass<Acc> & {
+    fromNode: (typeof Account)["fromNode"];
+  };
 } & BaseBrowserContextOptions;
 
 export type BaseBrowserContextOptions = {
-    peer: `wss://${string}` | `ws://${string}`;
-    reconnectionTimeout?: number;
-    storage?: "indexedDB" | "singleTabOPFS";
-    crypto?: CryptoProvider;
+  peer: `wss://${string}` | `ws://${string}`;
+  reconnectionTimeout?: number;
+  storage?: "indexedDB" | "singleTabOPFS";
+  crypto?: CryptoProvider;
 };
 
 /** @category Context Creation */
 export async function createJazzRNContext<Acc extends Account>(
-    options: BrowserContextOptions<Acc>,
+  options: BrowserContextOptions<Acc>,
 ): Promise<BrowserContext<Acc>>;
 export async function createJazzRNContext(
-    options: BaseBrowserContextOptions,
+  options: BaseBrowserContextOptions,
 ): Promise<BrowserGuestContext>;
 export async function createJazzRNContext<Acc extends Account>(
-    options: BrowserContextOptions<Acc> | BaseBrowserContextOptions,
+  options: BrowserContextOptions<Acc> | BaseBrowserContextOptions,
 ): Promise<BrowserContext<Acc> | BrowserGuestContext>;
 export async function createJazzRNContext<Acc extends Account>(
-    options: BrowserContextOptions<Acc> | BaseBrowserContextOptions,
+  options: BrowserContextOptions<Acc> | BaseBrowserContextOptions,
 ): Promise<BrowserContext<Acc> | BrowserGuestContext> {
-    const firstWsPeer = createWebSocketPeer({
-        websocket: new WebSocket(options.peer),
-        id: options.peer + "@" + new Date().toISOString(),
-        role: "server",
-        expectPings: true,
-    });
-    let shouldTryToReconnect = true;
-
-    let currentReconnectionTimeout = options.reconnectionTimeout || 500;
-
-    const unsubscribeNetworkChange = NetInfo.addEventListener((state) => {
-        if (state.isConnected) {
-            currentReconnectionTimeout = options.reconnectionTimeout || 500;
-        }
-    });
-
-    const context =
-        "auth" in options
-            ? await createJazzContext({
-                  AccountSchema: options.AccountSchema,
-                  auth: options.auth,
-                  crypto: await PureJSCrypto.create(),
-                  peersToLoadFrom: [firstWsPeer],
-                  sessionProvider: provideLockSession,
-              })
-            : await createJazzContext({
-                  crypto: await PureJSCrypto.create(),
-                  peersToLoadFrom: [firstWsPeer],
-              });
-
-    const node =
-        "account" in context
-            ? context.account._raw.core.node
-            : context.agent.node;
-
-    async function websocketReconnectLoop() {
-        while (shouldTryToReconnect) {
-            if (
-                Object.keys(node.syncManager.peers).some((peerId) =>
-                    peerId.includes(options.peer),
-                )
-            ) {
-                // TODO: this might drain battery, use listeners instead
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            } else {
-                console.log(
-                    "Websocket disconnected, trying to reconnect in " +
-                        currentReconnectionTimeout +
-                        "ms",
-                );
-                currentReconnectionTimeout = Math.min(
-                    currentReconnectionTimeout * 2,
-                    30000,
-                );
-                await new Promise<void>((resolve) => {
-                    setTimeout(resolve, currentReconnectionTimeout);
-                    const _unsubscribeNetworkChange = NetInfo.addEventListener(
-                        (state) => {
-                            if (state.isConnected) {
-                                resolve();
-                                _unsubscribeNetworkChange();
-                            }
-                        },
-                    );
-                });
-
-                node.syncManager.addPeer(
-                    createWebSocketPeer({
-                        websocket: new WebSocket(options.peer),
-                        id: options.peer + "@" + new Date().toISOString(),
-                        role: "server",
-                    }),
-                );
-            }
-        }
+  const firstWsPeer = createWebSocketPeer({
+    websocket: new WebSocket(options.peer),
+    id: options.peer + "@" + new Date().toISOString(),
+    role: "server",
+    expectPings: true,
+  });
+  let shouldTryToReconnect = true;
+
+  let currentReconnectionTimeout = options.reconnectionTimeout || 500;
+
+  const unsubscribeNetworkChange = NetInfo.addEventListener((state) => {
+    if (state.isConnected) {
+      currentReconnectionTimeout = options.reconnectionTimeout || 500;
     }
-
-    void websocketReconnectLoop();
-
-    return "account" in context
-        ? {
-              me: context.account,
-              done: () => {
-                  shouldTryToReconnect = false;
-                  unsubscribeNetworkChange?.();
-                  context.done();
-              },
-              logOut: () => {
-                  context.logOut();
-              },
-          }
-        : {
-              guest: context.agent,
-              done: () => {
-                  shouldTryToReconnect = false;
-                  unsubscribeNetworkChange?.();
-                  context.done();
-              },
-              logOut: () => {
-                  context.logOut();
-              },
-          };
+  });
+
+  const context =
+    "auth" in options
+      ? await createJazzContext({
+          AccountSchema: options.AccountSchema,
+          auth: options.auth,
+          crypto: await PureJSCrypto.create(),
+          peersToLoadFrom: [firstWsPeer],
+          sessionProvider: provideLockSession,
+        })
+      : await createJazzContext({
+          crypto: await PureJSCrypto.create(),
+          peersToLoadFrom: [firstWsPeer],
+        });
+
+  const node =
+    "account" in context ? context.account._raw.core.node : context.agent.node;
+
+  async function websocketReconnectLoop() {
+    while (shouldTryToReconnect) {
+      if (
+        Object.keys(node.syncManager.peers).some((peerId) =>
+          peerId.includes(options.peer),
+        )
+      ) {
+        // TODO: this might drain battery, use listeners instead
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      } else {
+        console.log(
+          "Websocket disconnected, trying to reconnect in " +
+            currentReconnectionTimeout +
+            "ms",
+        );
+        currentReconnectionTimeout = Math.min(
+          currentReconnectionTimeout * 2,
+          30000,
+        );
+        await new Promise<void>((resolve) => {
+          setTimeout(resolve, currentReconnectionTimeout);
+          const _unsubscribeNetworkChange = NetInfo.addEventListener(
+            (state) => {
+              if (state.isConnected) {
+                resolve();
+                _unsubscribeNetworkChange();
+              }
+            },
+          );
+        });
+
+        node.syncManager.addPeer(
+          createWebSocketPeer({
+            websocket: new WebSocket(options.peer),
+            id: options.peer + "@" + new Date().toISOString(),
+            role: "server",
+          }),
+        );
+      }
+    }
+  }
+
+  void websocketReconnectLoop();
+
+  return "account" in context
+    ? {
+        me: context.account,
+        done: () => {
+          shouldTryToReconnect = false;
+          unsubscribeNetworkChange?.();
+          context.done();
+        },
+        logOut: () => {
+          context.logOut();
+        },
+      }
+    : {
+        guest: context.agent,
+        done: () => {
+          shouldTryToReconnect = false;
+          unsubscribeNetworkChange?.();
+          context.done();
+        },
+        logOut: () => {
+          context.logOut();
+        },
+      };
 }
 
 /** @category Auth Providers */
 export type SessionProvider = (
-    accountID: ID<Account> | AgentID,
+  accountID: ID<Account> | AgentID,
 ) => Promise<SessionID>;
 
 export async function provideLockSession(
-    accountID: ID<Account> | AgentID,
-    crypto: CryptoProvider,
+  accountID: ID<Account> | AgentID,
+  crypto: CryptoProvider,
 ) {
-    const sessionDone = () => {};
+  const sessionDone = () => {};
 
-    const kvStore = KvStoreContext.getInstance().getStorage();
+  const kvStore = KvStoreContext.getInstance().getStorage();
 
-    const sessionID =
-        ((await kvStore.get(accountID)) as SessionID) ||
-        crypto.newRandomSessionID(accountID as RawAccountID | AgentID);
-    await kvStore.set(accountID, sessionID);
+  const sessionID =
+    ((await kvStore.get(accountID)) as SessionID) ||
+    crypto.newRandomSessionID(accountID as RawAccountID | AgentID);
+  await kvStore.set(accountID, sessionID);
 
-    return Promise.resolve({
-        sessionID,
-        sessionDone,
-    });
+  return Promise.resolve({
+    sessionID,
+    sessionDone,
+  });
 }
 
 const window = {
-    location: {
-        href: "#",
-    },
-    history: {
-        replaceState: (a: any, b: any, c: any) => {},
-    },
+  location: {
+    href: "#",
+  },
+  history: {
+    replaceState: (a: any, b: any, c: any) => {},
+  },
 };
 
 /** @category Invite Links */
 export function createInviteLink<C extends CoValue>(
-    value: C,
-    role: "reader" | "writer" | "admin",
-    { baseURL, valueHint }: { baseURL?: string; valueHint?: string } = {},
+  value: C,
+  role: "reader" | "writer" | "admin",
+  { baseURL, valueHint }: { baseURL?: string; valueHint?: string } = {},
 ): string {
-    const coValueCore = value._raw.core;
-    let currentCoValue = coValueCore;
+  const coValueCore = value._raw.core;
+  let currentCoValue = coValueCore;
 
-    while (currentCoValue.header.ruleset.type === "ownedByGroup") {
-        currentCoValue = currentCoValue.getGroup().core;
-    }
+  while (currentCoValue.header.ruleset.type === "ownedByGroup") {
+    currentCoValue = currentCoValue.getGroup().core;
+  }
 
-    if (currentCoValue.header.ruleset.type !== "group") {
-        throw new Error("Can't create invite link for object without group");
-    }
+  if (currentCoValue.header.ruleset.type !== "group") {
+    throw new Error("Can't create invite link for object without group");
+  }
 
-    const group = cojsonInternals.expectGroup(
-        currentCoValue.getCurrentContent(),
-    );
-    const inviteSecret = group.createInvite(role);
+  const group = cojsonInternals.expectGroup(currentCoValue.getCurrentContent());
+  const inviteSecret = group.createInvite(role);
 
-    return `${baseURL}/invite/${valueHint ? valueHint + "/" : ""}${
-        value.id
-    }/${inviteSecret}`;
+  return `${baseURL}/invite/${valueHint ? valueHint + "/" : ""}${
+    value.id
+  }/${inviteSecret}`;
 }
 
 /** @category Invite Links */
 export function parseInviteLink<C extends CoValue>(
-    inviteURL: string,
+  inviteURL: string,
 ):
-    | {
-          valueID: ID<C>;
-          valueHint?: string;
-          inviteSecret: InviteSecret;
-      }
-    | undefined {
-    const url = Linking.parse(inviteURL);
-    const parts = url.path?.split("/");
-
-    if (!parts || parts[0] !== "invite") {
-        return undefined;
-    }
-
-    let valueHint: string | undefined;
-    let valueID: ID<C> | undefined;
-    let inviteSecret: InviteSecret | undefined;
-
-    if (parts.length === 4) {
-        valueHint = parts[1];
-        valueID = parts[2] as ID<C>;
-        inviteSecret = parts[3] as InviteSecret;
-    } else if (parts.length === 3) {
-        valueID = parts[1] as ID<C>;
-        inviteSecret = parts[2] as InviteSecret;
-    }
-
-    if (!valueID || !inviteSecret) {
-        return undefined;
+  | {
+      valueID: ID<C>;
+      valueHint?: string;
+      inviteSecret: InviteSecret;
     }
-
-    return { valueID, inviteSecret, valueHint };
+  | undefined {
+  const url = Linking.parse(inviteURL);
+  const parts = url.path?.split("/");
+
+  if (!parts || parts[0] !== "invite") {
+    return undefined;
+  }
+
+  let valueHint: string | undefined;
+  let valueID: ID<C> | undefined;
+  let inviteSecret: InviteSecret | undefined;
+
+  if (parts.length === 4) {
+    valueHint = parts[1];
+    valueID = parts[2] as ID<C>;
+    inviteSecret = parts[3] as InviteSecret;
+  } else if (parts.length === 3) {
+    valueID = parts[1] as ID<C>;
+    inviteSecret = parts[2] as InviteSecret;
+  }
+
+  if (!valueID || !inviteSecret) {
+    return undefined;
+  }
+
+  return { valueID, inviteSecret, valueHint };
 }
 
 /////////

package/src/media.tsx

@@ -1,68 +1,67 @@
-import React, { useEffect, useState } from "react";
 import { ImageDefinition } from "jazz-tools";
+import React, { useEffect, useState } from "react";
 
 /** @category Media */
 export function useProgressiveImg({
-    image,
-    maxWidth,
+  image,
+  maxWidth,
 }: {
-    image: ImageDefinition | null | undefined;
-    maxWidth?: number;
+  image: ImageDefinition | null | undefined;
+  maxWidth?: number;
 }) {
-    const [current, setCurrent] = useState<
-        | { src?: string; res?: `${number}x${number}` | "placeholder" }
-        | undefined
-    >(undefined);
+  const [current, setCurrent] = useState<
+    { src?: string; res?: `${number}x${number}` | "placeholder" } | undefined
+  >(undefined);
 
-    useEffect(() => {
-        let lastHighestRes: string | undefined;
-        if (!image) return;
-        const unsub = image.subscribe({}, (update) => {
-            const highestRes = update?.highestResAvailable({ maxWidth });
-            if (highestRes) {
-                if (highestRes.res !== lastHighestRes) {
-                    lastHighestRes = highestRes.res;
-                    const blob = highestRes.stream.toBlob();
-                    if (blob) {
-                        const blobURI = URL.createObjectURL(blob);
-                        setCurrent({ src: blobURI, res: highestRes.res });
-                        return () => {
-                            setTimeout(() => URL.revokeObjectURL(blobURI), 200);
-                        };
-                    }
-                }
-            } else {
-                setCurrent({
-                    src: update?.placeholderDataURL,
-                    res: "placeholder",
-                });
-            }
+  useEffect(() => {
+    let lastHighestRes: string | undefined;
+    if (!image) return;
+    const unsub = image.subscribe({}, (update) => {
+      const highestRes = update?.highestResAvailable({ maxWidth });
+      if (highestRes) {
+        if (highestRes.res !== lastHighestRes) {
+          lastHighestRes = highestRes.res;
+          const blob = highestRes.stream.toBlob();
+          if (blob) {
+            const blobURI = URL.createObjectURL(blob);
+            setCurrent({ src: blobURI, res: highestRes.res });
+            return () => {
+              setTimeout(() => URL.revokeObjectURL(blobURI), 200);
+            };
+          }
+        }
+      } else {
+        setCurrent({
+          src: update?.placeholderDataURL,
+          res: "placeholder",
         });
+      }
+    });
 
-        return unsub;
-    }, [image?.id, maxWidth]);
+    return unsub;
+  }, [image?.id, maxWidth]);
 
-    return {
-        src: current?.src,
-        res: current?.res,
-        originalSize: image?.originalSize,
-    };
+  return {
+    src: current?.src,
+    res: current?.res,
+    originalSize: image?.originalSize,
+  };
 }
 
 /** @category Media */
 export function ProgressiveImg({
-    children,
-    image,
-    maxWidth,
+  children,
+  image,
+  maxWidth,
 }: {
-    children: (result: {
-        src: string | undefined;
-        res: `${number}x${number}` | "placeholder" | undefined;
-        originalSize: readonly [number, number] | undefined;
-    }) => React.ReactNode;
-    image: ImageDefinition | null | undefined;
-    maxWidth?: number;
+  children: (result: {
+    src: string | undefined;
+    res: `${number}x${number}` | "placeholder" | undefined;
+    originalSize: readonly [number, number] | undefined;
+  }) => React.ReactNode;
+  image: ImageDefinition | null | undefined;
+  maxWidth?: number;
 }) {
-    const result = useProgressiveImg({ image, maxWidth });
-    return result && children(result);
+  const result = useProgressiveImg({ image, maxWidth });
+  return result && children(result);
 }