@powerhousedao/connect 1.0.4 → 1.0.8

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

@@ -0,0 +1,67 @@
+import {
+  useDocumentDrives
+} from "./chunk-M2UUQ5LH.js";
+import {
+  useUserPermissions
+} from "./chunk-OVGOA2P5.js";
+
+// ../../packages/reactor-browser/dist/src/hooks/useAddDebouncedOperations.js
+import { useCallback, useEffect, useMemo, useRef } from "react";
+function debounceOperations(callback, timeout = 50) {
+  let timer;
+  const operations = [];
+  return (operation) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    const index = operations.findIndex((op) => op.scope === operation.scope && op.index === operation.index);
+    if (index > -1) {
+      const oldOperation = operations[index];
+      if (!(oldOperation.type === operation.type && JSON.stringify(operation.input) === JSON.stringify(oldOperation.input))) {
+        console.warn("Two conflicting operations were dispatched:", oldOperation, operation);
+      }
+      operations[index] = operation;
+    } else {
+      operations.push(operation);
+    }
+    return new Promise((resolve, reject) => {
+      timer = setTimeout(() => {
+        callback(operations).then(resolve).catch(reject);
+      }, timeout);
+    });
+  };
+}
+function useAddDebouncedOperations(reactor, props) {
+  const { driveId, documentId } = props;
+  const [documentDrives] = useDocumentDrives(reactor);
+  const documentDrivesRef = useRef(documentDrives);
+  const { isAllowedToEditDocuments } = useUserPermissions() || {
+    isAllowedToCreateDocuments: false,
+    isAllowedToEditDocuments: false
+  };
+  useEffect(() => {
+    documentDrivesRef.current = documentDrives;
+  }, [documentDrives]);
+  const addOperations = useCallback(async (driveId2, id, operations) => {
+    if (!isAllowedToEditDocuments) {
+      throw new Error("User is not allowed to edit documents");
+    }
+    if (!reactor) {
+      throw new Error("Reactor is not loaded");
+    }
+    const drive = documentDrivesRef.current.find((drive2) => drive2.state.global.id === driveId2);
+    if (!drive) {
+      throw new Error(`Drive with id ${driveId2} not found`);
+    }
+    const newDocument = await reactor.queueOperations(driveId2, id, operations);
+    return newDocument.document;
+  }, [isAllowedToEditDocuments, reactor]);
+  const addDebouncedOperations = useMemo(() => {
+    return debounceOperations((operations) => addOperations(driveId, documentId, operations));
+  }, [addOperations, driveId, documentId]);
+  return addDebouncedOperations;
+}
+
+export {
+  useAddDebouncedOperations
+};

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

@@ -0,0 +1,82 @@
+import {
+  useDriveActions
+} from "./chunk-6AXML2S3.js";
+import {
+  useDriveContext
+} from "./chunk-XBTEGV5M.js";
+import {
+  useUiNodesContext
+} from "./chunk-RGIB4DD4.js";
+import {
+  FILE
+} from "./chunk-7OQWVUC5.js";
+
+// ../../packages/reactor-browser/dist/src/hooks/useDriveActionsWithUiNodes.js
+import { useMemo } from "react";
+function toNode(uiNode) {
+  if (uiNode.kind === "DRIVE") {
+    throw new Error("Cannot convert drive node to regular node");
+  }
+  const { id, name, parentFolder, kind } = uiNode;
+  if (kind === "FOLDER") {
+    return { id, name, parentFolder, kind: "folder" };
+  } else {
+    const fileNode = uiNode;
+    return {
+      id,
+      name,
+      parentFolder,
+      kind: "file",
+      documentType: fileNode.documentType,
+      synchronizationUnits: fileNode.synchronizationUnits
+    };
+  }
+}
+function createUiNodeAdapter(driveActions) {
+  return {
+    ...driveActions,
+    addFile: (file, parentNode) => driveActions.addFile(file, parentNode?.id),
+    addFolder: (name, parentFolder = void 0) => driveActions.addFolder(name, parentFolder),
+    renameNode: (name, node) => {
+      const converted = toNode(node);
+      return driveActions.renameNode(converted.id, name);
+    },
+    deleteNode: (node) => {
+      const converted = toNode(node);
+      return driveActions.deleteNode(converted.id);
+    },
+    moveNode: async (src, target) => {
+      if (target.kind === FILE || src.parentFolder === target.id)
+        return;
+      const srcNode = toNode(src);
+      const targetNode = toNode(target);
+      return driveActions.moveNode(srcNode.id, targetNode.id);
+    },
+    copyNode: (src, target) => {
+      return driveActions.copyNode(src.id, target.id);
+    },
+    duplicateNode: (node) => {
+      const converted = toNode(node);
+      return driveActions.duplicateNode(converted.id);
+    }
+  };
+}
+function useDriveActionsWithUiNodes(document, dispatch) {
+  const { selectedNode, selectedDriveNode, setSelectedNode, getNodeById } = useUiNodesContext();
+  const _driveContext = useDriveContext();
+  const driveContext = useMemo(() => ({
+    ..._driveContext,
+    selectedNode,
+    onSelectNode: (node) => {
+      _driveContext.selectNode(node);
+      setSelectedNode(getNodeById(node.id));
+    }
+  }), [selectedNode, selectedDriveNode?.driveId, setSelectedNode, getNodeById]);
+  const driveActions = useDriveActions(document, dispatch, driveContext);
+  const uiNodeActions = useMemo(() => createUiNodeAdapter(driveActions), [driveActions]);
+  return uiNodeActions;
+}
+
+export {
+  useDriveActionsWithUiNodes
+};

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

@@ -0,0 +1,113 @@
+import {
+  addFolder,
+  copyNode,
+  deleteNode,
+  generateAddNodeAction,
+  generateNodesCopy,
+  isFileNode,
+  isFolderNode,
+  moveNode,
+  updateNode
+} from "./chunk-YOX3ZAET.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
+};

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

@@ -0,0 +1,43 @@
+// ../../packages/reactor-browser/dist/src/uiNodes/constants.js
+var SWITCHBOARD = "SWITCHBOARD";
+var LOCAL = "LOCAL";
+var CLOUD = "CLOUD";
+var PUBLIC = "PUBLIC";
+var sharingTypes = [LOCAL, CLOUD, PUBLIC];
+var driveLocations = [LOCAL, CLOUD, SWITCHBOARD];
+var DRIVE = "DRIVE";
+var FILE = "FILE";
+var FOLDER = "FOLDER";
+var SYNCING = "SYNCING";
+var SUCCESS = "SUCCESS";
+var CONFLICT = "CONFLICT";
+var MISSING = "MISSING";
+var ERROR = "ERROR";
+var INITIAL_SYNC = "INITIAL_SYNC";
+var syncStatuses = [
+  INITIAL_SYNC,
+  SYNCING,
+  SUCCESS,
+  CONFLICT,
+  MISSING,
+  ERROR
+];
+
+export {
+  SWITCHBOARD,
+  LOCAL,
+  CLOUD,
+  PUBLIC,
+  sharingTypes,
+  driveLocations,
+  DRIVE,
+  FILE,
+  FOLDER,
+  SYNCING,
+  SUCCESS,
+  CONFLICT,
+  MISSING,
+  ERROR,
+  INITIAL_SYNC,
+  syncStatuses
+};

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

@@ -0,0 +1,53 @@
+import {
+  addActionContext,
+  signOperation
+} from "./chunk-IQTSFTNF.js";
+import {
+  useAddDebouncedOperations
+} from "./chunk-45DCPCA7.js";
+import {
+  useConnectCrypto,
+  useConnectDid
+} from "./chunk-G6LMXRY5.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
+};