@powerhousedao/connect 1.0.4 → 1.0.5-dev.0

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-NHD6VUCD.js

@@ -0,0 +1,53 @@
+import {
+  addActionContext,
+  signOperation
+} from "./chunk-IQTSFTNF.js";
+import {
+  useAddDebouncedOperations
+} from "./chunk-CO2RVWYY.js";
+import {
+  useConnectCrypto,
+  useConnectDid
+} from "./chunk-2ONJ2PX4.js";
+import {
+  useDocumentDispatch
+} from "./chunk-GDP7BUIH.js";
+
+// ../../packages/reactor-browser/dist/src/hooks/useDocumentEditor.js
+function useDocumentEditorProps(reactor, props) {
+  const { nodeId, driveId, documentModelModule, document: initialDocument, user, connectDid, sign } = props;
+  const addDebouncedOprations = useAddDebouncedOperations(reactor, {
+    driveId,
+    documentId: nodeId
+  });
+  const [document, _dispatch, error] = useDocumentDispatch(documentModelModule.reducer, initialDocument);
+  function dispatch(action, onErrorCallback) {
+    const callback = (operation, state) => {
+      const { prevState } = state;
+      signOperation(operation, sign, nodeId, prevState, documentModelModule.reducer, user).then((op) => {
+        return addDebouncedOprations(op);
+      }).catch(console.error);
+    };
+    _dispatch(addActionContext(action, connectDid, user), callback, onErrorCallback);
+  }
+  return {
+    dispatch,
+    document,
+    error
+  };
+}
+function useDocumentEditor(reactor, props) {
+  const connectDid = useConnectDid();
+  const { sign } = useConnectCrypto();
+  const documentEditorDispatch = useDocumentEditorProps(reactor, {
+    ...props,
+    connectDid,
+    sign
+  });
+  return documentEditorDispatch;
+}
+
+export {
+  useDocumentEditorProps,
+  useDocumentEditor
+};

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-RGIB4DD4.js

@@ -0,0 +1,162 @@
+import {
+  DRIVE,
+  FILE
+} from "./chunk-7OQWVUC5.js";
+
+// ../../packages/reactor-browser/dist/src/hooks/useUiNodesContext.js
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
+var defaultTreeItemContextValue = {
+  driveNodes: [],
+  selectedNode: null,
+  selectedNodePath: [],
+  selectedDriveNode: null,
+  selectedParentNode: null,
+  setDriveNodes: () => {
+  },
+  setSelectedNode: () => {
+  },
+  getNodeById: () => null,
+  getParentNode: () => null,
+  getIsSelected: () => false,
+  getIsInSelectedNodePath: () => false,
+  getSiblings: () => []
+};
+var UiNodesContext = createContext(defaultTreeItemContextValue);
+var UiNodesContextProvider = ({ children }) => {
+  const [driveNodes, setDriveNodes] = useState([]);
+  const [selectedNode, _setSelectedNode] = useState(null);
+  const [selectedNodePath, setSelectedNodePath] = useState([]);
+  const [selectedDriveNode, setSelectedDriveNode] = useState(null);
+  const [selectedParentNode, setSelectedParentNode] = useState(null);
+  const _getNodeById = useCallback((id, driveNodes2) => {
+    if (!driveNodes2?.length)
+      return null;
+    for (const driveNode of driveNodes2) {
+      if (driveNode.id === id)
+        return driveNode;
+      const node = driveNode.nodeMap[id];
+      if (node)
+        return node;
+    }
+    return null;
+  }, []);
+  const getNodeById = useCallback((id) => {
+    return _getNodeById(id, driveNodes);
+  }, [_getNodeById, driveNodes]);
+  const getSelectedDriveNode = useCallback((selectedNode2, driveNodes2) => {
+    if (!selectedNode2 || !driveNodes2?.length)
+      return null;
+    if (selectedNode2.kind === DRIVE)
+      return selectedNode2;
+    return driveNodes2.find((d) => d.id === selectedNode2.driveId) ?? null;
+  }, []);
+  const _getParentNode = useCallback((node, driveNodes2) => {
+    if (!driveNodes2?.length || node.kind === DRIVE) {
+      return null;
+    }
+    const parentNode = _getNodeById(node.parentFolder, driveNodes2);
+    if (!parentNode)
+      return null;
+    if (parentNode.kind === FILE) {
+      throw new Error(`Parent node ${node.parentFolder} is a file, not a folder`);
+    }
+    return parentNode;
+  }, [_getNodeById]);
+  const getParentNode = useCallback((uiNode) => {
+    return _getParentNode(uiNode, driveNodes);
+  }, [_getParentNode, driveNodes]);
+  const getSelectedParentNode = useCallback((selectedNode2, driveNodes2) => {
+    if (!selectedNode2 || !driveNodes2?.length)
+      return null;
+    if (selectedNode2.kind === FILE)
+      return _getParentNode(selectedNode2, driveNodes2);
+    return selectedNode2;
+  }, [_getParentNode]);
+  const getPathToNode = useCallback((uiNode, driveNodes2) => {
+    const path = [];
+    const driveNode = driveNodes2.find((d) => d.id === uiNode.driveId);
+    let current = uiNode;
+    while (current) {
+      path.push(current);
+      current = current.parentFolder === driveNode?.id ? driveNode : current.parentFolder ? driveNode?.nodeMap[current.parentFolder] : void 0;
+    }
+    return path.reverse();
+  }, []);
+  const setSelectedNode = useCallback((uiNode) => {
+    _setSelectedNode(uiNode);
+    setSelectedDriveNode(getSelectedDriveNode(uiNode, driveNodes));
+    setSelectedParentNode(getSelectedParentNode(uiNode, driveNodes));
+    if (!uiNode) {
+      setSelectedNodePath([]);
+      return;
+    }
+    if (uiNode.kind === DRIVE) {
+      setSelectedNodePath([uiNode]);
+      return;
+    }
+    const newSelectedNodePath = getPathToNode(uiNode, driveNodes);
+    setSelectedNodePath(newSelectedNodePath);
+  }, [driveNodes, getPathToNode, getSelectedDriveNode, getSelectedParentNode]);
+  const getIsSelected = useCallback((node) => {
+    return selectedNode === node;
+  }, [selectedNode]);
+  const getIsInSelectedNodePath = useCallback((node) => {
+    if (node.kind === FILE)
+      return false;
+    return selectedNodePath.includes(node);
+  }, [selectedNodePath]);
+  const getSiblings = useCallback((node) => {
+    if (node.kind === DRIVE) {
+      console.warn("Drive nodes do not have siblings, as they are top-level nodes");
+      return [];
+    }
+    const parent = _getParentNode(node, driveNodes);
+    return parent?.children ?? [];
+  }, [_getParentNode, driveNodes]);
+  useEffect(() => {
+    if (!selectedNode)
+      return;
+    const updatedSelectedNode = _getNodeById(selectedNode.id, driveNodes);
+    if (updatedSelectedNode) {
+      setSelectedNode(updatedSelectedNode);
+    }
+  }, [driveNodes, _getNodeById, selectedNode, setSelectedNode]);
+  const value = useMemo(() => ({
+    driveNodes,
+    selectedNode,
+    selectedNodePath,
+    selectedDriveNode,
+    selectedParentNode,
+    getNodeById,
+    getParentNode,
+    setDriveNodes,
+    setSelectedNode,
+    getIsSelected,
+    getIsInSelectedNodePath,
+    getSiblings
+  }), [
+    driveNodes,
+    selectedNode,
+    selectedNodePath,
+    selectedDriveNode,
+    selectedParentNode,
+    getNodeById,
+    getParentNode,
+    setSelectedNode,
+    getIsSelected,
+    getIsInSelectedNodePath,
+    getSiblings
+  ]);
+  return _jsx(UiNodesContext.Provider, { value, children });
+};
+var useUiNodesContext = () => {
+  const contextValue = useContext(UiNodesContext);
+  return contextValue;
+};
+
+export {
+  UiNodesContext,
+  UiNodesContextProvider,
+  useUiNodesContext
+};

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

@@ -0,0 +1,250 @@
+import {
+  atom,
+  useAtom
+} from "./chunk-C7QRY43M.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.20_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
+};