@powerhousedao/connect 1.0.4 → 1.0.9-dev.0

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

@@ -0,0 +1,178 @@
+import {
+  useUserPermissions
+} from "./chunk-OVGOA2P5.js";
+import {
+  drivesToHash
+} from "./chunk-P6NJ6IAQ.js";
+import {
+  ReadDriveNotFoundError
+} from "./chunk-N5UNGAA6.js";
+
+// ../../packages/reactor-browser/dist/src/context/read-mode.js
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var logger = {
+  error: console.error
+};
+function checkServer(target, propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  descriptor.value = function(...args) {
+    if (!this.server) {
+      throw new Error("Read mode document drive not initialized.");
+    }
+    return originalMethod.apply(this, args);
+  };
+}
+function bindClassMethods(instance) {
+  const prototype = Object.getPrototypeOf(instance);
+  const propertyNames = Object.getOwnPropertyNames(prototype);
+  propertyNames.forEach((name) => {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+    if (descriptor && typeof descriptor.value === "function" && name !== "constructor") {
+      instance[name] = instance[name].bind(instance);
+    }
+  });
+}
+var ReadModeContextImpl = class {
+  server;
+  constructor(documentDrive) {
+    bindClassMethods(this);
+    this.server = documentDrive;
+  }
+  getServer() {
+    return this.server;
+  }
+  setDocumentDrive(documentDrive) {
+    this.server = documentDrive;
+  }
+  /* eslint-disable @typescript-eslint/no-non-null-assertion */
+  migrateReadDrive(id, options) {
+    return this.server.migrateReadDrive(id, options);
+  }
+  addReadDrive(url, options) {
+    return this.server.addReadDrive(url, options);
+  }
+  getReadDrives() {
+    return this.server.getReadDrives();
+  }
+  getReadDriveBySlug(slug) {
+    return this.server.getReadDriveBySlug(slug);
+  }
+  getReadDrive(id) {
+    return this.server.getReadDrive(id);
+  }
+  getReadDriveContext(id) {
+    return this.server.getReadDriveContext(id);
+  }
+  fetchDrive(id) {
+    return this.server.fetchDrive(id);
+  }
+  fetchDocument(driveId, documentId, documentType) {
+    return this.server.fetchDocument(driveId, documentId, documentType);
+  }
+  deleteReadDrive(id) {
+    return this.server.deleteReadDrive(id);
+  }
+  onReadDrivesUpdate(listener) {
+    return this.server.onReadDrivesUpdate(listener);
+  }
+};
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "migrateReadDrive", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "addReadDrive", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "getReadDrives", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "getReadDriveBySlug", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "getReadDrive", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "getReadDriveContext", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "fetchDrive", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "fetchDocument", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "deleteReadDrive", null);
+__decorate([
+  checkServer
+], ReadModeContextImpl.prototype, "onReadDrivesUpdate", null);
+var ReadModeInstance = new ReadModeContextImpl();
+var ReadModeContext = createContext({
+  ...ReadModeInstance,
+  readDrives: []
+});
+async function getReadDrives(instance) {
+  const driveIds = await instance.getReadDrives();
+  const drives = await Promise.all(driveIds.map((id) => instance.getReadDrive(id)));
+  return drives.filter((drive) => !(drive instanceof ReadDriveNotFoundError));
+}
+var ReadModeContextProvider = (props) => {
+  const { reactorPromise, ...restProps } = props;
+  const [readDrives, setReadDrives] = useState([]);
+  const userPermissions = useUserPermissions();
+  const [ready, setReady] = useState(false);
+  useEffect(() => {
+    reactorPromise.then((reactor) => {
+      ReadModeInstance.setDocumentDrive(reactor);
+      setReady(true);
+    }).catch(logger.error);
+  }, [reactorPromise]);
+  const readMode = userPermissions === void 0 ? void 0 : !(userPermissions.isAllowedToCreateDocuments || userPermissions.isAllowedToEditDocuments);
+  useMemo(() => {
+    if (!ready || readMode === void 0) {
+      return;
+    }
+    const accessLevel = readMode ? "READ" : "WRITE";
+    const server = ReadModeInstance.getServer();
+    if (server && typeof server.setAllDefaultDrivesAccessLevel === "function") {
+      server.setAllDefaultDrivesAccessLevel(accessLevel).catch(logger.error);
+    }
+  }, [readMode, ready]);
+  useEffect(() => {
+    if (!ready) {
+      return;
+    }
+    getReadDrives(ReadModeInstance).then((drives) => setReadDrives(drives)).catch(logger.error);
+    const unsubscribe = ReadModeInstance.onReadDrivesUpdate((newDrives) => {
+      setReadDrives((readDrives2) => readDrives2.length !== newDrives.length || drivesToHash(readDrives2) !== drivesToHash(newDrives) ? newDrives : readDrives2);
+    }).catch(logger.error);
+    return () => {
+      unsubscribe.then((unsub) => {
+        if (typeof unsub === "function") {
+          unsub();
+        }
+      }).catch(logger.error);
+    };
+  }, [ready]);
+  const context = useMemo(() => {
+    return {
+      ...ReadModeInstance,
+      readDrives
+    };
+  }, [readDrives]);
+  return _jsx(ReadModeContext.Provider, { ...restProps, value: context });
+};
+var useReadModeContext = () => useContext(ReadModeContext);
+
+export {
+  ReadModeContext,
+  ReadModeContextProvider,
+  useReadModeContext
+};

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

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

@@ -0,0 +1,17 @@
+// ../../packages/reactor-browser/dist/src/hooks/useDriveContext.js
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+var DriveContext = createContext(void 0);
+var DriveContextProvider = ({ value, children }) => _jsx(DriveContext.Provider, { value, children });
+function useDriveContext() {
+  const context = useContext(DriveContext);
+  if (!context) {
+    throw new Error("useDriveContext must be used within a DriveContextProvider");
+  }
+  return context;
+}
+
+export {
+  DriveContextProvider,
+  useDriveContext
+};

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

@@ -0,0 +1,25 @@
+import {
+  createZip
+} from "./chunk-FQF4YAVC.js";
+
+// ../../packages/reactor-browser/dist/src/utils/export-document.js
+var exportDocument = async (document, name, extension) => {
+  const zip = createZip(document);
+  const ext = extension ? `.${extension.replace(/^\./, "")}` : "";
+  try {
+    const blob = await zip.generateAsync({ type: "blob" });
+    const link = window.document.createElement("a");
+    link.style.display = "none";
+    link.href = URL.createObjectURL(blob);
+    link.download = `${name || document.name || "Untitled"}${ext}.zip`;
+    window.document.body.appendChild(link);
+    link.click();
+    window.document.body.removeChild(link);
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+export {
+  exportDocument
+};

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

@@ -0,0 +1,52 @@
+// ../../packages/reactor-browser/dist/src/crypto/browser.js
+var BrowserKeyStorage = class _BrowserKeyStorage {
+  static #DB_NAME = "browserKeyDB";
+  static #STORE_NAME = "keyPairs";
+  static #KEY = "keyPair";
+  #db;
+  constructor() {
+    this.#db = new Promise((resolve, reject) => {
+      const req = indexedDB.open(_BrowserKeyStorage.#DB_NAME, 1);
+      req.onupgradeneeded = () => {
+        req.result.createObjectStore(_BrowserKeyStorage.#STORE_NAME);
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async #useStore(mode = "readwrite") {
+    const database = await this.#db;
+    const transaction = database.transaction(_BrowserKeyStorage.#STORE_NAME, mode);
+    const store = transaction.objectStore(_BrowserKeyStorage.#STORE_NAME);
+    return store;
+  }
+  async saveKeyPair(keyPair) {
+    const store = await this.#useStore();
+    const request = store.put(keyPair, _BrowserKeyStorage.#KEY);
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        resolve();
+      };
+      request.onerror = () => {
+        reject(new Error("Failed to save key pair"));
+      };
+    });
+  }
+  async loadKeyPair() {
+    const store = await this.#useStore("readonly");
+    const request = store.getAll();
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        const keyPair = request.result.length ? request.result[0] : void 0;
+        resolve(keyPair);
+      };
+      request.onerror = () => {
+        reject(new Error("Failed to load key pair"));
+      };
+    });
+  }
+};
+
+export {
+  BrowserKeyStorage
+};

package/dist/modules/@powerhousedao/reactor-browser/context/index.js

@@ -0,0 +1,16 @@
+import "../chunk-U36SV333.js";
+import {
+  ReadModeContext,
+  ReadModeContextProvider,
+  useReadModeContext
+} from "../chunk-OYYVE7RP.js";
+import "../chunk-OVGOA2P5.js";
+import "../chunk-P6NJ6IAQ.js";
+import "../chunk-N5UNGAA6.js";
+import "../chunk-FQF4YAVC.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  ReadModeContext,
+  ReadModeContextProvider,
+  useReadModeContext
+};

package/dist/modules/@powerhousedao/reactor-browser/context/read-mode.js

@@ -0,0 +1,15 @@
+import {
+  ReadModeContext,
+  ReadModeContextProvider,
+  useReadModeContext
+} from "../chunk-OYYVE7RP.js";
+import "../chunk-OVGOA2P5.js";
+import "../chunk-P6NJ6IAQ.js";
+import "../chunk-N5UNGAA6.js";
+import "../chunk-FQF4YAVC.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  ReadModeContext,
+  ReadModeContextProvider,
+  useReadModeContext
+};

package/dist/modules/@powerhousedao/reactor-browser/crypto/browser.js

@@ -0,0 +1,7 @@
+import {
+  BrowserKeyStorage
+} from "../chunk-YWKVPJNL.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  BrowserKeyStorage
+};

package/dist/modules/@powerhousedao/reactor-browser/crypto/index.js

@@ -0,0 +1,7 @@
+import {
+  ConnectCrypto
+} from "../chunk-2X2M6BYG.js";
+import "../chunk-2ESYSVXG.js";
+export {
+  ConnectCrypto
+};

package/dist/modules/@powerhousedao/reactor-browser/document-model.js

@@ -0,0 +1,10 @@
+import {
+  baseDocumentModels,
+  baseDocumentModelsMap
+} from "./chunk-LRNZZ3SR.js";
+import "./chunk-FQF4YAVC.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  baseDocumentModels,
+  baseDocumentModelsMap
+};