mindoodb-app-sdk 0.0.71 → 0.0.73

package/dist/testing/index.js

@@ -1,11 +1,23 @@
 import {
   MINDOODB_APP_VALUE_TAG,
+  MindooDBAppEmbedValidationError,
   assertValidMindooDBCreateIds,
   mindooDBAppComponentFieldsMatch,
+  mindooDBAppComponentSupports,
+  mindooDBAppExportFile,
+  mindooDBAppExportPayload,
+  normalizeMindooDBAppEmbedExportRequest,
+  normalizeMindooDBAppEmbedVariables,
+  normalizeMindooDBAppInspectAnchor,
+  normalizeMindooDBAppInspectRequest,
+  normalizeMindooDBAppInspection,
+  normalizeMindooDBAppIssues,
   pageUsers,
+  performMindooDBAppEmbeddingSave,
   releaseMindooDBAppBridgeSessions,
+  resolveMindooDBAppEmbedValidation,
   validateMindooDBAppDefinition
-} from "../chunk-GTNDGA7P.js";
+} from "../chunk-FKTNDDWB.js";
 
 // src/testing/index.ts
 import * as Automerge from "@automerge/automerge";
@@ -470,6 +482,16 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
   let nextSaveError = null;
   let embeddingDirty;
   let saveRequestHandler = null;
+  let inspectionProvider = null;
+  let showIssuesHandler = null;
+  let revealHandler = null;
+  let exportProvider = null;
+  let embeddingVariables = normalizeMindooDBAppEmbedVariables(options.embeddingVariables ?? []);
+  const variableListeners = /* @__PURE__ */ new Set();
+  const embeddingValidations = [];
+  let embeddingSaveCount = 0;
+  const beforeSaveHandlers = /* @__PURE__ */ new Map();
+  const savedListeners = /* @__PURE__ */ new Set();
   let embedCounter = 0;
   let embeddingFinish = null;
   const accessRequests = [];
@@ -519,6 +541,18 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
     if (!mindooDBAppComponentFieldsMatch(component.match, document2.data)) {
       throw new Error(`Document ${input.docId} is not a "${component.label}" document.`);
     }
+    let template;
+    if (input.template) {
+      const databaseId = input.template.databaseId ?? input.databaseId;
+      const source = await getDatabase(databaseId).documents.get(input.template.docId);
+      if (!source || !mindooDBAppComponentFieldsMatch(component.match, source.data)) {
+        throw new Error(`Template ${input.template.docId} is not a "${component.label}" document.`);
+      }
+      if (!(component.supports ?? []).includes("template")) {
+        throw Object.assign(new Error(`Component "${component.label}" cannot start from a template.`), { name: "unsupported" });
+      }
+      template = { databaseId, docId: input.template.docId };
+    }
     embedCounter += 1;
     const embedId = `mock-embed-${embedCounter}`;
     embeds.set(embedId, {
@@ -530,7 +564,12 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
       rect: mockRect(input),
       visible: input.visible !== false,
       active: false,
-      agentTools: null
+      agentTools: null,
+      supports: [...component.supports ?? []],
+      beforeSave: null,
+      requests: [],
+      variables: normalizeMindooDBAppEmbedVariables(input.variables ?? []),
+      ...template ? { template } : {}
     });
     setActive(embedId);
     return embedId;
@@ -583,6 +622,7 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
     handles.get(embedId)?.settle(event);
     handles.delete(embedId);
     toolNames.delete(embedId);
+    beforeSaveHandlers.delete(embedId);
     closedListeners.forEach((listener) => listener(event));
     notifyChange();
   }
@@ -605,6 +645,46 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
     closed;
     dirty = void 0;
     dirtyListeners = /* @__PURE__ */ new Set();
+    savedListeners = /* @__PURE__ */ new Set();
+    get supports() {
+      return embeds.get(this.embedId)?.supports ?? [];
+    }
+    async inspect(request) {
+      return await inspectEmbed(this.embedId, request);
+    }
+    onBeforeSave(handler, options2) {
+      setBeforeSave(this.embedId, handler, options2?.inspect);
+      return () => {
+        if (beforeSaveHandlers.get(this.embedId) === handler) {
+          setBeforeSave(this.embedId, null);
+        }
+      };
+    }
+    onAfterSave(listener) {
+      this.savedListeners.add(listener);
+      return () => {
+        this.savedListeners.delete(listener);
+      };
+    }
+    notifySaved() {
+      const event = { embedId: this.embedId };
+      this.savedListeners.forEach((listener) => listener(event));
+    }
+    async showIssues(issues) {
+      await showEmbedIssues(this.embedId, issues);
+    }
+    async reveal(anchor) {
+      await revealInEmbed(this.embedId, anchor);
+    }
+    async callTool(name, input) {
+      return await callEmbedTool(this.embedId, name, input ?? {});
+    }
+    async setVariables(variables) {
+      setEmbedVariables(this.embedId, variables);
+    }
+    async export(request) {
+      return mindooDBAppExportFile(await exportEmbed(this.embedId, request));
+    }
     onDirtyChange(listener) {
       this.dirtyListeners.add(listener);
       return () => {
@@ -704,7 +784,8 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
     notifyChange();
   }
   async function saveEmbed(embedId) {
-    if (!embeds.has(embedId)) {
+    const entry = embeds.get(embedId);
+    if (!entry) {
       throw new Error("Unknown embed.");
     }
     const error = nextSaveError;
@@ -712,7 +793,130 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
     if (error) {
       throw new Error(error);
     }
+    if (mindooDBAppComponentSupports(entry.supports, "validate")) {
+      const validation = await validateEmbed(embedId);
+      if (!validation.ok) {
+        throw new MindooDBAppEmbedValidationError(validation.issues);
+      }
+    }
     setEmbedDirty(embedId, false);
+    notifyEmbedSaved(embedId);
+  }
+  function entryOf(embedId) {
+    const entry = embeds.get(embedId);
+    if (!entry) {
+      throw new Error("Unknown embed.");
+    }
+    return entry;
+  }
+  function unsupported(message) {
+    return Object.assign(new Error(message), { name: "unsupported" });
+  }
+  async function inspectEmbed(embedId, request) {
+    const entry = entryOf(embedId);
+    const inspect = normalizeMindooDBAppInspectRequest(request);
+    entry.requests.push({ request: "inspect", inspect });
+    if (!options.embedInspection || !mindooDBAppComponentSupports(entry.supports, "inspect")) {
+      throw unsupported("The component cannot describe its document.");
+    }
+    return normalizeMindooDBAppInspection(await options.embedInspection(structuredClone(entry), inspect));
+  }
+  function setBeforeSave(embedId, handler, inspect) {
+    const entry = entryOf(embedId);
+    if (handler) {
+      beforeSaveHandlers.set(embedId, handler);
+      entry.beforeSave = { inspect: normalizeMindooDBAppInspectRequest(inspect) };
+    } else {
+      beforeSaveHandlers.delete(embedId);
+      entry.beforeSave = null;
+    }
+    notifyChange();
+  }
+  async function validateEmbed(embedId, validateOptions = {}) {
+    const entry = entryOf(embedId);
+    const handler = beforeSaveHandlers.get(embedId);
+    if (!handler) {
+      return { ok: true, issues: [] };
+    }
+    let inspection = null;
+    if (options.embedInspection && mindooDBAppComponentSupports(entry.supports, "inspect")) {
+      inspection = normalizeMindooDBAppInspection(
+        await options.embedInspection(structuredClone(entry), entry.beforeSave?.inspect ?? {})
+      );
+    }
+    const root = await getDatabase(entry.databaseId).documents.get(entry.docId);
+    const answer = await handler({
+      embedId,
+      inspection,
+      root: root ? JSON.parse(JSON.stringify(root.data)) : null
+    });
+    return await resolveMindooDBAppEmbedValidation(
+      normalizeMindooDBAppIssues(answer?.issues),
+      validateOptions.interactive !== false,
+      options.confirmSaveWarnings ?? (() => true)
+    );
+  }
+  function notifyEmbedSaved(embedId) {
+    if (!embeds.has(embedId)) {
+      return;
+    }
+    handles.get(embedId)?.notifySaved();
+    savedListeners.forEach((listener) => listener({ embedId }));
+  }
+  async function showEmbedIssues(embedId, issues) {
+    const entry = entryOf(embedId);
+    entry.requests.push({ request: "showIssues", issues: normalizeMindooDBAppIssues(issues) });
+    if (!mindooDBAppComponentSupports(entry.supports, "issues")) {
+      throw unsupported("The component cannot show issues.");
+    }
+  }
+  async function revealInEmbed(embedId, anchor) {
+    const entry = entryOf(embedId);
+    const normalized = normalizeMindooDBAppInspectAnchor(anchor);
+    if (!normalized) {
+      throw new Error("Invalid anchor.");
+    }
+    entry.requests.push({ request: "reveal", anchor: normalized });
+    if (!mindooDBAppComponentSupports(entry.supports, "reveal")) {
+      throw unsupported("The component cannot reveal places.");
+    }
+  }
+  async function callEmbedTool(embedId, name, input) {
+    const entry = entryOf(embedId);
+    const prefix = `${toolPrefix(entry.component)}_`;
+    const bare = name.startsWith(prefix) ? name.slice(prefix.length) : name;
+    entry.requests.push({ request: "callTool", name: bare, input: structuredClone(input) });
+    if (!options.embedTools) {
+      throw unsupported(`The component has no tool "${bare}".`);
+    }
+    return structuredClone(await options.embedTools(structuredClone(entry), bare, structuredClone(input)));
+  }
+  async function validateEmbedding(validateOptions = {}) {
+    const interactive = validateOptions.interactive !== false;
+    const raw = await options.embeddingValidation?.({ interactive }) ?? { ok: true, issues: [] };
+    const result = {
+      ok: raw.ok !== false,
+      issues: normalizeMindooDBAppIssues(raw.issues),
+      ...raw.timedOut ? { timedOut: true } : {}
+    };
+    embeddingValidations.push({ interactive, result: structuredClone(result) });
+    return result;
+  }
+  function setEmbedVariables(embedId, variables) {
+    entryOf(embedId).variables = normalizeMindooDBAppEmbedVariables(variables);
+    notifyChange();
+  }
+  async function exportEmbed(embedId, request) {
+    const entry = entryOf(embedId);
+    const normalized = normalizeMindooDBAppEmbedExportRequest(request);
+    entry.requests.push({ request: "export", export: normalized });
+    if (!options.embedExport || !mindooDBAppComponentSupports(entry.supports, `export:${normalized.format}`)) {
+      throw unsupported(`The component cannot export ${normalized.format}.`);
+    }
+    return await mindooDBAppExportPayload(await options.embedExport(structuredClone(entry), normalized), normalized);
+  }
+  function unsupportedHandler() {
+    throw unsupported("unsupported");
   }
   function setVisible(embedId, visible) {
     const entry = embeds.get(embedId);
@@ -724,7 +928,7 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
   return {
     components: {
       async list(query) {
-        return components.filter((entry) => !query?.intent || entry.intents.includes(query.intent)).filter((entry) => !query?.document || mindooDBAppComponentFieldsMatch(entry.match, query.document)).map((entry) => structuredClone(entry));
+        return components.filter((entry) => !query?.intent || entry.intents.includes(query.intent)).filter((entry) => (query?.requires ?? []).every((requirement) => mindooDBAppComponentSupports(entry.supports, requirement))).filter((entry) => !query?.document || mindooDBAppComponentFieldsMatch(entry.match, query.document)).map((entry) => structuredClone(entry));
       }
     },
     embeds: {
@@ -759,6 +963,51 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
             saveRequestHandler = null;
           }
         };
+      },
+      provideInspection(provider) {
+        inspectionProvider = provider;
+        return () => {
+          if (inspectionProvider === provider) inspectionProvider = null;
+        };
+      },
+      onShowIssues(handler) {
+        showIssuesHandler = handler;
+        return () => {
+          if (showIssuesHandler === handler) showIssuesHandler = null;
+        };
+      },
+      onReveal(handler) {
+        revealHandler = handler;
+        return () => {
+          if (revealHandler === handler) revealHandler = null;
+        };
+      },
+      validate: validateEmbedding,
+      async getVariables() {
+        return embeddingVariables.map((variable) => ({ ...variable }));
+      },
+      onVariablesChange(listener) {
+        variableListeners.add(listener);
+        return () => {
+          variableListeners.delete(listener);
+        };
+      },
+      provideExport(provider) {
+        exportProvider = provider;
+        return () => {
+          if (exportProvider === provider) exportProvider = null;
+        };
+      },
+      async save(flush, saveOptions) {
+        return await performMindooDBAppEmbeddingSave({
+          validate: () => validateEmbedding(saveOptions),
+          provider: inspectionProvider,
+          showIssues: showIssuesHandler,
+          flush,
+          saved: () => {
+            embeddingSaveCount += 1;
+          }
+        });
       }
     },
     openEmbed,
@@ -822,6 +1071,58 @@ function createMockEmbedHost(options, getDatabase, listDatabaseIds = () => []) {
     },
     setSaveRequestHandler(handler) {
       saveRequestHandler = handler;
+    },
+    inspectEmbed,
+    setBeforeSave,
+    validateEmbed,
+    notifyEmbedSaved,
+    onSaved(listener) {
+      savedListeners.add(listener);
+      return () => {
+        savedListeners.delete(listener);
+      };
+    },
+    showEmbedIssues,
+    revealInEmbed,
+    callEmbedTool,
+    getEmbedRequests(embedId) {
+      return structuredClone(embeds.get(embedId)?.requests ?? []);
+    },
+    async requestEmbeddingInspection(request) {
+      if (!inspectionProvider) unsupportedHandler();
+      return normalizeMindooDBAppInspection(await inspectionProvider(normalizeMindooDBAppInspectRequest(request)));
+    },
+    async requestEmbeddingShowIssues(issues) {
+      if (!showIssuesHandler) unsupportedHandler();
+      await showIssuesHandler(normalizeMindooDBAppIssues(issues));
+    },
+    async requestEmbeddingReveal(anchor) {
+      if (!revealHandler) unsupportedHandler();
+      await revealHandler(anchor);
+    },
+    getEmbeddingValidations() {
+      return structuredClone(embeddingValidations);
+    },
+    getEmbeddingSaveCount() {
+      return embeddingSaveCount;
+    },
+    validateEmbedding,
+    recordEmbeddingSaved() {
+      embeddingSaveCount += 1;
+    },
+    setEmbedVariables,
+    exportEmbed,
+    async requestEmbeddingVariables(variables) {
+      embeddingVariables = normalizeMindooDBAppEmbedVariables(variables);
+      variableListeners.forEach((listener) => listener(embeddingVariables.map((variable) => ({ ...variable }))));
+    },
+    getEmbeddingVariables() {
+      return embeddingVariables.map((variable) => ({ ...variable }));
+    },
+    async requestEmbeddingExport(request) {
+      if (!exportProvider) unsupportedHandler();
+      const normalized = normalizeMindooDBAppEmbedExportRequest(request);
+      return mindooDBAppExportFile(await mindooDBAppExportPayload(await exportProvider(normalized), normalized));
     }
   };
 }
@@ -6030,7 +6331,17 @@ function createMockMindooDBAppSession(options = {}) {
     setEmbedAgentTools: (embedId, names, toolOptions) => state.embedHost.setEmbedAgentTools(embedId, names, toolOptions),
     failNextEmbedSave: (message) => state.embedHost.failNextSave(message),
     getEmbeddingDirty: () => state.embedHost.getEmbeddingDirty(),
-    requestEmbeddingSave: () => state.embedHost.requestEmbeddingSave()
+    requestEmbeddingSave: () => state.embedHost.requestEmbeddingSave(),
+    validateEmbed: (embedId, validateOptions) => state.embedHost.validateEmbed(embedId, validateOptions),
+    notifyEmbedSaved: (embedId) => state.embedHost.notifyEmbedSaved(embedId),
+    getEmbedRequests: (embedId) => state.embedHost.getEmbedRequests(embedId),
+    requestEmbeddingInspection: (request) => state.embedHost.requestEmbeddingInspection(request),
+    requestEmbeddingShowIssues: (issues) => state.embedHost.requestEmbeddingShowIssues(issues),
+    requestEmbeddingReveal: (anchor) => state.embedHost.requestEmbeddingReveal(anchor),
+    getEmbeddingValidations: () => state.embedHost.getEmbeddingValidations(),
+    getEmbeddingSaveCount: () => state.embedHost.getEmbeddingSaveCount(),
+    requestEmbeddingVariables: (variables) => state.embedHost.requestEmbeddingVariables(variables),
+    requestEmbeddingExport: (request) => state.embedHost.requestEmbeddingExport(request)
   };
   replicaStates.set(controller, state);
   return controller;
@@ -6076,8 +6387,25 @@ function createFakeBridgeHost(options = {}) {
       (port) => port.postMessage({ protocol: PROTOCOL, kind: "embed-event", event: { type: "agentTools", ...event } })
     );
   });
+  state.embedHost.onSaved((event) => {
+    connectedPorts.forEach(
+      (port) => port.postMessage({ protocol: PROTOCOL, kind: "embed-event", event: { type: "saved", ...event } })
+    );
+  });
   const embeddingRequests = /* @__PURE__ */ new Map();
   let embeddingRequestCounter = 0;
+  function pushEmbeddingRequest(request, params) {
+    embeddingRequestCounter += 1;
+    const requestId = `embedding-request-${embeddingRequestCounter}`;
+    return new Promise((resolve, reject) => {
+      embeddingRequests.set(requestId, { resolve, reject });
+      connectedPorts.forEach(
+        (port) => port.postMessage({ protocol: PROTOCOL, kind: "embedding-request", requestId, request, ...params ? { params } : {} })
+      );
+    });
+  }
+  const embedRequests = /* @__PURE__ */ new Map();
+  let embedRequestCounter = 0;
   const beforeCloseWaiters = /* @__PURE__ */ new Map();
   let beforeCloseCounter = 0;
   const viewSessions = /* @__PURE__ */ new Map();
@@ -6314,8 +6642,73 @@ function createFakeBridgeHost(options = {}) {
       case "embeds.open": {
         const input = params.input;
         const embedId = await state.embedHost.openEmbed(input);
-        return input.placement === "frame" && options.embedFrameUrl ? { embedId, frame: { url: options.embedFrameUrl } } : { embedId };
+        const supports = state.embedHost.listEmbeds().find((entry) => entry.embedId === embedId)?.supports ?? [];
+        return {
+          embedId,
+          ...input.placement === "frame" && options.embedFrameUrl ? { frame: { url: options.embedFrameUrl } } : {},
+          ...supports.length ? { supports } : {}
+        };
+      }
+      case "embeds.inspect":
+        return await state.embedHost.inspectEmbed(
+          String(params.embedId),
+          params.request
+        );
+      case "embeds.setBeforeSave": {
+        const embedId = String(params.embedId);
+        state.embedHost.setBeforeSave(
+          embedId,
+          params.enabled === true ? (input) => {
+            embedRequestCounter += 1;
+            const requestId = `embed-request-${embedRequestCounter}`;
+            return new Promise((resolve) => {
+              embedRequests.set(requestId, (result) => resolve(result));
+              connectedPorts.forEach(
+                (port) => port.postMessage({
+                  protocol: PROTOCOL,
+                  kind: "embed-request",
+                  requestId,
+                  embedId,
+                  request: "beforeSave",
+                  params: { inspection: input.inspection, root: input.root }
+                })
+              );
+            });
+          } : null,
+          params.inspect
+        );
+        return { ok: true };
+      }
+      case "embeds.respond": {
+        const resolve = embedRequests.get(String(params.requestId));
+        embedRequests.delete(String(params.requestId));
+        resolve?.(params.ok === true ? params.result : { issues: [] });
+        return { ok: true };
       }
+      case "embeds.showIssues":
+        await state.embedHost.showEmbedIssues(String(params.embedId), params.issues);
+        return { ok: true };
+      case "embeds.reveal":
+        await state.embedHost.revealInEmbed(String(params.embedId), params.anchor);
+        return { ok: true };
+      case "embeds.callTool":
+        return await state.embedHost.callEmbedTool(
+          String(params.embedId),
+          String(params.name),
+          params.input ?? {}
+        );
+      case "embeds.setVariables":
+        state.embedHost.setEmbedVariables(String(params.embedId), params.variables);
+        return { ok: true };
+      case "embeds.export":
+        return await state.embedHost.exportEmbed(String(params.embedId), params.request);
+      case "embedding.getVariables":
+        return { variables: state.embedHost.getEmbeddingVariables() };
+      case "embedding.validate":
+        return await state.embedHost.validateEmbedding({ interactive: params.interactive !== false });
+      case "embedding.saved":
+        state.embedHost.recordEmbeddingSaved();
+        return { ok: true };
       case "embeds.requestAccess":
         return await state.embedHost.embeds.requestAccess(
           params.input ?? { components: [] }
@@ -6348,9 +6741,10 @@ function createFakeBridgeHost(options = {}) {
         const pending = embeddingRequests.get(String(params.requestId));
         embeddingRequests.delete(String(params.requestId));
         if (params.ok === true) {
-          pending?.resolve();
+          pending?.resolve(params.result);
         } else {
-          pending?.reject(new Error(typeof params.error === "string" ? params.error : "Save failed."));
+          const message = typeof params.error === "string" ? params.error : "Save failed.";
+          pending?.reject(Object.assign(new Error(message), message === "unsupported" ? { name: "unsupported" } : {}));
         }
         return { ok: true };
       }
@@ -6988,15 +7382,29 @@ function createFakeBridgeHost(options = {}) {
     setEmbedAgentTools: (embedId, names, toolOptions) => state.embedHost.setEmbedAgentTools(embedId, names, toolOptions),
     failNextEmbedSave: (message) => state.embedHost.failNextSave(message),
     getEmbeddingDirty: () => state.embedHost.getEmbeddingDirty(),
-    requestEmbeddingSave() {
-      embeddingRequestCounter += 1;
-      const requestId = `embedding-request-${embeddingRequestCounter}`;
-      return new Promise((resolve, reject) => {
-        embeddingRequests.set(requestId, { resolve, reject });
-        connectedPorts.forEach(
-          (port) => port.postMessage({ protocol: PROTOCOL, kind: "embedding-request", requestId, request: "save" })
-        );
-      });
+    async requestEmbeddingSave() {
+      await pushEmbeddingRequest("save");
+    },
+    validateEmbed: (embedId, validateOptions) => state.embedHost.validateEmbed(embedId, validateOptions),
+    notifyEmbedSaved: (embedId) => state.embedHost.notifyEmbedSaved(embedId),
+    getEmbedRequests: (embedId) => state.embedHost.getEmbedRequests(embedId),
+    async requestEmbeddingInspection(request) {
+      return await pushEmbeddingRequest("inspect", { request: request ?? {} });
+    },
+    async requestEmbeddingShowIssues(issues) {
+      await pushEmbeddingRequest("showIssues", { issues });
+    },
+    async requestEmbeddingReveal(anchor) {
+      await pushEmbeddingRequest("reveal", { anchor });
+    },
+    getEmbeddingValidations: () => state.embedHost.getEmbeddingValidations(),
+    getEmbeddingSaveCount: () => state.embedHost.getEmbeddingSaveCount(),
+    async requestEmbeddingVariables(variables) {
+      await state.embedHost.requestEmbeddingVariables(variables);
+      await pushEmbeddingRequest("variables", { variables: state.embedHost.getEmbeddingVariables() });
+    },
+    async requestEmbeddingExport(request) {
+      return mindooDBAppExportFile(await pushEmbeddingRequest("export", { request }));
     },
     dispose() {
       restoreWindow();