jazz-tools 0.14.28 → 0.15.0

package/dist/react-native-core/index.js

@@ -0,0 +1,669 @@
+// src/react-native-core/provider.tsx
+import { JazzContext, JazzContextManagerContext } from "jazz-tools/react-core";
+import React, { useEffect, useRef } from "react";
+
+// src/react-native-core/ReactNativeContextManager.ts
+import {
+  JazzContextManager
+} from "jazz-tools";
+
+// src/react-native-core/platform.ts
+import NetInfo from "@react-native-community/netinfo";
+import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
+import {
+  createInviteLink as baseCreateInviteLink,
+  createAnonymousJazzContext,
+  createJazzContext
+} from "jazz-tools";
+
+// src/react-native-core/storage/kv-store-context.ts
+var KvStoreContext = class _KvStoreContext {
+  constructor() {
+    this.storageInstance = null;
+  }
+  static getInstance() {
+    if (!_KvStoreContext.instance) {
+      _KvStoreContext.instance = new _KvStoreContext();
+    }
+    return _KvStoreContext.instance;
+  }
+  isInitialized() {
+    return this.storageInstance !== null;
+  }
+  initialize(store) {
+    if (!this.storageInstance) {
+      this.storageInstance = store;
+    }
+  }
+  getStorage() {
+    if (!this.storageInstance) {
+      throw new Error("Storage instance is not initialized.");
+    }
+    return this.storageInstance;
+  }
+};
+
+// src/react-native-core/storage/sqlite-react-native.ts
+import { SQLiteNodeBaseAsync } from "cojson-storage";
+var SQLiteReactNative = class extends SQLiteNodeBaseAsync {
+  static async asPeer(config) {
+    if (!config.adapter) {
+      throw new Error("SQLite adapter is required");
+    }
+    return SQLiteNodeBaseAsync.create({
+      db: config.adapter,
+      localNodeName: "localNode"
+    });
+  }
+};
+
+// src/react-native-core/platform.ts
+import { WebSocketPeerWithReconnection } from "cojson-transport-ws";
+var ReactNativeWebSocketPeerWithReconnection = class extends WebSocketPeerWithReconnection {
+  onNetworkChange(callback) {
+    return NetInfo.addEventListener(
+      (state) => callback(state.isConnected ?? false)
+    );
+  }
+};
+async function setupPeers(options) {
+  const CryptoProvider2 = options.CryptoProvider || PureJSCrypto;
+  const crypto = await CryptoProvider2.create();
+  let node = void 0;
+  const peersToLoadFrom = [];
+  if (options.storage && options.storage !== "disabled") {
+    const storage = await SQLiteReactNative.asPeer({
+      adapter: options.storage
+    });
+    peersToLoadFrom.push(storage);
+  }
+  if (options.sync.when === "never") {
+    return {
+      toggleNetwork: () => {
+      },
+      peersToLoadFrom,
+      setNode: () => {
+      },
+      crypto
+    };
+  }
+  const wsPeer = new ReactNativeWebSocketPeerWithReconnection({
+    peer: options.sync.peer,
+    reconnectionTimeout: options.reconnectionTimeout,
+    addPeer: (peer) => {
+      if (node) {
+        node.syncManager.addPeer(peer);
+      } else {
+        peersToLoadFrom.push(peer);
+      }
+    },
+    removePeer: (peer) => {
+      peersToLoadFrom.splice(peersToLoadFrom.indexOf(peer), 1);
+    }
+  });
+  function toggleNetwork(enabled) {
+    if (enabled) {
+      wsPeer.enable();
+    } else {
+      wsPeer.disable();
+    }
+  }
+  function setNode(value) {
+    node = value;
+  }
+  if (options.sync.when === "always" || !options.sync.when) {
+    toggleNetwork(true);
+  }
+  return {
+    toggleNetwork,
+    peersToLoadFrom,
+    setNode,
+    crypto
+  };
+}
+async function createJazzReactNativeGuestContext(options) {
+  const { toggleNetwork, peersToLoadFrom, setNode, crypto } = await setupPeers(options);
+  const context = await createAnonymousJazzContext({
+    crypto,
+    peersToLoadFrom
+  });
+  setNode(context.agent.node);
+  options.authSecretStorage.emitUpdate(null);
+  return {
+    guest: context.agent,
+    node: context.agent.node,
+    done: () => {
+      toggleNetwork(false);
+      context.done();
+    },
+    logOut: () => {
+      return context.logOut();
+    }
+  };
+}
+async function createJazzReactNativeContext(options) {
+  const { toggleNetwork, peersToLoadFrom, setNode, crypto } = await setupPeers(options);
+  let unsubscribeAuthUpdate = () => {
+  };
+  if (options.sync.when === "signedUp") {
+    let handleAuthUpdate2 = function(isAuthenticated) {
+      if (isAuthenticated) {
+        toggleNetwork(true);
+      } else {
+        toggleNetwork(false);
+      }
+    };
+    var handleAuthUpdate = handleAuthUpdate2;
+    const authSecretStorage = options.authSecretStorage;
+    const credentials = options.credentials ?? await authSecretStorage.get();
+    authSecretStorage.emitUpdate(credentials);
+    unsubscribeAuthUpdate = authSecretStorage.onUpdate(handleAuthUpdate2);
+    handleAuthUpdate2(authSecretStorage.isAuthenticated);
+  }
+  const context = await createJazzContext({
+    credentials: options.credentials,
+    newAccountProps: options.newAccountProps,
+    peersToLoadFrom,
+    crypto,
+    defaultProfileName: options.defaultProfileName,
+    AccountSchema: options.AccountSchema,
+    sessionProvider: provideLockSession,
+    authSecretStorage: options.authSecretStorage
+  });
+  setNode(context.node);
+  return {
+    me: context.account,
+    node: context.node,
+    authSecretStorage: context.authSecretStorage,
+    done: () => {
+      toggleNetwork(false);
+      unsubscribeAuthUpdate();
+      context.done();
+    },
+    logOut: () => {
+      unsubscribeAuthUpdate();
+      return context.logOut();
+    }
+  };
+}
+async function provideLockSession(accountID, crypto) {
+  const sessionDone = () => {
+  };
+  const kvStore = KvStoreContext.getInstance().getStorage();
+  const sessionID = await kvStore.get(accountID) || crypto.newRandomSessionID(accountID);
+  await kvStore.set(accountID, sessionID);
+  return Promise.resolve({
+    sessionID,
+    sessionDone
+  });
+}
+function createInviteLink(value, role, { baseURL, valueHint } = {}) {
+  return baseCreateInviteLink(value, role, baseURL ?? "", valueHint);
+}
+function setupKvStore(kvStore) {
+  if (!kvStore) {
+    return void 0;
+  }
+  KvStoreContext.getInstance().initialize(kvStore);
+  return kvStore;
+}
+
+// src/react-native-core/ReactNativeContextManager.ts
+var ReactNativeContextManager = class extends JazzContextManager {
+  async getNewContext(props, authProps) {
+    if (props.guestMode) {
+      return createJazzReactNativeGuestContext({
+        sync: props.sync,
+        storage: props.storage,
+        authSecretStorage: this.authSecretStorage,
+        CryptoProvider: props.CryptoProvider
+      });
+    } else {
+      return createJazzReactNativeContext({
+        sync: props.sync,
+        storage: props.storage,
+        AccountSchema: props.AccountSchema,
+        credentials: authProps?.credentials,
+        newAccountProps: authProps?.newAccountProps,
+        defaultProfileName: props.defaultProfileName,
+        authSecretStorage: this.authSecretStorage,
+        CryptoProvider: props.CryptoProvider
+      });
+    }
+  }
+  getKvStore() {
+    return KvStoreContext.getInstance().getStorage();
+  }
+  propsChanged(props) {
+    if (!this.props) {
+      return true;
+    }
+    return this.props.sync.when !== props.sync.when || this.props.sync.peer !== props.sync.peer || this.props.guestMode !== props.guestMode;
+  }
+};
+
+// src/react-native-core/provider.tsx
+import { jsx } from "react/jsx-runtime";
+function JazzProviderCore({
+  children,
+  guestMode,
+  sync,
+  storage,
+  AccountSchema: AccountSchema2,
+  defaultProfileName,
+  onLogOut,
+  kvStore,
+  onAnonymousAccountDiscarded,
+  CryptoProvider: CryptoProvider2,
+  logOutReplacement
+}) {
+  setupKvStore(kvStore);
+  const [contextManager] = React.useState(
+    () => new ReactNativeContextManager()
+  );
+  const onAnonymousAccountDiscardedRefCallback = useRefCallback(
+    onAnonymousAccountDiscarded
+  );
+  const onLogOutRefCallback = useRefCallback(onLogOut);
+  const logOutReplacementRefCallback = useRefCallback(logOutReplacement);
+  const logoutReplacementActiveRef = useRef(false);
+  logoutReplacementActiveRef.current = Boolean(logOutReplacement);
+  const value = React.useSyncExternalStore(
+    React.useCallback(
+      (callback) => {
+        const props = {
+          AccountSchema: AccountSchema2,
+          guestMode,
+          sync,
+          storage,
+          defaultProfileName,
+          onLogOut: onLogOutRefCallback,
+          logOutReplacement: logoutReplacementActiveRef.current ? logOutReplacementRefCallback : void 0,
+          onAnonymousAccountDiscarded: onAnonymousAccountDiscardedRefCallback,
+          CryptoProvider: CryptoProvider2
+        };
+        if (contextManager.propsChanged(props)) {
+          contextManager.createContext(props).catch((error) => {
+            console.log(error.stack);
+            console.error("Error creating Jazz context:", error);
+          });
+        }
+        return contextManager.subscribe(callback);
+      },
+      [sync, guestMode].concat(storage)
+    ),
+    () => contextManager.getCurrentValue(),
+    () => contextManager.getCurrentValue()
+  );
+  useEffect(() => {
+    if (process.env.NODE_ENV === "development") return;
+    return () => {
+      contextManager.done();
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(JazzContext.Provider, { value, children: /* @__PURE__ */ jsx(JazzContextManagerContext.Provider, { value: contextManager, children: value && children }) });
+}
+function useRefCallback(callback) {
+  const callbackRef = React.useRef(callback);
+  callbackRef.current = callback;
+  return useRef(
+    (...args) => callbackRef.current?.(...args)
+  ).current;
+}
+
+// src/react-native-core/auth/DemoAuthUI.tsx
+import { useState } from "react";
+import {
+  StyleSheet,
+  Text,
+  TextInput,
+  TouchableOpacity,
+  View,
+  useColorScheme
+} from "react-native";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var DemoAuthBasicUI = ({
+  appName,
+  auth,
+  children
+}) => {
+  const colorScheme = useColorScheme();
+  const darkMode = colorScheme === "dark";
+  const [username, setUsername] = useState("");
+  const [errorMessage, setErrorMessage] = useState(null);
+  const handleSignUp = () => {
+    setErrorMessage(null);
+    auth.signUp(username).catch((error) => {
+      setErrorMessage(error.message);
+    });
+  };
+  const handleLogIn = (username2) => {
+    setErrorMessage(null);
+    auth.logIn(username2).catch((error) => {
+      setErrorMessage(error.message);
+    });
+  };
+  if (auth.state === "signedIn") {
+    return children;
+  }
+  return /* @__PURE__ */ jsx2(
+    View,
+    {
+      style: [
+        styles.container,
+        darkMode ? styles.darkBackground : styles.lightBackground
+      ],
+      children: /* @__PURE__ */ jsxs(View, { style: styles.formContainer, children: [
+        /* @__PURE__ */ jsx2(
+          Text,
+          {
+            style: [
+              styles.headerText,
+              darkMode ? styles.darkText : styles.lightText
+            ],
+            children: appName
+          }
+        ),
+        errorMessage && /* @__PURE__ */ jsx2(Text, { style: styles.errorText, children: errorMessage }),
+        /* @__PURE__ */ jsx2(
+          TextInput,
+          {
+            placeholder: "Display name",
+            value: username,
+            onChangeText: setUsername,
+            placeholderTextColor: darkMode ? "#fff" : "#000",
+            style: [
+              styles.textInput,
+              darkMode ? styles.darkInput : styles.lightInput
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          TouchableOpacity,
+          {
+            onPress: handleSignUp,
+            style: [
+              styles.button,
+              darkMode ? styles.darkButton : styles.lightButton
+            ],
+            children: /* @__PURE__ */ jsx2(
+              Text,
+              {
+                style: darkMode ? styles.darkButtonText : styles.lightButtonText,
+                children: "Sign Up as new account"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx2(View, { style: styles.existingUsersContainer, children: auth.existingUsers.map((user) => /* @__PURE__ */ jsx2(
+          TouchableOpacity,
+          {
+            onPress: () => handleLogIn(user),
+            style: [
+              styles.existingUserButton,
+              darkMode ? styles.darkUserButton : styles.lightUserButton
+            ],
+            children: /* @__PURE__ */ jsxs(Text, { style: darkMode ? styles.darkText : styles.lightText, children: [
+              'Log In as "',
+              user,
+              '"'
+            ] })
+          },
+          user
+        )) })
+      ] })
+    }
+  );
+};
+var styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+    padding: 20
+  },
+  formContainer: {
+    width: "80%",
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  headerText: {
+    fontSize: 24,
+    marginBottom: 20
+  },
+  errorText: {
+    color: "red",
+    marginVertical: 5,
+    textAlign: "center"
+  },
+  textInput: {
+    borderWidth: 1,
+    padding: 10,
+    marginVertical: 10,
+    width: "100%",
+    borderRadius: 6
+  },
+  darkInput: {
+    borderColor: "#444",
+    backgroundColor: "#000",
+    color: "#fff"
+  },
+  lightInput: {
+    borderColor: "#ddd",
+    backgroundColor: "#fff",
+    color: "#000"
+  },
+  button: {
+    paddingVertical: 15,
+    paddingHorizontal: 10,
+    borderRadius: 6,
+    width: "100%",
+    marginVertical: 10
+  },
+  darkButton: {
+    backgroundColor: "#444"
+  },
+  lightButton: {
+    backgroundColor: "#ddd"
+  },
+  darkButtonText: {
+    color: "#fff",
+    textAlign: "center"
+  },
+  lightButtonText: {
+    color: "#000",
+    textAlign: "center"
+  },
+  existingUsersContainer: {
+    width: "100%",
+    marginTop: 20
+  },
+  existingUserButton: {
+    paddingVertical: 15,
+    paddingHorizontal: 10,
+    borderRadius: 6,
+    marginVertical: 5
+  },
+  darkUserButton: {
+    backgroundColor: "#222"
+  },
+  lightUserButton: {
+    backgroundColor: "#eee"
+  },
+  loadingText: {
+    fontSize: 18,
+    color: "#888"
+  },
+  darkText: {
+    color: "#fff"
+  },
+  lightText: {
+    color: "#000"
+  },
+  darkBackground: {
+    backgroundColor: "#000"
+  },
+  lightBackground: {
+    backgroundColor: "#fff"
+  }
+});
+
+// src/react-native-core/auth/auth.ts
+function clearUserCredentials() {
+  const kvStore = KvStoreContext.getInstance().getStorage();
+  return Promise.all([
+    kvStore.delete("demo-auth-logged-in-secret"),
+    kvStore.delete("jazz-clerk-auth"),
+    kvStore.delete("jazz-logged-in-secret")
+  ]);
+}
+
+// src/react-native-core/hooks.tsx
+import { useEffect as useEffect2 } from "react";
+import { parseInviteLink } from "jazz-tools";
+import { useJazzContext } from "jazz-tools/react-core";
+import { Linking } from "react-native";
+import {
+  useCoState,
+  experimental_useInboxSender,
+  useDemoAuth,
+  usePassphraseAuth,
+  useJazzContext as useJazzContext2,
+  useAuthSecretStorage,
+  useIsAuthenticated,
+  useAccount
+} from "jazz-tools/react-core";
+function useAcceptInviteNative({
+  invitedObjectSchema,
+  onAccept,
+  forValueHint
+}) {
+  const context = useJazzContext();
+  if (!("me" in context)) {
+    throw new Error(
+      "useAcceptInviteNative can't be used in a JazzProvider with auth === 'guest'."
+    );
+  }
+  useEffect2(() => {
+    const handleDeepLink = ({ url }) => {
+      const result = parseInviteLink(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]);
+}
+
+// src/react-native-core/media.tsx
+import { ImageDefinition } from "jazz-tools";
+import { useEffect as useEffect3, useState as useState2 } from "react";
+function useProgressiveImgNative({
+  image,
+  maxWidth,
+  targetWidth
+}) {
+  const [current, setCurrent] = useState2(void 0);
+  useEffect3(() => {
+    let lastHighestRes;
+    if (!image) return;
+    const unsub = image.subscribe({}, (update) => {
+      const highestRes = ImageDefinition.highestResAvailable(update, {
+        maxWidth,
+        targetWidth
+      });
+      if (highestRes && highestRes.res !== lastHighestRes) {
+        lastHighestRes = highestRes.res;
+        const chunks = highestRes.stream.getChunks();
+        if (chunks?.chunks && chunks.chunks.length > 0) {
+          const totalLength = chunks.chunks.reduce(
+            (acc, chunk) => acc + chunk.length,
+            0
+          );
+          const combinedArray = new Uint8Array(totalLength);
+          let offset = 0;
+          chunks.chunks.forEach((chunk) => {
+            combinedArray.set(chunk, offset);
+            offset += chunk.length;
+          });
+          const base64 = btoa(
+            Array.from(combinedArray, (byte) => String.fromCharCode(byte)).join(
+              ""
+            )
+          );
+          const dataUrl = `data:${chunks.mimeType};base64,${base64}`;
+          setCurrent({
+            src: dataUrl,
+            res: highestRes.res
+          });
+        } else {
+          console.warn("No chunks available for image", image.id);
+          setCurrent({
+            src: update?.placeholderDataURL,
+            res: "placeholder"
+          });
+        }
+      } else if (!highestRes) {
+        setCurrent({
+          src: update?.placeholderDataURL,
+          res: "placeholder"
+        });
+      }
+    });
+    return unsub;
+  }, [image?.id, maxWidth]);
+  return {
+    src: current?.src,
+    res: current?.res,
+    originalSize: image?.originalSize
+  };
+}
+function ProgressiveImgNative({
+  children,
+  image,
+  maxWidth,
+  targetWidth
+}) {
+  const result = useProgressiveImgNative({ image, maxWidth, targetWidth });
+  return result && children(result);
+}
+
+// src/react-native-core/index.ts
+import { SQLiteDatabaseDriverAsync as SQLiteDatabaseDriverAsync2 } from "cojson-storage";
+import { parseInviteLink as parseInviteLink2 } from "jazz-tools";
+export {
+  DemoAuthBasicUI,
+  JazzProviderCore,
+  KvStoreContext,
+  ProgressiveImgNative,
+  SQLiteDatabaseDriverAsync2 as SQLiteDatabaseDriverAsync,
+  clearUserCredentials,
+  createInviteLink,
+  experimental_useInboxSender,
+  parseInviteLink2 as parseInviteLink,
+  setupKvStore,
+  useAcceptInviteNative,
+  useAccount,
+  useAuthSecretStorage,
+  useCoState,
+  useDemoAuth,
+  useIsAuthenticated,
+  useJazzContext2 as useJazzContext,
+  usePassphraseAuth,
+  useProgressiveImgNative
+};
+//# sourceMappingURL=index.js.map