mindoodb-app-sdk 0.0.14 → 0.0.17

package/dist/index.js

@@ -142,6 +142,7 @@ var PortRpcClient = class {
     this.port.addEventListener("message", this.handleMessage);
     this.port.start();
   }
+  port;
   pending = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   requestCounter = 0;
@@ -232,7 +233,10 @@ var PortRpcClient = class {
 var PROTOCOL2 = "mindoodb-app-bridge";
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 function toTransferableArrayBuffer(chunk) {
-  return chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+  return chunk.buffer.slice(
+    chunk.byteOffset,
+    chunk.byteOffset + chunk.byteLength
+  );
 }
 function isStreamChunkFor(streamId, message) {
   return message.kind === "stream-chunk" && message.streamId === streamId;
@@ -262,7 +266,9 @@ function resolveLaunchId(options) {
     return options.launchId;
   }
   if (typeof window === "undefined") {
-    throw new Error("A launchId must be provided when connecting outside the browser.");
+    throw new Error(
+      "A launchId must be provided when connecting outside the browser."
+    );
   }
   const search = new URLSearchParams(window.location.search);
   const launchId = search.get("mindoodbAppLaunchId");
@@ -271,9 +277,17 @@ function resolveLaunchId(options) {
   }
   return launchId;
 }
+function shouldUseWindowedHostTab() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return window.parent === window && Boolean(window.opener);
+}
 function resolveTargetWindow() {
   if (typeof window === "undefined") {
-    throw new Error("The MindooDB app bridge is only available in the browser.");
+    throw new Error(
+      "The MindooDB app bridge is only available in the browser."
+    );
   }
   if (window.parent && window.parent !== window) {
     return window.parent;
@@ -281,7 +295,7 @@ function resolveTargetWindow() {
   if (window.opener) {
     return window.opener;
   }
-  throw new Error("Could not find a MindooDB Administrator host window.");
+  throw new Error("Could not find a MindooDB Haven host window.");
 }
 function waitForConnectedPort(options, launchId) {
   const targetWindow = resolveTargetWindow();
@@ -294,20 +308,36 @@ function waitForConnectedPort(options, launchId) {
       if (timeoutId !== null) {
         window.clearTimeout(timeoutId);
       }
-      channel.port1.removeEventListener("message", handleMessage);
+      channel.port1.removeEventListener(
+        "message",
+        handleMessage
+      );
     };
     const handleMessage = (event) => {
       const payload = event.data;
-      if (!payload || payload.protocol !== PROTOCOL2 || payload.type !== "mindoodb-app:connected") {
+      if (!payload || payload.protocol !== PROTOCOL2) {
         return;
       }
-      cleanup();
-      resolve(channel.port1);
+      if (payload.type === "mindoodb-app:connected") {
+        cleanup();
+        resolve(channel.port1);
+        return;
+      }
+      if (payload.type === "mindoodb-app:error") {
+        cleanup();
+        channel.port1.close();
+        const message2 = typeof payload.error === "string" && payload.error.trim() ? payload.error : "MindooDB Haven bridge connection failed.";
+        reject(new Error(message2));
+      }
     };
     timeoutId = window.setTimeout(() => {
       cleanup();
       channel.port1.close();
-      reject(new Error(`Timed out while connecting to the MindooDB Administrator bridge for launch ${launchId}.`));
+      reject(
+        new Error(
+          `Timed out while connecting to the MindooDB Haven bridge for launch ${launchId}.`
+        )
+      );
     }, timeoutMs);
     channel.port1.addEventListener("message", handleMessage);
     channel.port1.start();
@@ -325,6 +355,9 @@ var MindooDBAppViewNavigatorImpl = class {
     this.navigatorId = navigatorId;
     this.viewCursor = viewCursor;
   }
+  rpc;
+  navigatorId;
+  viewCursor;
   /** Shorthand: call an RPC method with the navigator ID automatically injected. */
   async call(method, params = {}) {
     return await this.rpc.call(method, {
@@ -339,7 +372,9 @@ var MindooDBAppViewNavigatorImpl = class {
     return this.viewCursor;
   }
   async refresh() {
-    const result = await this.call("viewNavigators.refresh");
+    const result = await this.call(
+      "viewNavigators.refresh"
+    );
     this.viewCursor = result.viewCursor;
     return this.viewCursor;
   }
@@ -383,10 +418,14 @@ var MindooDBAppViewNavigatorImpl = class {
     return await this.call("viewNavigators.category.findByParts", { parts });
   }
   async entriesForward(options) {
-    return await this.call("viewNavigators.entries.forward", { options: options ?? {} });
+    return await this.call("viewNavigators.entries.forward", {
+      options: options ?? {}
+    });
   }
   async entriesBackward(options) {
-    return await this.call("viewNavigators.entries.backward", { options: options ?? {} });
+    return await this.call("viewNavigators.entries.backward", {
+      options: options ?? {}
+    });
   }
   async gotoNextSelected() {
     return await this.call("viewNavigators.goto.nextSelected");
@@ -411,7 +450,10 @@ var MindooDBAppViewNavigatorImpl = class {
     await this.call("viewNavigators.selection.deselectAll");
   }
   async isSelected(origin, docId) {
-    return await this.call("viewNavigators.selection.isSelected", { origin, docId });
+    return await this.call("viewNavigators.selection.isSelected", {
+      origin,
+      docId
+    });
   }
   async getSelectionState() {
     return await this.call("viewNavigators.selection.get");
@@ -444,13 +486,22 @@ var MindooDBAppViewNavigatorImpl = class {
     await this.call("viewNavigators.expansion.set", { state });
   }
   async childEntries(entryKey, descending) {
-    return await this.call("viewNavigators.children.entries", { entryKey, descending });
+    return await this.call("viewNavigators.children.entries", {
+      entryKey,
+      descending
+    });
   }
   async childCategories(entryKey, descending) {
-    return await this.call("viewNavigators.children.categories", { entryKey, descending });
+    return await this.call("viewNavigators.children.categories", {
+      entryKey,
+      descending
+    });
   }
   async childDocuments(entryKey, descending) {
-    return await this.call("viewNavigators.children.documents", { entryKey, descending });
+    return await this.call("viewNavigators.children.documents", {
+      entryKey,
+      descending
+    });
   }
   async childCategoriesByKey(entryKey, key, exact, descending) {
     return await this.call("viewNavigators.children.categoriesByKey", {
@@ -469,16 +520,28 @@ var MindooDBAppViewNavigatorImpl = class {
     });
   }
   async childCategoriesBetween(entryKey, range) {
-    return await this.call("viewNavigators.children.categoriesBetween", { entryKey, range });
+    return await this.call("viewNavigators.children.categoriesBetween", {
+      entryKey,
+      range
+    });
   }
   async childDocumentsBetween(entryKey, range) {
-    return await this.call("viewNavigators.children.documentsBetween", { entryKey, range });
+    return await this.call("viewNavigators.children.documentsBetween", {
+      entryKey,
+      range
+    });
   }
   async getSortedDocIds(descending) {
-    return await this.call("viewNavigators.sortedDocIds.get", { descending });
+    return await this.call(
+      "viewNavigators.sortedDocIds.get",
+      { descending }
+    );
   }
   async getSortedDocIdsScoped(entryKey, descending) {
-    return await this.call("viewNavigators.sortedDocIds.scoped", { entryKey, descending });
+    return await this.call(
+      "viewNavigators.sortedDocIds.scoped",
+      { entryKey, descending }
+    );
   }
   async dispose() {
     await this.call("viewNavigators.dispose");
@@ -495,7 +558,9 @@ var MindooDBAppReadableAttachmentStreamImpl = class {
         if (!pending) {
           return;
         }
-        pending.resolve(message.done ? null : new Uint8Array(message.chunk ?? new ArrayBuffer(0)));
+        pending.resolve(
+          message.done ? null : new Uint8Array(message.chunk ?? new ArrayBuffer(0))
+        );
         if (message.done) {
           this.closed = true;
           this.unsubscribe();
@@ -511,6 +576,8 @@ var MindooDBAppReadableAttachmentStreamImpl = class {
       }
     });
   }
+  rpc;
+  streamId;
   unsubscribe;
   closed = false;
   pendingRead = null;
@@ -520,7 +587,9 @@ var MindooDBAppReadableAttachmentStreamImpl = class {
       return null;
     }
     if (this.pendingRead) {
-      throw new Error("A read() call is already in progress for this attachment stream.");
+      throw new Error(
+        "A read() call is already in progress for this attachment stream."
+      );
     }
     return await new Promise((resolve, reject) => {
       this.pendingRead = { resolve, reject };
@@ -567,6 +636,8 @@ var MindooDBAppWritableAttachmentStreamImpl = class {
       }
     });
   }
+  rpc;
+  streamId;
   unsubscribe;
   closed = false;
   inflight = null;
@@ -592,12 +663,15 @@ var MindooDBAppWritableAttachmentStreamImpl = class {
     return await this.enqueue(async () => {
       const buffer = toTransferableArrayBuffer(chunk);
       await this.waitForAck(() => {
-        this.rpc.postMessage({
-          protocol: PROTOCOL2,
-          kind: "stream-write",
-          streamId: this.streamId,
-          chunk: buffer
-        }, [buffer]);
+        this.rpc.postMessage(
+          {
+            protocol: PROTOCOL2,
+            kind: "stream-write",
+            streamId: this.streamId,
+            chunk: buffer
+          },
+          [buffer]
+        );
       });
     });
   }
@@ -665,6 +739,10 @@ var MindooDBAppDatabaseImpl = class {
         databaseId: this.databaseId,
         docId
       }),
+      undelete: async (docId) => await this.rpc.call("documents.undelete", {
+        databaseId: this.databaseId,
+        docId
+      }),
       listHistory: async (docId) => await this.rpc.call("documents.history.list", {
         databaseId: this.databaseId,
         docId
@@ -673,49 +751,130 @@ var MindooDBAppDatabaseImpl = class {
         databaseId: this.databaseId,
         docId,
         timestamp
+      }),
+      getAtRevision: async (docId, revisionId) => await this.rpc.call("documents.history.getAtRevision", {
+        databaseId: this.databaseId,
+        docId,
+        revisionId
       })
     };
     this.attachments = {
-      list: async (docId) => await this.rpc.call("attachments.list", {
+      list: async (docId, options) => await this.rpc.call("attachments.list", {
         databaseId: this.databaseId,
-        docId
+        docId,
+        timestamp: options?.timestamp,
+        revisionId: options?.revisionId
       }),
       remove: async (docId, attachmentName) => await this.rpc.call("attachments.remove", {
         databaseId: this.databaseId,
         docId,
         attachmentName
       }),
-      openReadStream: async (docId, attachmentName) => {
-        const result = await this.rpc.call("attachments.openReadStream", {
-          databaseId: this.databaseId,
-          docId,
-          attachmentName
-        });
-        return new MindooDBAppReadableAttachmentStreamImpl(this.rpc, result.streamId);
+      openReadStream: async (docId, attachmentName, options) => {
+        const result = await this.rpc.call(
+          "attachments.openReadStream",
+          {
+            databaseId: this.databaseId,
+            docId,
+            attachmentName,
+            timestamp: options?.timestamp,
+            revisionId: options?.revisionId
+          }
+        );
+        return new MindooDBAppReadableAttachmentStreamImpl(
+          this.rpc,
+          result.streamId
+        );
       },
       openWriteStream: async (docId, attachmentName, contentType) => {
-        const result = await this.rpc.call("attachments.openWriteStream", {
-          databaseId: this.databaseId,
-          docId,
-          attachmentName,
-          contentType
-        });
-        return new MindooDBAppWritableAttachmentStreamImpl(this.rpc, result.streamId);
+        const result = await this.rpc.call(
+          "attachments.openWriteStream",
+          {
+            databaseId: this.databaseId,
+            docId,
+            attachmentName,
+            contentType
+          }
+        );
+        return new MindooDBAppWritableAttachmentStreamImpl(
+          this.rpc,
+          result.streamId
+        );
+      },
+      scan: async (docId, options) => {
+        const scannerTab = shouldUseWindowedHostTab() ? window.open("", "_blank") : null;
+        if (scannerTab) {
+          try {
+            scannerTab.document.title = "Opening document scanner...";
+            const preparedSession = await this.rpc.call("attachments.prepareScanSession", {
+              databaseId: this.databaseId,
+              docId,
+              defaultFileName: options?.defaultFileName,
+              preset: options?.preset,
+              mimeType: options?.mimeType
+            });
+            scannerTab.location.href = preparedSession.scanUrl;
+            return await this.rpc.call(
+              "attachments.awaitScanSession",
+              {
+                databaseId: this.databaseId,
+                sessionId: preparedSession.sessionId
+              }
+            );
+          } catch (error) {
+            scannerTab.close();
+            throw error;
+          }
+        }
+        return await this.rpc.call(
+          "attachments.scanAndWrite",
+          {
+            databaseId: this.databaseId,
+            docId,
+            defaultFileName: options?.defaultFileName,
+            preset: options?.preset,
+            mimeType: options?.mimeType
+          }
+        );
       },
       preparePreviewSession: async (docId, attachmentName, options) => await this.rpc.call("attachments.preparePreviewSession", {
         databaseId: this.databaseId,
         docId,
         attachmentName,
-        timestamp: options?.timestamp
+        timestamp: options?.timestamp,
+        revisionId: options?.revisionId
       }),
-      openPreview: async (docId, attachmentName, options) => await this.rpc.call("attachments.openPreview", {
-        databaseId: this.databaseId,
-        docId,
-        attachmentName,
-        timestamp: options?.timestamp
-      })
+      openPreview: async (docId, attachmentName, options) => {
+        const previewTab = shouldUseWindowedHostTab() ? window.open("", "_blank") : null;
+        if (previewTab) {
+          try {
+            previewTab.document.title = "Opening attachment preview...";
+            const previewSession = await this.rpc.call("attachments.preparePreviewSession", {
+              databaseId: this.databaseId,
+              docId,
+              attachmentName,
+              timestamp: options?.timestamp,
+              revisionId: options?.revisionId
+            });
+            previewTab.location.href = previewSession.previewUrl;
+            return { ok: true };
+          } catch (error) {
+            previewTab.close();
+            throw error;
+          }
+        }
+        return await this.rpc.call("attachments.openPreview", {
+          databaseId: this.databaseId,
+          docId,
+          attachmentName,
+          timestamp: options?.timestamp,
+          revisionId: options?.revisionId
+        });
+      }
     };
   }
+  rpc;
+  databaseId;
   documents;
   attachments;
   /** Returns database metadata for the currently opened binding. */
@@ -735,8 +894,9 @@ var MindooDBAppSessionImpl = class {
       }
     };
   }
+  rpc;
   menus;
-  /** Returns the launch context provided by the Administrator host. */
+  /** Returns the launch context provided by the Haven host. */
   async getLaunchContext() {
     return await this.rpc.call("session.getLaunchContext", {});
   }
@@ -750,7 +910,9 @@ var MindooDBAppSessionImpl = class {
     return new MindooDBAppDatabaseImpl(this.rpc, databaseId);
   }
   async listDocumentsSinceViewCursor(cursor) {
-    return await this.rpc.call("session.listDocumentsSinceViewCursor", { cursor });
+    return await this.rpc.call("session.listDocumentsSinceViewCursor", {
+      cursor
+    });
   }
   /**
    * Create a navigator from an ad-hoc view definition and one or more database bindings.
@@ -761,7 +923,11 @@ var MindooDBAppSessionImpl = class {
    */
   async createViewNavigator(input) {
     const result = await this.rpc.call("session.createViewNavigator", input);
-    return new MindooDBAppViewNavigatorImpl(this.rpc, result.navigatorId, result.viewCursor);
+    return new MindooDBAppViewNavigatorImpl(
+      this.rpc,
+      result.navigatorId,
+      result.viewCursor
+    );
   }
   /**
    * Open a navigator for a preconfigured view that the host already knows about.
@@ -771,7 +937,11 @@ var MindooDBAppSessionImpl = class {
    */
   async openViewNavigator(viewId, options) {
     const result = await this.rpc.call("session.openViewNavigator", { viewId, options: options ?? {} });
-    return new MindooDBAppViewNavigatorImpl(this.rpc, result.navigatorId, result.viewCursor);
+    return new MindooDBAppViewNavigatorImpl(
+      this.rpc,
+      result.navigatorId,
+      result.viewCursor
+    );
   }
   /** Subscribe to host-pushed theme changes (dark/light mode, color tokens). */
   onThemeChange(listener) {
@@ -817,6 +987,146 @@ function createMindooDBAppBridge() {
   };
 }
 
+// src/textBuffer.ts
+var MindooDBTextBuffer = class {
+  constructor(options) {
+    this.options = options;
+    this.valueInternal = readTextAtPath(options.document.data, options.path);
+    this.heads = options.document.heads ? [...options.document.heads] : [];
+  }
+  options;
+  valueInternal;
+  heads;
+  pendingEdits = [];
+  get value() {
+    return this.valueInternal;
+  }
+  /** Whether there are local edits that have not been flushed yet. */
+  get dirty() {
+    return this.pendingEdits.length > 0;
+  }
+  /** Number of pending text operations currently buffered. */
+  get pendingCount() {
+    return this.pendingEdits.length;
+  }
+  /** Return the current local text value. */
+  toString() {
+    return this.valueInternal;
+  }
+  /**
+   * Apply an exact local text splice and queue it for the next flush.
+   *
+   * Offsets use JavaScript string indexing. The delete count is clamped to the
+   * remaining local text length so callers can safely delete to the end.
+   */
+  splice(index, deleteCount, insert = "") {
+    if (!Number.isInteger(index) || index < 0 || index > this.valueInternal.length) {
+      throw new RangeError("Text splice index is out of range");
+    }
+    if (!Number.isInteger(deleteCount) || deleteCount < 0) {
+      throw new RangeError("Text splice deleteCount must be a non-negative integer");
+    }
+    const clampedDeleteCount = Math.min(deleteCount, this.valueInternal.length - index);
+    this.valueInternal = this.valueInternal.slice(0, index) + insert + this.valueInternal.slice(index + clampedDeleteCount);
+    this.pendingEdits.push({ index, deleteCount: clampedDeleteCount, insert });
+  }
+  /**
+   * Replace the current local text value and queue the change as one splice.
+   *
+   * This is useful for editors such as Milkdown that can produce the full
+   * markdown string after each transaction but do not expose raw text splices.
+   */
+  replaceText(nextValue) {
+    if (nextValue === this.valueInternal) {
+      return;
+    }
+    const edit = computeSingleSplice(this.valueInternal, nextValue);
+    this.splice(edit.index, edit.deleteCount, edit.insert ?? "");
+  }
+  /**
+   * Replace local state from a fresh document snapshot and clear pending edits.
+   *
+   * Returns whether the text value changed. Use this after an external refresh
+   * or after receiving a document update through another app-level mechanism.
+   */
+  reconcile(document) {
+    const nextValue = readTextAtPath(document.data, this.options.path);
+    const changed = nextValue !== this.valueInternal;
+    this.valueInternal = nextValue;
+    this.heads = document.heads ? [...document.heads] : [];
+    this.pendingEdits = [];
+    return changed;
+  }
+  /**
+   * Flush pending edits to Haven using `documents.update({ text: ... })`.
+   *
+   * The request includes the document heads this buffer is based on, allowing
+   * Haven to apply the text operations at the original causal version and merge
+   * them with any concurrent document changes. After a successful flush the
+   * buffer adopts the returned canonical value and heads, and clears the
+   * pending edit queue.
+   */
+  async flush() {
+    if (this.pendingEdits.length === 0) {
+      return {
+        document: this.options.document,
+        value: this.valueInternal,
+        reconciled: false
+      };
+    }
+    const localValueAtFlush = this.valueInternal;
+    const document = await this.options.database.documents.update(this.options.document.id, {
+      text: [{
+        path: this.options.path,
+        baseHeads: this.heads,
+        edits: this.pendingEdits.map((edit) => ({ ...edit }))
+      }]
+    });
+    const nextValue = readTextAtPath(document.data, this.options.path);
+    const reconciled = nextValue !== localValueAtFlush;
+    this.valueInternal = nextValue;
+    this.heads = document.heads ? [...document.heads] : [];
+    this.pendingEdits = [];
+    return {
+      document,
+      value: this.valueInternal,
+      reconciled
+    };
+  }
+};
+function createMindooDBTextBuffer(options) {
+  return new MindooDBTextBuffer(options);
+}
+function readTextAtPath(data, path) {
+  let value = data;
+  for (const segment of path) {
+    if (value == null || typeof value !== "object") {
+      return "";
+    }
+    value = value[segment];
+  }
+  return typeof value === "string" ? value : "";
+}
+function computeSingleSplice(previous, next) {
+  let prefixLength = 0;
+  const maxPrefix = Math.min(previous.length, next.length);
+  while (prefixLength < maxPrefix && previous[prefixLength] === next[prefixLength]) {
+    prefixLength += 1;
+  }
+  let suffixLength = 0;
+  const previousRemaining = previous.length - prefixLength;
+  const nextRemaining = next.length - prefixLength;
+  const maxSuffix = Math.min(previousRemaining, nextRemaining);
+  while (suffixLength < maxSuffix && previous[previous.length - 1 - suffixLength] === next[next.length - 1 - suffixLength]) {
+    suffixLength += 1;
+  }
+  return {
+    index: prefixLength,
+    deleteCount: previous.length - prefixLength - suffixLength,
+    insert: next.slice(prefixLength, next.length - suffixLength)
+  };
+}
+
 // src/viewLanguage.ts
 import {
   createViewLanguage,
@@ -825,9 +1135,11 @@ import {
   mindooDBViewLanguageHelpersByName
 } from "mindoodb-view-language";
 export {
+  MindooDBTextBuffer,
   abbreviateCanonicalName,
   canPreviewAttachment,
   createMindooDBAppBridge,
+  createMindooDBTextBuffer,
   createViewLanguage,
   expandAbbreviatedName
 };

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { a4 as MindooDBAppLaunchContext, V as MindooDBAppDatabaseInfo, X as MindooDBAppDocumentApi, T as MindooDBAppCreateViewNavigatorInput, ay as MindooDBAppViewNavigator, aA as MindooDBAppViewNavigatorOpenOptions, b as MindooDBAppAttachmentApi, a as MindooDBAppBridge, ao as MindooDBAppSession, n as MindooDBAppBridgeRpcRequest, a3 as MindooDBAppHostTheme, aF as MindooDBAppViewport, as as MindooDBAppUiPreferences, k as MindooDBAppBridgePortMessage } from '../types-B1iKRIuy.js';
+import { ac as MindooDBAppLaunchContext, X as MindooDBAppDatabaseInfo, Y as MindooDBAppDocumentApi, W as MindooDBAppCreateViewNavigatorInput, aK as MindooDBAppViewNavigator, aM as MindooDBAppViewNavigatorOpenOptions, d as MindooDBAppAttachmentApi, a as MindooDBAppBridge, ay as MindooDBAppSession, q as MindooDBAppBridgeRpcRequest, a6 as MindooDBAppHostTheme, aR as MindooDBAppViewport, aE as MindooDBAppUiPreferences, n as MindooDBAppBridgePortMessage } from '../types-Dw6YRApH.js';
 import 'mindoodb-view-language';
 
 type MaybePromise<T> = T | Promise<T>;