@powerhousedao/connect 1.0.16-dev.0 → 1.0.16-dev.2

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

@@ -1,250 +0,0 @@
-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
-};

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

@@ -1,17 +0,0 @@
-// ../../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-Y2AV245J.js

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

@@ -1,25 +0,0 @@
-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

@@ -1,52 +0,0 @@
-// ../../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

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

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

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

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

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

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

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

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

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

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

@@ -1,96 +0,0 @@
-import "../chunk-2ESYSVXG.js";
-
-// ../../packages/reactor-browser/dist/src/hooks/document-state.js
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-function useDocumentsState(args) {
-  const { reactor, driveId, documentIds, options } = args;
-  const [statesByDocumentId, setStatesByDocumentId] = useState({});
-  const isInitialized = useRef(false);
-  const isSubscribed = useRef(false);
-  useEffect(() => {
-    async function initialize() {
-      if (isInitialized.current)
-        return;
-      if (!reactor || !driveId)
-        return;
-      isInitialized.current = true;
-      const ids = documentIds ?? await reactor.getDocuments(driveId);
-      const statesByDocumentId2 = {};
-      for (const id of ids) {
-        const document = await reactor.getDocument(driveId, id, options);
-        statesByDocumentId2[id] = {
-          ...document.state,
-          documentType: document.documentType,
-          revision: document.revision,
-          created: document.created,
-          lastModified: document.lastModified
-        };
-      }
-      setStatesByDocumentId(statesByDocumentId2);
-    }
-    void initialize();
-  }, [reactor, driveId, options]);
-  useEffect(() => {
-    if (!reactor || !driveId)
-      return;
-    if (isSubscribed.current)
-      return;
-    isSubscribed.current = true;
-    const unsubscribe = reactor.on("strandUpdate", async (update) => {
-      if (update.driveId !== driveId || documentIds && !documentIds.includes(update.documentId))
-        return;
-      const updatedDocument = await reactor.getDocument(driveId, update.documentId, options);
-      setStatesByDocumentId((prev) => {
-        const newStatesByDocumentId = { ...prev };
-        newStatesByDocumentId[update.documentId] = {
-          ...updatedDocument.state,
-          documentType: updatedDocument.documentType,
-          revision: updatedDocument.revision,
-          created: updatedDocument.created,
-          lastModified: updatedDocument.lastModified
-        };
-        return newStatesByDocumentId;
-      });
-    });
-    return unsubscribe;
-  }, [reactor, driveId, options]);
-  return useMemo(() => statesByDocumentId, [statesByDocumentId]);
-}
-function makeDriveDocumentStatesHook(reactor) {
-  const useDriveDocumentStates = useCallback((args) => {
-    const { driveId, documentIds, options } = args;
-    return useDocumentsState({
-      reactor,
-      driveId,
-      documentIds,
-      options
-    });
-  }, [reactor]);
-  return useDriveDocumentStates;
-}
-function makeDriveDocumentStateHook(reactor) {
-  const useDriveDocumentState = useCallback((args) => {
-    const { driveId, documentId } = args;
-    return useDocumentState({
-      reactor,
-      driveId,
-      documentId
-    });
-  }, [reactor]);
-  return useDriveDocumentState;
-}
-function useDocumentState(args) {
-  const { reactor, driveId, documentId } = args;
-  const state = useDocumentsState({
-    reactor,
-    driveId,
-    documentIds: [documentId]
-  });
-  return useMemo(() => state[documentId], [state, documentId]);
-}
-export {
-  makeDriveDocumentStateHook,
-  makeDriveDocumentStatesHook,
-  useDocumentState,
-  useDocumentsState
-};