@powerhousedao/connect 1.0.0 → 1.0.8

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

@@ -0,0 +1,50 @@
+import {
+  atom,
+  useAtom
+} from "./chunk-FW7N6EJH.js";
+import {
+  BrowserKeyStorage
+} from "./chunk-YWKVPJNL.js";
+import {
+  ConnectCrypto
+} from "./chunk-2X2M6BYG.js";
+
+// ../../packages/reactor-browser/dist/src/hooks/useConnectCrypto.js
+import { useEffect, useMemo } from "react";
+var connectCrypto = (async () => {
+  const connectCrypto2 = new ConnectCrypto(new BrowserKeyStorage());
+  await connectCrypto2.did();
+  return connectCrypto2;
+})();
+function useConnectCrypto() {
+  return useMemo(() => ({
+    async regenerateDid() {
+      const crypto = await connectCrypto;
+      return crypto.regenerateDid();
+    },
+    async did() {
+      const crypto = await connectCrypto;
+      return crypto.did();
+    },
+    sign: async (data) => {
+      const crypto = await connectCrypto;
+      return await crypto.sign(data);
+    }
+  }), []);
+}
+var didAtom = atom(void 0);
+function useConnectDid() {
+  const [did, setDid] = useAtom(didAtom);
+  useEffect(() => {
+    if (did) {
+      return;
+    }
+    connectCrypto.then((c) => c.did()).then((did2) => setDid(did2)).catch(console.error);
+  });
+  return did;
+}
+
+export {
+  useConnectCrypto,
+  useConnectDid
+};

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

@@ -0,0 +1,250 @@
+import {
+  atom,
+  useAtom
+} from "./chunk-FW7N6EJH.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.18_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-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-P46ZMPJ3.js

@@ -0,0 +1,178 @@
+import {
+  useUserPermissions
+} from "./chunk-OVGOA2P5.js";
+import {
+  drivesToHash
+} from "./chunk-P6NJ6IAQ.js";
+import {
+  ReadDriveNotFoundError
+} from "./chunk-YOX3ZAET.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
+};