@powerhousedao/connect 1.0.0 → 1.0.3-dev.0

package/dist/modules/@powerhousedao/reactor-browser/chunk-G6LMXRY5.js

@@ -0,0 +1,50 @@
+import {
+  atom,
+  useAtom
+} from "./chunk-FW7N6EJH.js";
+import {
+  BrowserKeyStorage
+} from "./chunk-YWKVPJNL.js";
+import {
+  ConnectCrypto
+} from "./chunk-2X2M6BYG.js";
+
+// ../../packages/reactor-browser/dist/src/hooks/useConnectCrypto.js
+import { useEffect, useMemo } from "react";
+var connectCrypto = (async () => {
+  const connectCrypto2 = new ConnectCrypto(new BrowserKeyStorage());
+  await connectCrypto2.did();
+  return connectCrypto2;
+})();
+function useConnectCrypto() {
+  return useMemo(() => ({
+    async regenerateDid() {
+      const crypto = await connectCrypto;
+      return crypto.regenerateDid();
+    },
+    async did() {
+      const crypto = await connectCrypto;
+      return crypto.did();
+    },
+    sign: async (data) => {
+      const crypto = await connectCrypto;
+      return await crypto.sign(data);
+    }
+  }), []);
+}
+var didAtom = atom(void 0);
+function useConnectDid() {
+  const [did, setDid] = useAtom(didAtom);
+  useEffect(() => {
+    if (did) {
+      return;
+    }
+    connectCrypto.then((c) => c.did()).then((did2) => setDid(did2)).catch(console.error);
+  });
+  return did;
+}
+
+export {
+  useConnectCrypto,
+  useConnectDid
+};

package/dist/modules/@powerhousedao/reactor-browser/chunk-GDP7BUIH.js

@@ -0,0 +1,45 @@
+// ../../packages/reactor-browser/dist/src/hooks/useDocumentDispatch.js
+import { useEffect, useState } from "react";
+function useDocumentDispatch(documentReducer, initialState, onError = console.error) {
+  const [state, setState] = useState(initialState);
+  const [error, setError] = useState();
+  const onErrorHandler = (error2) => {
+    setError(error2);
+    onError(error2);
+  };
+  useEffect(() => {
+    setState(initialState);
+  }, [initialState]);
+  const dispatch = (action, callback, onErrorCallback) => {
+    setError(void 0);
+    setState((_state) => {
+      if (!documentReducer || !_state)
+        return _state;
+      try {
+        const newState = documentReducer(_state, action);
+        const scope = action.scope ?? "global";
+        const operations = newState.operations[scope];
+        const operation = operations[operations.length - 1];
+        if (operation.error) {
+          const error2 = new Error(operation.error);
+          onErrorHandler(error2);
+          onErrorCallback?.(error2);
+        }
+        callback?.(operation, {
+          prevState: { ..._state },
+          newState: { ...newState }
+        });
+        return newState;
+      } catch (error2) {
+        onErrorHandler(error2);
+        onErrorCallback?.(error2);
+        return _state;
+      }
+    });
+  };
+  return [state, dispatch, error];
+}
+
+export {
+  useDocumentDispatch
+};

package/dist/modules/@powerhousedao/reactor-browser/chunk-IQTSFTNF.js

@@ -0,0 +1,48 @@
+import {
+  buildSignedOperation
+} from "./chunk-FQF4YAVC.js";
+
+// ../../packages/reactor-browser/dist/src/utils/signature.js
+async function signOperation(operation, sign, documentId, document, reducer, user) {
+  if (!user)
+    return operation;
+  if (!operation.context)
+    return operation;
+  if (!operation.context.signer)
+    return operation;
+  if (!reducer) {
+    console.error(`Document model '${document.documentType}' does not have a reducer`);
+    return operation;
+  }
+  const context = {
+    documentId,
+    signer: operation.context.signer
+  };
+  const signedOperation = await buildSignedOperation(operation, reducer, document, context, sign);
+  return signedOperation;
+}
+function addActionContext(action, connectDid, user) {
+  if (!user)
+    return action;
+  const signer = {
+    app: {
+      name: "Connect",
+      key: connectDid || ""
+    },
+    user: {
+      address: user.address,
+      networkId: user.networkId,
+      chainId: user.chainId
+    },
+    signatures: []
+  };
+  return {
+    context: { signer },
+    ...action
+  };
+}
+
+export {
+  signOperation,
+  addActionContext
+};

package/dist/modules/@powerhousedao/reactor-browser/chunk-J5TYPY7U.js

@@ -0,0 +1,36 @@
+// ../../packages/reactor-browser/dist/src/hooks/useDocument.js
+import { useCallback, useEffect, useState } from "react";
+function useDocument(reactor, documentMeta = {}) {
+  const { documentId, documentType, driveId } = documentMeta;
+  const [document, setDocument] = useState();
+  const onStrandUpdate = useCallback((cb) => {
+    if (!reactor) {
+      throw new Error("Reactor is not loaded");
+    }
+    return reactor.on("strandUpdate", cb);
+  }, [reactor]);
+  useEffect(() => {
+    if (!reactor)
+      return;
+    if (!driveId || !documentId || !documentType)
+      return;
+    reactor.getDocument(driveId, documentId).then(setDocument).catch(console.error);
+  }, [driveId, documentId, documentType, reactor]);
+  useEffect(() => {
+    if (!reactor)
+      return;
+    if (!driveId || !documentId || !documentType)
+      return;
+    const removeListener = onStrandUpdate((strand) => {
+      if (strand.driveId === driveId && strand.documentId === documentId) {
+        reactor.getDocument(driveId, documentId).then(setDocument).catch(console.error);
+      }
+    });
+    return removeListener;
+  }, [onStrandUpdate, driveId, documentId, documentType]);
+  return document;
+}
+
+export {
+  useDocument
+};

package/dist/modules/@powerhousedao/reactor-browser/chunk-LRNZZ3SR.js

@@ -0,0 +1,14 @@
+import {
+  documentModelDocumentModelModule
+} from "./chunk-FQF4YAVC.js";
+
+// ../../packages/reactor-browser/dist/src/document-model.js
+var baseDocumentModelsMap = {
+  DocumentModel: documentModelDocumentModelModule
+};
+var baseDocumentModels = Object.values(baseDocumentModelsMap);
+
+export {
+  baseDocumentModelsMap,
+  baseDocumentModels
+};

package/dist/modules/@powerhousedao/reactor-browser/chunk-M2UUQ5LH.js

@@ -0,0 +1,250 @@
+import {
+  atom,
+  useAtom
+} from "./chunk-FW7N6EJH.js";
+import {
+  documentToHash
+} from "./chunk-P6NJ6IAQ.js";
+
+// ../../packages/reactor-browser/dist/src/hooks/useDocumentDrives.js
+import { useMemo, useCallback } from "react";
+
+// ../../node_modules/.pnpm/jotai@2.12.2_@types+react@18.3.18_react@18.3.1/node_modules/jotai/esm/vanilla/utils.mjs
+var RESET = Symbol(
+  (import.meta.env ? import.meta.env.MODE : void 0) !== "production" ? "RESET" : ""
+);
+function atomFamily(initializeAtom, areEqual) {
+  let shouldRemove = null;
+  const atoms = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const createAtom = (param) => {
+    let item;
+    if (areEqual === void 0) {
+      item = atoms.get(param);
+    } else {
+      for (const [key, value] of atoms) {
+        if (areEqual(key, param)) {
+          item = value;
+          break;
+        }
+      }
+    }
+    if (item !== void 0) {
+      if (shouldRemove == null ? void 0 : shouldRemove(item[1], param)) {
+        createAtom.remove(param);
+      } else {
+        return item[0];
+      }
+    }
+    const newAtom = initializeAtom(param);
+    atoms.set(param, [newAtom, Date.now()]);
+    notifyListeners("CREATE", param, newAtom);
+    return newAtom;
+  };
+  const notifyListeners = (type, param, atom2) => {
+    for (const listener of listeners) {
+      listener({ type, param, atom: atom2 });
+    }
+  };
+  createAtom.unstable_listen = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
+  createAtom.getParams = () => atoms.keys();
+  createAtom.remove = (param) => {
+    if (areEqual === void 0) {
+      if (!atoms.has(param)) return;
+      const [atom2] = atoms.get(param);
+      atoms.delete(param);
+      notifyListeners("REMOVE", param, atom2);
+    } else {
+      for (const [key, [atom2]] of atoms) {
+        if (areEqual(key, param)) {
+          atoms.delete(key);
+          notifyListeners("REMOVE", key, atom2);
+          break;
+        }
+      }
+    }
+  };
+  createAtom.setShouldRemove = (fn) => {
+    shouldRemove = fn;
+    if (!shouldRemove) return;
+    for (const [key, [atom2, createdAt]] of atoms) {
+      if (shouldRemove(createdAt, key)) {
+        atoms.delete(key);
+        notifyListeners("REMOVE", key, atom2);
+      }
+    }
+  };
+  return createAtom;
+}
+var isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
+function createJSONStorage(getStringStorage = () => {
+  try {
+    return window.localStorage;
+  } catch (e) {
+    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
+      if (typeof window !== "undefined") {
+        console.warn(e);
+      }
+    }
+    return void 0;
+  }
+}, options) {
+  var _a;
+  let lastStr;
+  let lastValue;
+  const storage = {
+    getItem: (key, initialValue) => {
+      var _a2, _b;
+      const parse = (str2) => {
+        str2 = str2 || "";
+        if (lastStr !== str2) {
+          try {
+            lastValue = JSON.parse(str2, options == null ? void 0 : options.reviver);
+          } catch (e) {
+            return initialValue;
+          }
+          lastStr = str2;
+        }
+        return lastValue;
+      };
+      const str = (_b = (_a2 = getStringStorage()) == null ? void 0 : _a2.getItem(key)) != null ? _b : null;
+      if (isPromiseLike(str)) {
+        return str.then(parse);
+      }
+      return parse(str);
+    },
+    setItem: (key, newValue) => {
+      var _a2;
+      return (_a2 = getStringStorage()) == null ? void 0 : _a2.setItem(
+        key,
+        JSON.stringify(newValue, options == null ? void 0 : options.replacer)
+      );
+    },
+    removeItem: (key) => {
+      var _a2;
+      return (_a2 = getStringStorage()) == null ? void 0 : _a2.removeItem(key);
+    }
+  };
+  const createHandleSubscribe = (subscriber2) => (key, callback, initialValue) => subscriber2(key, (v) => {
+    let newValue;
+    try {
+      newValue = JSON.parse(v || "");
+    } catch (e) {
+      newValue = initialValue;
+    }
+    callback(newValue);
+  });
+  let subscriber;
+  try {
+    subscriber = (_a = getStringStorage()) == null ? void 0 : _a.subscribe;
+  } catch (e) {
+  }
+  if (!subscriber && typeof window !== "undefined" && typeof window.addEventListener === "function" && window.Storage) {
+    subscriber = (key, callback) => {
+      if (!(getStringStorage() instanceof window.Storage)) {
+        return () => {
+        };
+      }
+      const storageEventCallback = (e) => {
+        if (e.storageArea === getStringStorage() && e.key === key) {
+          callback(e.newValue);
+        }
+      };
+      window.addEventListener("storage", storageEventCallback);
+      return () => {
+        window.removeEventListener("storage", storageEventCallback);
+      };
+    };
+  }
+  if (subscriber) {
+    storage.subscribe = createHandleSubscribe(subscriber);
+  }
+  return storage;
+}
+var defaultStorage = createJSONStorage();
+
+// ../../packages/reactor-browser/dist/src/hooks/useDocumentDrives.js
+var documentDrivesAtom = atom(/* @__PURE__ */ new Map());
+function drivesToHash(drives) {
+  return drives.map(documentToHash).join("&");
+}
+var readWriteDocumentDrivesAtom = (server) => () => atom((get) => server ? get(documentDrivesAtom).get(server) ?? [] : [], (_get, set, newDrives) => {
+  set(documentDrivesAtom, (map) => {
+    if (!server) {
+      return /* @__PURE__ */ new Map();
+    }
+    const currentDrives = map.get(server) ?? [];
+    if (currentDrives.length !== newDrives.length || drivesToHash(currentDrives) !== drivesToHash(newDrives)) {
+      return new Map(map).set(server, newDrives);
+    } else {
+      return map;
+    }
+  });
+});
+var documentDrivesInitializedMapAtomFamily = atomFamily(() => atom("INITIAL"));
+function useDocumentDrives(reactor) {
+  const [documentDrives, setDocumentDrives] = useAtom(useMemo(readWriteDocumentDrivesAtom(reactor), [reactor]));
+  const refreshDocumentDrives = useCallback(async () => {
+    if (!reactor) {
+      return;
+    }
+    const documentDrives2 = [];
+    try {
+      const driveIds = await reactor.getDrives();
+      for (const id of driveIds) {
+        try {
+          const drive = await reactor.getDrive(id);
+          documentDrives2.push(drive);
+        } catch (error) {
+          console.error(error);
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    } finally {
+      setDocumentDrives(documentDrives2);
+    }
+  }, [reactor]);
+  const [status, setStatus] = useAtom(documentDrivesInitializedMapAtomFamily(reactor));
+  if (status === "INITIAL") {
+    setStatus("LOADING");
+    refreshDocumentDrives().then(() => setStatus("LOADED")).catch(() => setStatus("ERROR"));
+  }
+  const serverSubscribeUpdates = useCallback((clientErrorhandler) => {
+    if (!reactor) {
+      return;
+    }
+    const unsub1 = reactor.on("syncStatus", async (_event, _status, error) => {
+      if (error) {
+        console.error(error);
+      }
+      await refreshDocumentDrives();
+    });
+    const unsub2 = reactor.on("strandUpdate", () => refreshDocumentDrives());
+    const unsubOnSyncError = reactor.on("clientStrandsError", clientErrorhandler.strandsErrorHandler);
+    const unsub3 = reactor.on("defaultRemoteDrive", () => refreshDocumentDrives());
+    return () => {
+      unsub1();
+      unsub2();
+      unsubOnSyncError();
+      unsub3();
+    };
+  }, [reactor, refreshDocumentDrives]);
+  return useMemo(() => [
+    documentDrives,
+    refreshDocumentDrives,
+    serverSubscribeUpdates,
+    status
+  ], [documentDrives, status]);
+}
+
+export {
+  drivesToHash,
+  documentDrivesInitializedMapAtomFamily,
+  useDocumentDrives
+};

package/dist/modules/@powerhousedao/reactor-browser/chunk-OVGOA2P5.js

@@ -0,0 +1,11 @@
+// ../../packages/reactor-browser/dist/src/hooks/useUserPermissions.js
+function useUserPermissions() {
+  return {
+    isAllowedToCreateDocuments: true,
+    isAllowedToEditDocuments: true
+  };
+}
+
+export {
+  useUserPermissions
+};

package/dist/modules/@powerhousedao/reactor-browser/chunk-P6NJ6IAQ.js

@@ -0,0 +1,12 @@
+// ../../packages/reactor-browser/dist/src/utils/index.js
+function documentToHash(drive) {
+  return Object.keys(drive.operations).map((key) => `${key}:${drive.operations[key].length}:${drive.operations[key].at(-1)?.hash}`).join(":");
+}
+function drivesToHash(drives) {
+  return drives.map(documentToHash).join("&");
+}
+
+export {
+  documentToHash,
+  drivesToHash
+};

package/dist/modules/@powerhousedao/reactor-browser/chunk-PQ4UODLR.js

@@ -0,0 +1,113 @@
+import {
+  addFolder,
+  copyNode,
+  deleteNode,
+  generateAddNodeAction,
+  generateNodesCopy,
+  isFileNode,
+  isFolderNode,
+  moveNode,
+  updateNode
+} from "./chunk-A4GIWVYS.js";
+import {
+  generateId
+} from "./chunk-FQF4YAVC.js";
+
+// ../../packages/reactor-browser/dist/src/hooks/useDriveActions.js
+import { useMemo } from "react";
+var generateId2 = () => generateId().toString();
+function getNode(id, drive) {
+  return drive.state.global.nodes.find((node) => node.id === id);
+}
+function createDriveActions(document, dispatch, context) {
+  const drive = document;
+  const { id: driveId } = drive.state.global;
+  const { selectedNode } = context;
+  const handleAddFolder = async (name, parentFolder, id = generateId2()) => {
+    dispatch(addFolder({
+      id,
+      name,
+      parentFolder: parentFolder ?? null
+    }));
+  };
+  const addDocument = async (name, documentType, document2, parentFolder, id = generateId2()) => {
+    const action = generateAddNodeAction(drive.state.global, {
+      id,
+      name,
+      parentFolder: parentFolder ?? null,
+      documentType,
+      document: document2
+    }, ["global"]);
+    dispatch(action);
+  };
+  const addFile = async (file, parentFolder = selectedNode && isFileNode(selectedNode) ? void 0 : selectedNode?.id, name = file.name.replace(/\.zip$/gim, "")) => {
+    const folder = parentFolder ? getNode(parentFolder, drive) : void 0;
+    if (parentFolder && !folder) {
+      throw new Error(`Parent folder with id "${parentFolder}" not found`);
+    }
+    if (folder && !isFolderNode(folder)) {
+      throw new Error(`Parent folder with id "${parentFolder}" is not a folder`);
+    }
+    await context.addFile(file, driveId, name, parentFolder);
+  };
+  const handleDeleteNode = async (id) => {
+    dispatch(deleteNode({ id }));
+  };
+  const renameNode = async (id, name) => {
+    dispatch(updateNode({ id, name }));
+  };
+  const handleMoveNode = async (sourceId, targetId) => {
+    dispatch(moveNode({
+      srcFolder: sourceId,
+      targetParentFolder: targetId
+    }));
+  };
+  const handleCopyNode = async (sourceId, targetFolderId) => {
+    const target = targetFolderId ? getNode(targetFolderId, drive) : void 0;
+    if (targetFolderId && !target) {
+      throw new Error(`Target node with id "${targetFolderId}" not found`);
+    }
+    if (target && !isFolderNode(target)) {
+      throw new Error(`Target node with id "${targetFolderId}" is not a folder`);
+    }
+    const source = getNode(sourceId, drive);
+    if (!source) {
+      throw new Error(`Source node with id "${sourceId}" not found`);
+    }
+    const copyNodesInput = generateNodesCopy({
+      srcId: sourceId,
+      targetParentFolder: target?.id,
+      targetName: source.name
+    }, generateId2, drive.state.global.nodes);
+    const copyActions = copyNodesInput.map((copyNodeInput) => copyNode(copyNodeInput));
+    for (const copyAction of copyActions) {
+      dispatch(copyAction);
+    }
+  };
+  const duplicateNode = async (sourceId) => {
+    const node = getNode(sourceId, drive);
+    if (!node) {
+      throw new Error(`Node with id "${sourceId}" not found`);
+    }
+    await handleCopyNode(node.id, node.parentFolder || void 0);
+  };
+  return {
+    context,
+    selectNode: context.selectNode,
+    addFolder: handleAddFolder,
+    addFile,
+    addDocument,
+    deleteNode: handleDeleteNode,
+    renameNode,
+    moveNode: handleMoveNode,
+    copyNode: handleCopyNode,
+    duplicateNode
+  };
+}
+function useDriveActions(document, dispatch, context) {
+  return useMemo(() => createDriveActions(document, dispatch, context), [document, dispatch, context]);
+}
+
+export {
+  useDriveActions
+};