@powerhousedao/reactor-browser 1.10.2 → 1.11.0

package/dist/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@powerhousedao/reactor-browser",
+    "version": "1.10.2",
+    "license": "AGPL-3.0-only",
+    "type": "module",
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist"
+    ],
+    "types": "./dist/src/index.d.ts",
+    "main": "./dist/src/index.js",
+    "exports": {
+        ".": "./dist/src/index.js",
+        "./*": "./dist/src/*.js"
+    },
+    "scripts": {
+        "build:tsc": "tsc --build",
+        "lint": "eslint .",
+        "lint:nx": "eslint . --fix --quiet",
+        "lint:fix": "eslint --fix",
+        "build": "tsc --build",
+        "build:watch": "tsc --build --watch",
+        "test": "vitest run --passWithNoTests",
+        "clean": "rimraf dist",
+        "clean:node_modules": "rimraf node_modules"
+    },
+    "keywords": [],
+    "author": "",
+    "devDependencies": {
+        "@types/react": "^18.3.1",
+        "@types/react-dom": "^18.3.1",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1"
+    },
+    "peerDependencies": {
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1"
+    },
+    "dependencies": {
+        "document-drive": "workspace:*",
+        "document-model": "workspace:*",
+        "did-key-creator": "^1.2.0",
+        "jotai": "^2.10.3"
+    }
+}

package/dist/src/context/index.d.ts

@@ -1,2 +1,2 @@
-export * from './read-mode';
+export * from "./read-mode.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/context/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/context/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/context/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/src/context/index.js

@@ -0,0 +1 @@
+export * from "./read-mode.js";

package/dist/src/context/read-mode.d.ts

@@ -1,10 +1,10 @@
-import { BaseDocumentDriveServer, IReadModeDriveServer, ReadDrive } from 'document-drive';
-import { FC, ReactNode } from 'react';
+import { BaseDocumentDriveServer, IReadModeDriveServer, ReadDrive } from "document-drive";
+import { FC, ReactNode } from "react";
 export interface IReadModeContext extends IReadModeDriveServer {
     readDrives: ReadDrive[];
     setDocumentDrive(documentDrive: IReadModeDriveServer): void;
 }
-export declare const ReadModeContext: import('react').Context<IReadModeContext>;
+export declare const ReadModeContext: import("react").Context<IReadModeContext>;
 export interface ReadModeContextProviderProps {
     children: ReactNode;
     reactorPromise: Promise<BaseDocumentDriveServer & IReadModeDriveServer>;

package/dist/src/context/read-mode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read-mode.d.ts","sourceRoot":"","sources":["../../../src/context/read-mode.tsx"],"names":[],"mappings":"AAIA,OAAO,EACL,uBAAuB,EAKvB,oBAAoB,EAEpB,SAAS,EAOV,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAEL,EAAE,EACF,SAAS,EAKV,MAAM,OAAO,CAAC;AAkBf,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB;IAC5D,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,gBAAgB,CAAC,aAAa,EAAE,oBAAoB,GAAG,IAAI,CAAC;CAC7D;AAuID,eAAO,MAAM,eAAe,2CAG1B,CAAC;AAEH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,SAAS,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC,uBAAuB,GAAG,oBAAoB,CAAC,CAAC;CACzE;AAcD,eAAO,MAAM,uBAAuB,EAAE,EAAE,CAAC,4BAA4B,CAkFpE,CAAC;AACF,eAAO,MAAM,kBAAkB,wBAAoC,CAAC"}
+{"version":3,"file":"read-mode.d.ts","sourceRoot":"","sources":["../../../src/context/read-mode.tsx"],"names":[],"mappings":"AAIA,OAAO,EACL,uBAAuB,EAEvB,oBAAoB,EAEpB,SAAS,EAOV,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAEL,EAAE,EACF,SAAS,EAKV,MAAM,OAAO,CAAC;AAkBf,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB;IAC5D,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,gBAAgB,CAAC,aAAa,EAAE,oBAAoB,GAAG,IAAI,CAAC;CAC7D;AA+HD,eAAO,MAAM,eAAe,2CAG1B,CAAC;AAEH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,SAAS,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC,uBAAuB,GAAG,oBAAoB,CAAC,CAAC;CACzE;AAcD,eAAO,MAAM,uBAAuB,EAAE,EAAE,CAAC,4BAA4B,CAkFpE,CAAC;AACF,eAAO,MAAM,kBAAkB,wBAAoC,CAAC"}

package/dist/src/context/read-mode.js

@@ -0,0 +1,198 @@
+var __decorate = (this && this.__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;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { ReadDriveNotFoundError, } from "document-drive";
+import { createContext, useContext, useEffect, useMemo, useState, } from "react";
+import { useUserPermissions } from "../hooks/useUserPermissions.js";
+import { drivesToHash } from "../utils/index.js";
+const logger = {
+    error: console.error,
+};
+// TODO: add export of this class from document-drive/src/server/error
+class DocumentModelNotFoundError extends Error {
+    id;
+    constructor(id, cause) {
+        super(`Document model "${id}" not found`, { cause });
+        this.id = id;
+    }
+}
+// decorator method to ensure server is defined before calling it
+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) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    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") {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            instance[name] = instance[name].bind(instance);
+        }
+    });
+}
+class ReadModeContextImpl {
+    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);
+const ReadModeInstance = new ReadModeContextImpl();
+export const 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));
+}
+export const 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]);
+    // updates drive access level when user permissions change
+    const readMode = userPermissions === undefined
+        ? undefined
+        : !(userPermissions.isAllowedToCreateDocuments ||
+            userPermissions.isAllowedToEditDocuments);
+    useMemo(() => {
+        // wait for user initial load
+        if (!ready || readMode === undefined) {
+            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((readDrives) => readDrives.length !== newDrives.length ||
+                drivesToHash(readDrives) !== drivesToHash(newDrives)
+                ? newDrives
+                : readDrives);
+        }).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 });
+};
+export const useReadModeContext = () => useContext(ReadModeContext);

package/dist/src/crypto/browser.d.ts

@@ -1,4 +1,4 @@
-import { JsonWebKeyPairStorage, JwkKeyPair } from './';
+import { JsonWebKeyPairStorage, JwkKeyPair } from "./index.js";
 export declare class BrowserKeyStorage implements JsonWebKeyPairStorage {
     #private;
     constructor();

package/dist/src/crypto/browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/crypto/browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAEvD,qBAAa,iBAAkB,YAAW,qBAAqB;;;IA2BvD,WAAW,CAAC,OAAO,EAAE,UAAU;IAa/B,WAAW,IAAI,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;CAgBrD"}
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/crypto/browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE/D,qBAAa,iBAAkB,YAAW,qBAAqB;;;IA2BvD,WAAW,CAAC,OAAO,EAAE,UAAU;IAa/B,WAAW,IAAI,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;CAgBrD"}

package/dist/src/crypto/browser.js

@@ -0,0 +1,49 @@
+export 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]
+                    : undefined;
+                resolve(keyPair);
+            };
+            request.onerror = () => {
+                reject(new Error("Failed to load key pair"));
+            };
+        });
+    }
+}

package/dist/src/crypto/index.js

@@ -0,0 +1,121 @@
+import { compressedKeyInHexfromRaw, encodeDIDfromHexString, rawKeyInHexfromUncompressed, } from "did-key-creator";
+function ab2hex(ab) {
+    return Array.prototype.map
+        .call(new Uint8Array(ab), (x) => ("00" + x.toString(16)).slice(-2))
+        .join("");
+}
+export class ConnectCrypto {
+    #subtleCrypto;
+    #keyPair;
+    #keyPairStorage;
+    #did;
+    static algorithm = {
+        name: "ECDSA",
+        namedCurve: "P-256",
+    };
+    static signAlgorithm = {
+        name: "ECDSA",
+        namedCurve: "P-256",
+        hash: "SHA-256",
+    };
+    constructor(keyPairStorage) {
+        this.#keyPairStorage = keyPairStorage;
+        // Initializes the subtleCrypto module according to the host environment
+        this.#subtleCrypto = this.#initCrypto();
+        this.#did = this.#initialize();
+    }
+    #initCrypto() {
+        return new Promise((resolve, reject) => {
+            if (typeof window === "undefined") {
+                import("node:crypto")
+                    .then((module) => {
+                    resolve(module.webcrypto.subtle);
+                })
+                    .catch(reject);
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (!window.crypto?.subtle) {
+                    reject(new Error("Crypto module not available"));
+                }
+                resolve(window.crypto.subtle);
+            }
+        });
+    }
+    // loads the key pair from storage or generates a new one if none is stored
+    async #initialize() {
+        const loadedKeyPair = await this.#keyPairStorage.loadKeyPair();
+        if (loadedKeyPair) {
+            this.#keyPair = await this.#importKeyPair(loadedKeyPair);
+            console.log("Found key pair");
+        }
+        else {
+            this.#keyPair = await this.#generateECDSAKeyPair();
+            console.log("Created key pair");
+            await this.#keyPairStorage.saveKeyPair(await this.#exportKeyPair());
+        }
+        const did = await this.#parseDid();
+        console.log("Connect DID:", did);
+        return did;
+    }
+    did() {
+        return this.#did;
+    }
+    async regenerateDid() {
+        this.#keyPair = await this.#generateECDSAKeyPair();
+        await this.#keyPairStorage.saveKeyPair(await this.#exportKeyPair());
+    }
+    async #parseDid() {
+        if (!this.#keyPair) {
+            throw new Error("No key pair available");
+        }
+        const subtleCrypto = await this.#subtleCrypto;
+        const publicKeyRaw = await subtleCrypto.exportKey("raw", this.#keyPair.publicKey);
+        const multicodecName = "p256-pub";
+        const rawKey = rawKeyInHexfromUncompressed(ab2hex(publicKeyRaw));
+        const compressedKey = compressedKeyInHexfromRaw(rawKey);
+        const did = encodeDIDfromHexString(multicodecName, compressedKey);
+        return did;
+    }
+    async #generateECDSAKeyPair() {
+        const subtleCrypto = await this.#subtleCrypto;
+        const keyPair = await subtleCrypto.generateKey(ConnectCrypto.algorithm, true, ["sign", "verify"]);
+        return keyPair;
+    }
+    async #exportKeyPair() {
+        if (!this.#keyPair) {
+            throw new Error("No key pair available");
+        }
+        const subtleCrypto = await this.#subtleCrypto;
+        const jwkKeyPair = {
+            publicKey: await subtleCrypto.exportKey("jwk", this.#keyPair.publicKey),
+            privateKey: await subtleCrypto.exportKey("jwk", this.#keyPair.privateKey),
+        };
+        return jwkKeyPair;
+    }
+    async #importKeyPair(jwkKeyPair) {
+        const subtleCrypto = await this.#subtleCrypto;
+        return {
+            publicKey: await subtleCrypto.importKey("jwk", jwkKeyPair.publicKey, ConnectCrypto.algorithm, true, ["verify"]),
+            privateKey: await subtleCrypto.importKey("jwk", jwkKeyPair.privateKey, ConnectCrypto.algorithm, true, ["sign"]),
+        };
+    }
+    // eslint-disable-next-line no-unused-private-class-members
+    #sign = async (...args) => {
+        return (await this.#subtleCrypto).sign(...args);
+    };
+    // eslint-disable-next-line no-unused-private-class-members
+    #verify = async (...args) => {
+        return (await this.#subtleCrypto).verify(...args);
+    };
+    async sign(data) {
+        if (this.#keyPair?.privateKey) {
+            const subtleCrypto = await this.#subtleCrypto;
+            const arrayBuffer = await subtleCrypto.sign(ConnectCrypto.signAlgorithm, this.#keyPair.privateKey, data.buffer);
+            return new Uint8Array(arrayBuffer);
+        }
+        else {
+            throw new Error("No private key available");
+        }
+    }
+}

package/dist/src/document-model.d.ts

@@ -1,4 +1,4 @@
-import { DocumentModel } from 'document-model/document';
-export declare const baseDocumentModelsMap: Record<string, DocumentModel>;
-export declare const baseDocumentModels: DocumentModel[];
+import { DocumentModelModule } from "document-model";
+export declare const baseDocumentModelsMap: Record<string, DocumentModelModule>;
+export declare const baseDocumentModels: DocumentModelModule[];
 //# sourceMappingURL=document-model.d.ts.map

package/dist/src/document-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-model.d.ts","sourceRoot":"","sources":["../../src/document-model.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGxD,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAG/D,CAAC;AAEF,eAAO,MAAM,kBAAkB,iBAAuC,CAAC"}
+{"version":3,"file":"document-model.d.ts","sourceRoot":"","sources":["../../src/document-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,mBAAmB,EACpB,MAAM,gBAAgB,CAAC;AAExB,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAErE,CAAC;AAEF,eAAO,MAAM,kBAAkB,uBAAuC,CAAC"}

package/dist/src/document-model.js

@@ -0,0 +1,5 @@
+import { documentModelDocumentModelModule, } from "document-model";
+export const baseDocumentModelsMap = {
+    DocumentModel: documentModelDocumentModelModule,
+};
+export const baseDocumentModels = Object.values(baseDocumentModelsMap);

package/dist/src/hooks/index.d.ts

@@ -1,6 +1,10 @@
-export * from './useUserPermissions';
-export * from './useDocumentEditor';
-export * from './useDocumentDrives';
-export * from './useDocument';
-export * from './useConnectCrypto';
+export * from "./useConnectCrypto.js";
+export * from "./useDocument.js";
+export * from "./useDocumentDrives.js";
+export * from "./useDocumentEditor.js";
+export * from "./useDriveActions.js";
+export * from "./useDriveActionsWithUiNodes.js";
+export * from "./useDriveContext.js";
+export * from "./useUiNodesContext.js";
+export * from "./useUserPermissions.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC;AAChD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC"}

package/dist/src/hooks/index.js

@@ -0,0 +1,9 @@
+export * from "./useConnectCrypto.js";
+export * from "./useDocument.js";
+export * from "./useDocumentDrives.js";
+export * from "./useDocumentEditor.js";
+export * from "./useDriveActions.js";
+export * from "./useDriveActionsWithUiNodes.js";
+export * from "./useDriveContext.js";
+export * from "./useUiNodesContext.js";
+export * from "./useUserPermissions.js";

package/dist/src/hooks/useAddDebouncedOperations.d.ts

@@ -1,8 +1,8 @@
-import { Document, Operation } from 'document-model/document';
-import { IDocumentDriveServer } from 'document-drive';
+import { Operation, PHDocument } from "document-model";
+import { IDocumentDriveServer } from "document-drive";
 export type UseAddDebouncedOperationsProps = {
     driveId: string;
     documentId: string;
 };
-export declare function useAddDebouncedOperations(reactor: IDocumentDriveServer | undefined, props: UseAddDebouncedOperationsProps): (operation: Operation) => Promise<Document | undefined>;
+export declare function useAddDebouncedOperations(reactor: IDocumentDriveServer | undefined, props: UseAddDebouncedOperationsProps): (operation: Operation) => Promise<PHDocument | undefined>;
 //# sourceMappingURL=useAddDebouncedOperations.d.ts.map

package/dist/src/hooks/useAddDebouncedOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAddDebouncedOperations.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAddDebouncedOperations.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAI9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAyCtD,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,oBAAoB,GAAG,SAAS,EACzC,KAAK,EAAE,8BAA8B,eAxClB,SAAS,mCAoF7B"}
+{"version":3,"file":"useAddDebouncedOperations.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAddDebouncedOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AA2CtD,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,oBAAoB,GAAG,SAAS,EACzC,KAAK,EAAE,8BAA8B,eAxClB,SAAS,qCAoF7B"}

package/dist/src/hooks/useAddDebouncedOperations.js

@@ -0,0 +1,55 @@
+import { useCallback, useMemo } from "react";
+import { useDocumentDrives } from "./useDocumentDrives.js";
+import { useUserPermissions } from "./useUserPermissions.js";
+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);
+        });
+    };
+}
+export function useAddDebouncedOperations(reactor, props) {
+    const { driveId, documentId } = props;
+    const [documentDrives] = useDocumentDrives(reactor);
+    const { isAllowedToEditDocuments } = useUserPermissions() || {
+        isAllowedToCreateDocuments: false,
+        isAllowedToEditDocuments: false,
+    };
+    const addOperations = useCallback(async (driveId, 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 = documentDrives.find((drive) => drive.state.global.id === driveId);
+        if (!drive) {
+            throw new Error(`Drive with id ${driveId} not found`);
+        }
+        const newDocument = await reactor.queueOperations(driveId, id, operations);
+        return newDocument.document;
+    }, [documentDrives, isAllowedToEditDocuments, reactor]);
+    const addDebouncedOperations = useMemo(() => {
+        return debounceOperations((operations) => addOperations(driveId, documentId, operations));
+    }, [addOperations, driveId, documentId]);
+    return addDebouncedOperations;
+}

package/dist/src/hooks/useConnectCrypto.d.ts

@@ -1,4 +1,4 @@
-import { DID, IConnectCrypto } from '../crypto';
+import { DID, IConnectCrypto } from "../crypto/index.js";
 export declare function useConnectCrypto(): IConnectCrypto;
 export declare function useConnectDid(): DID | undefined;
 //# sourceMappingURL=useConnectCrypto.d.ts.map

package/dist/src/hooks/useConnectCrypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useConnectCrypto.d.ts","sourceRoot":"","sources":["../../../src/hooks/useConnectCrypto.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,GAAG,EAAE,cAAc,EAAiB,MAAM,WAAW,CAAC;AAS/D,wBAAgB,gBAAgB,IAAI,cAAc,CAkBjD;AAID,wBAAgB,aAAa,IAAI,GAAG,GAAG,SAAS,CAc/C"}
+{"version":3,"file":"useConnectCrypto.d.ts","sourceRoot":"","sources":["../../../src/hooks/useConnectCrypto.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,GAAG,EAAE,cAAc,EAAiB,MAAM,oBAAoB,CAAC;AASxE,wBAAgB,gBAAgB,IAAI,cAAc,CAkBjD;AAID,wBAAgB,aAAa,IAAI,GAAG,GAAG,SAAS,CAc/C"}

package/dist/src/hooks/useConnectCrypto.js

@@ -0,0 +1,40 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */
+import { atom, useAtom } from "jotai";
+import { useEffect, useMemo } from "react";
+import { ConnectCrypto } from "../crypto/index.js";
+import { BrowserKeyStorage } from "../crypto/browser.js";
+const connectCrypto = (async () => {
+    const connectCrypto = new ConnectCrypto(new BrowserKeyStorage());
+    await connectCrypto.did();
+    return connectCrypto;
+})();
+export 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);
+        },
+    }), []);
+}
+const didAtom = atom(undefined);
+export function useConnectDid() {
+    const [did, setDid] = useAtom(didAtom);
+    useEffect(() => {
+        if (did) {
+            return;
+        }
+        connectCrypto
+            .then((c) => c.did())
+            .then((did) => setDid(did))
+            .catch(console.error);
+    });
+    return did;
+}

package/dist/src/hooks/useDocument.d.ts

@@ -1,9 +1,9 @@
-import { Document } from 'document-model/document';
-import { IDocumentDriveServer } from 'document-drive/server';
+import { IDocumentDriveServer } from "document-drive";
+import { PHDocument } from "document-model";
 export type DocumentMeta = {
     driveId?: string;
     documentId?: string;
     documentType?: string;
 };
-export declare function useDocument(reactor: IDocumentDriveServer | undefined, documentMeta?: DocumentMeta): Document | undefined;
+export declare function useDocument(reactor: IDocumentDriveServer | undefined, documentMeta?: DocumentMeta): PHDocument | undefined;
 //# sourceMappingURL=useDocument.d.ts.map