@powerhousedao/connect 1.0.4 → 1.0.6-dev.0

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
+};