@dxos/plugin-wnfs 0.7.4-staging.f7e8224 → 0.7.5-labs.5f04cf6

package/dist/lib/browser/index.mjs

@@ -1,517 +1,119 @@
 import {
-  FileType
-} from "./chunk-JDSKIDDR.mjs";
+  Blockstore,
+  FileUploader,
+  IntentResolver,
+  Markdown,
+  ReactSurface
+} from "./chunk-ED7HMPYN.mjs";
+import {
+  WnfsCapabilities
+} from "./chunk-357BWHML.mjs";
+import {
+  FileType,
+  WnfsAction
+} from "./chunk-EMRQJXBW.mjs";
 import {
   WNFS_PLUGIN,
-  meta_default
-} from "./chunk-VL3H7P4F.mjs";
-
-// packages/plugins/experimental/plugin-wnfs/src/WnfsPlugin.tsx
-import { FileCloud } from "@phosphor-icons/react";
-import React2 from "react";
-import { isObject, resolvePlugin } from "@dxos/app-framework";
-import { invariant } from "@dxos/invariant";
-import { parseClientPlugin } from "@dxos/plugin-client";
-import { getSpace } from "@dxos/react-client/echo";
-import { isTileComponentProps } from "@dxos/react-ui-mosaic";
+  meta
+} from "./chunk-6YFT42F7.mjs";
 
-// packages/plugins/experimental/plugin-wnfs/src/blockstore.ts
-import { BaseBlockstore } from "blockstore-core";
-import { IDBBlockstore } from "blockstore-idb";
+// packages/plugins/plugin-wnfs/src/WnfsPlugin.tsx
+import { pipe } from "effect";
+import { Capabilities, Events, chain, contributes, createIntent, defineModule, definePlugin, oneOf } from "@dxos/app-framework";
+import { ClientCapabilities, ClientEvents } from "@dxos/plugin-client";
 
-// packages/plugins/experimental/plugin-wnfs/src/common.ts
-import { CID } from "multiformats/cid";
-import { sha256 } from "multiformats/hashes/sha2";
-import * as crypto from "@dxos/crypto";
-var filePath = (fileName, space) => {
-  return [
-    "spaces",
-    space.properties.id,
-    "files",
-    fileName
-  ];
-};
-var Rng = class {
-  randomBytes(count) {
-    return new Uint8Array(crypto.randomBytes(count));
-  }
-};
-var store = (blockstore) => {
-  const getBlock = async (cid) => {
-    const decodedCid = CID.decode(cid);
-    return await blockstore.get(decodedCid);
-  };
-  const hasBlock = async (cid) => {
-    const decodedCid = CID.decode(cid);
-    return await blockstore.has(decodedCid);
-  };
-  const putBlockKeyed = async (cid, bytes) => {
-    const decodedCid = CID.decode(cid);
-    await blockstore.put(decodedCid, bytes);
-  };
-  const putBlock = async (bytes, codec) => {
-    const hash = await sha256.digest(bytes);
-    const cid = CID.create(1, codec, hash);
-    await blockstore.put(cid, bytes);
-    return cid.bytes;
-  };
-  return {
-    getBlock,
-    hasBlock,
-    putBlockKeyed,
-    putBlock
-  };
-};
-var storeName = () => "dxos/wnfs";
-
-// packages/plugins/experimental/plugin-wnfs/src/blockstore.ts
-var create = (apiHost) => {
-  return new MixedBlockstore(apiHost);
-};
-var MixedBlockstore = class extends BaseBlockstore {
-  #apiHost;
-  #idbStore;
-  constructor(apiHost) {
-    super();
-    this.#apiHost = apiHost;
-    this.#idbStore = new IDBBlockstore(storeName());
-  }
-  async open() {
-    await this.#idbStore.open();
-  }
-  url(apiHost, cid) {
-    const path = cid ? cid.toString() : "";
-    return `${apiHost}/api/file/${path}`;
-  }
-  // Blockstore implementation
-  async delete(key) {
-    await this.#idbStore.delete(key);
-    if (this.#apiHost) {
-      await fetch(this.url(this.#apiHost, key), {
-        method: "DELETE"
-      });
-    }
-  }
-  async get(key) {
-    if (await this.#idbStore.has(key)) {
-      return await this.#idbStore.get(key);
-    }
-    if (this.#apiHost) {
-      return await fetch(this.url(this.#apiHost, key), {
-        method: "GET"
-      }).then((r) => r.arrayBuffer()).then((r) => new Uint8Array(r));
-    }
-    return await this.#idbStore.get(key);
-  }
-  async has(key) {
-    if (await this.#idbStore.has(key)) {
-      return true;
-    }
-    if (this.#apiHost) {
-      return await fetch(this.url(this.#apiHost, key), {
-        method: "HEAD"
-      }).then((r) => r.ok);
-    }
-    return false;
-  }
-  async put(key, val) {
-    await this.#idbStore.put(key, val);
-    if (this.#apiHost) {
-      await fetch(this.url(this.#apiHost, key), {
-        method: "POST",
-        body: val
-      });
-    }
-    return key;
-  }
-  async destroy() {
-    await this.#idbStore.destroy();
-  }
-};
-
-// packages/plugins/experimental/plugin-wnfs/src/components/index.ts
-import React from "react";
-var FileCard = React.lazy(() => import("./FileCard-HJIZDWJF.mjs"));
-var FileMain = React.lazy(() => import("./FileMain-WEWTX7QB.mjs"));
-var FileSection = React.lazy(() => import("./FileSection-BEUGJ7EI.mjs"));
-var FileSlide = React.lazy(() => import("./FileSlide-NYBGZEZS.mjs"));
-
-// packages/plugins/experimental/plugin-wnfs/src/extensions/image.ts
-import { syntaxTree } from "@codemirror/language";
-import { StateField, StateEffect } from "@codemirror/state";
-import { Decoration, EditorView, WidgetType, ViewPlugin } from "@codemirror/view";
-import { log } from "@dxos/log";
-
-// packages/plugins/experimental/plugin-wnfs/src/load.ts
-import { CID as CID2 } from "multiformats";
-import * as Uint8Arrays from "uint8arrays";
-import { AccessKey, PrivateForest, PrivateDirectory, PrivateNode } from "wnfs";
-var loadWnfs = async (space, blockstore) => {
-  const exists = space.properties.wnfs_access_key !== void 0 && space.properties.wnfs_private_forest_cid !== void 0;
-  return exists ? await loadWnfsDir(blockstore, space) : await createWnfsDir(blockstore, space);
-};
-var createWnfsDir = async (blockstore, space) => {
-  const wnfsStore = store(blockstore);
-  const rng = new Rng();
-  const forest = new PrivateForest(rng);
-  const dirResult = await PrivateDirectory.newAndStore(forest.emptyName(), /* @__PURE__ */ new Date(), forest, wnfsStore, rng);
-  const dir = dirResult.rootDir;
-  const [accessKeyRaw, newForest] = await dir.asNode().store(dirResult.forest, wnfsStore, rng);
-  const cidBytes = await newForest.store(wnfsStore);
-  space.properties.wnfs_access_key = Uint8Arrays.toString(accessKeyRaw.toBytes(), "base64");
-  space.properties.wnfs_private_forest_cid = CID2.decode(cidBytes).toString();
-  return {
-    directory: dir,
-    forest: newForest
-  };
-};
-var loadWnfsDir = async (blockstore, space) => {
-  const wnfsStore = store(blockstore);
-  const accessKey = AccessKey.fromBytes(Uint8Arrays.fromString(space.properties.wnfs_access_key, "base64"));
-  const forest = await PrivateForest.load(CID2.parse(space.properties.wnfs_private_forest_cid).bytes, wnfsStore);
-  const node = await PrivateNode.load(accessKey, forest, wnfsStore);
-  return {
-    directory: node.asDir(),
-    forest
-  };
-};
-
-// packages/plugins/experimental/plugin-wnfs/src/extensions/image.ts
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-wnfs/src/extensions/image.ts";
-var image = (options) => {
-  return [
-    stateField(options),
-    viewPlugin(options)
-  ];
-};
-var loadedWnfsInstances = {};
-var stateEffect = StateEffect.define({});
-var stateField = (options) => StateField.define({
-  create: () => {
-    return Decoration.none;
-  },
-  update: (value, tr) => {
-    for (const effect of tr.effects) {
-      if (effect.is(stateEffect)) {
-        return value.map(tr.changes).update({
-          filterFrom: effect.value.from,
-          filterTo: effect.value.to,
-          filter: () => false,
-          add: effect.value.decorations
-        });
-      }
-    }
-    return value;
-  },
-  provide: (f) => {
-    return EditorView.decorations.from(f);
-  }
-});
-var viewPlugin = (options) => ViewPlugin.define((view) => {
-  buildDecorations({
-    from: 0,
-    to: view.state.doc.length,
-    state: view.state,
-    options
-  }).then((decorations) => {
-    view.dispatch({
-      effects: stateEffect.of({
-        decorations,
-        from: 0,
-        to: view.state.doc.length
-      })
-    });
-  }).catch((err) => {
-    throw new Error(err);
-  });
-  const update = (update2) => {
-    if (!update2.docChanged) {
-      return;
-    }
-    const { from, to } = changedRange(update2);
-    buildDecorations({
-      from,
-      to,
-      state: view.state,
-      options
-    }).then((decorations) => {
-      view.dispatch({
-        effects: stateEffect.of({
-          decorations,
-          from,
-          to
-        })
-      });
-    }).catch((err) => {
-      log.catch(err, void 0, {
-        F: __dxlog_file,
-        L: 107,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-    });
-  };
-  return {
-    update
-  };
-});
-var changedRange = (update) => {
-  const cursor = update.state.selection.main.head;
-  const oldCursor = update.changes.mapPos(update.startState.selection.main.head);
-  let from = Math.min(cursor, oldCursor);
-  let to = Math.max(cursor, oldCursor);
-  update.changes.iterChangedRanges((fromA, toA, fromB, toB) => {
-    from = Math.min(from, fromB);
-    to = Math.max(to, toB);
-  });
-  from = update.state.doc.lineAt(from).from;
-  to = update.state.doc.lineAt(to).to;
-  return {
-    from,
-    to
-  };
-};
-var buildDecorations = async ({ from, to, state, options }) => {
-  const cursor = state.selection.main.head;
-  let nodes = [];
-  syntaxTree(state).iterate({
-    enter: (node) => {
-      if (node.name === "Image") {
-        const urlNode = node.node.getChild("URL");
-        if (urlNode) {
-          const hide = state.readOnly || cursor < node.from || cursor > node.to;
-          const url = state.sliceDoc(urlNode.from, urlNode.to);
-          if (url.startsWith("wnfs://")) {
-            nodes.push({
-              from: node.from,
-              to: node.to,
-              hide,
-              url
-            });
-          }
-        }
-      }
-    },
-    from,
-    to
-  });
-  nodes = nodes.sort((a, b) => {
-    return a.from - b.from;
-  });
-  const decorations = await nodes.reduce(async (acc, node) => {
-    const array = await acc;
-    const path = node.url.replace(/^wnfs:\/\//, "").split("/").map((p) => decodeURIComponent(p));
-    const spaceIdFromUrl = path[1];
-    if (spaceIdFromUrl !== options.space.properties.id) {
-      return array;
-    }
-    const cacheKey = options.space.properties.wnfs_private_forest_cid;
-    const { directory, forest } = loadedWnfsInstances[cacheKey] ? loadedWnfsInstances[cacheKey] : await loadWnfs(options.space, options.blockstore);
-    loadedWnfsInstances[cacheKey] = {
-      directory,
-      forest
-    };
-    const wnfsStore = store(options.blockstore);
-    const { result } = await directory.read(path, true, forest, wnfsStore);
-    const blob = new Blob([
-      result
-    ]);
-    const blobUrl = URL.createObjectURL(blob);
-    return [
-      ...array,
-      Decoration.replace({
-        block: true,
-        widget: new WnfsImageWidget(blobUrl)
-      }).range(node.hide ? node.from : node.to, node.to)
-    ];
-  }, Promise.resolve([]));
-  return decorations;
-};
-var WnfsImageWidget = class extends WidgetType {
-  constructor(_url) {
-    super();
-    this._url = _url;
-  }
-  eq(other) {
-    return this._url === other._url;
-  }
-  toDOM(view) {
-    const img = document.createElement("img");
-    img.setAttribute("loading", "lazy");
-    img.setAttribute("src", this._url);
-    img.setAttribute("class", "cm-image");
-    img.onload = () => img.classList.add("cm-loaded-image");
-    return img;
-  }
-};
-
-// packages/plugins/experimental/plugin-wnfs/src/translations.ts
+// packages/plugins/plugin-wnfs/src/translations.ts
 var translations_default = [
   {
     "en-US": {
+      [FileType.typename]: {
+        "typename label": "File"
+      },
       [WNFS_PLUGIN]: {
         "plugin name": "Files",
         "file title placeholder": "New file",
-        "delete object label": "Delete"
+        "delete object label": "Delete",
+        "file input placeholder": "Drop a file here, or click to select a file"
       }
     }
   }
 ];
 
-// packages/plugins/experimental/plugin-wnfs/src/upload.ts
-import { CID as CID3 } from "multiformats";
-import * as Raw from "multiformats/codecs/raw";
-import { sha256 as sha2562 } from "multiformats/hashes/sha2";
-import { log as log2 } from "@dxos/log";
-
-// packages/plugins/experimental/plugin-wnfs/src/wnfs-url.ts
-var wnfsUrl = (filePath2) => {
-  return "wnfs://" + filePath2.map((f) => encodeURIComponent(f)).join("/");
-};
-
-// packages/plugins/experimental/plugin-wnfs/src/upload.ts
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-wnfs/src/upload.ts";
-var upload = async ({ blockstore, file, space }) => {
-  const { directory, forest } = await loadWnfs(space, blockstore);
-  const wnfsStore = store(blockstore);
-  const bytes = new Uint8Array(await file.arrayBuffer());
-  const hash = await sha2562.digest(bytes);
-  const cid = CID3.create(1, Raw.code, hash);
-  const path = filePath(cid.toString(), space);
-  const result = await directory.write(path, true, bytes, /* @__PURE__ */ new Date(), forest, wnfsStore, new Rng());
-  const [_, updatedForest] = await result.rootDir.store(result.forest, wnfsStore, new Rng());
-  const cidBytes = await updatedForest.store(wnfsStore);
-  space.properties.wnfs_private_forest_cid = CID3.decode(cidBytes).toString();
-  const info = {
-    url: wnfsUrl(path)
-  };
-  log2("upload", {
-    file,
-    info
-  }, {
-    F: __dxlog_file2,
-    L: 44,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  return info;
-};
-
-// packages/plugins/experimental/plugin-wnfs/src/WnfsPlugin.tsx
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-wnfs/src/WnfsPlugin.tsx";
-var WnfsPlugin = () => {
-  let blockstore;
-  return {
-    meta: meta_default,
-    ready: async (plugins) => {
-      const client = resolvePlugin(plugins, parseClientPlugin)?.provides.client;
-      invariant(client, void 0, {
-        F: __dxlog_file3,
-        L: 31,
-        S: void 0,
-        A: [
-          "client",
-          ""
-        ]
-      });
-      const apiHost = client.config.values.runtime?.services?.edge?.url || "http://localhost:8787";
-      blockstore = create(apiHost);
-      await blockstore.open();
-    },
-    provides: {
-      translations: translations_default,
+// packages/plugins/plugin-wnfs/src/WnfsPlugin.tsx
+var WnfsPlugin = () => definePlugin(meta, [
+  defineModule({
+    id: `${meta.id}/module/blockstore`,
+    activatesOn: ClientEvents.ClientReady,
+    activate: Blockstore
+  }),
+  defineModule({
+    id: `${meta.id}/module/instances`,
+    activatesOn: Events.Startup,
+    activate: () => {
+      const instances = {};
+      return contributes(WnfsCapabilities.Instances, instances);
+    }
+  }),
+  defineModule({
+    id: `${meta.id}/module/translations`,
+    activatesOn: Events.SetupTranslations,
+    activate: () => contributes(Capabilities.Translations, translations_default)
+  }),
+  defineModule({
+    id: `${meta.id}/module/metadata`,
+    activatesOn: oneOf(Events.Startup, Events.SetupAppGraph),
+    activate: () => contributes(Capabilities.Metadata, {
+      id: FileType.typename,
       metadata: {
-        records: {
-          [FileType.typename]: {
-            placeholder: [
-              "file title placeholder",
-              {
-                ns: WNFS_PLUGIN
-              }
-            ],
-            icon: (props) => /* @__PURE__ */ React2.createElement(FileCloud, props)
-          }
-        }
-      },
-      echo: {
-        system: [
-          FileType
-        ]
-      },
-      // TODO(burdon): Add intent to upload file.
-      file: {
-        upload: async (file, space) => {
-          if (!blockstore) {
-            throw new Error("Blockstore is not ready yet");
-          }
-          return await upload({
-            blockstore,
-            file,
-            space
-          });
-        }
-      },
-      markdown: {
-        extensions: ({ document: document2 }) => {
-          if (!blockstore) {
-            throw new Error("Blockstore is not ready yet");
-          }
-          if (document2) {
-            const space = getSpace(document2);
-            return space ? [
-              image({
-                blockstore,
-                space
-              })
-            ] : [];
-          }
-          return [];
-        }
-      },
-      surface: {
-        component: ({ data, role, ...props }, forwardedRef) => {
-          switch (role) {
-            case "main":
-              return data.active instanceof FileType ? /* @__PURE__ */ React2.createElement(FileMain, {
-                file: data.active
-              }) : null;
-            case "slide":
-              return data.slide instanceof FileType ? /* @__PURE__ */ React2.createElement(FileSlide, {
-                file: data.slide,
-                cover: false
-              }) : null;
-            case "section":
-              return data.object instanceof FileType ? /* @__PURE__ */ React2.createElement(FileSection, {
-                file: data.object
-              }) : null;
-            case "card": {
-              if (isObject(data.content) && typeof data.content.id === "string" && data.content.object instanceof FileType) {
-                const cardProps = {
-                  ...props,
-                  item: {
-                    id: data.content.id,
-                    object: data.content.object
-                  }
-                };
-                return isTileComponentProps(cardProps) ? /* @__PURE__ */ React2.createElement(FileCard, {
-                  ...cardProps,
-                  ref: forwardedRef
-                }) : null;
-              }
-              break;
-            }
+        creationSchema: WnfsAction.UploadFileSchema,
+        createObject: ({ file }, { space }) => pipe(createIntent(WnfsAction.Upload, {
+          file,
+          space
+        }), chain(WnfsAction.Create, {})),
+        label: (object) => object instanceof FileType ? object.name : void 0,
+        placeholder: [
+          "file title placeholder",
+          {
+            ns: WNFS_PLUGIN
           }
-          return null;
-        }
+        ],
+        // TODO(wittjosiah): Would be nice if icon could change based on the type of the file.
+        icon: "ph--file--regular"
       }
-    }
-  };
-};
-
-// packages/plugins/experimental/plugin-wnfs/src/index.ts
-var src_default = WnfsPlugin;
+    })
+  }),
+  defineModule({
+    id: `${meta.id}/module/schema`,
+    activatesOn: ClientEvents.SetupClient,
+    activate: () => contributes(ClientCapabilities.Schema, [
+      FileType
+    ])
+  }),
+  defineModule({
+    id: `${meta.id}/module/file-uploader`,
+    activatesOn: ClientEvents.ClientReady,
+    activate: FileUploader
+  }),
+  defineModule({
+    id: `${meta.id}/module/markdown`,
+    activatesOn: Events.Startup,
+    activate: Markdown
+  }),
+  defineModule({
+    id: `${meta.id}/module/react-surface`,
+    activatesOn: Events.Startup,
+    activate: ReactSurface
+  }),
+  defineModule({
+    id: `${meta.id}/module/intent-resolver`,
+    activatesOn: Events.SetupIntents,
+    activate: IntentResolver
+  })
+]);
 export {
+  WNFS_PLUGIN,
+  WnfsCapabilities,
   WnfsPlugin,
-  src_default as default
+  meta
 };
 //# sourceMappingURL=index.mjs.map