grist-widget-sdk 0.3.26 → 0.4.0

package/dist/emulator.cjs

@@ -86,26 +86,7 @@ function coerceGristDocApiRefRowId(value) {
   return void 0;
 }
 
-// src/sdk/helpers/grist-safe-parse.ts
-var import_zod = require("zod");
-var gristSafeRefValueSchema = import_zod.z.object({
-  rowId: import_zod.z.number(),
-  display: import_zod.z.string().nullable().optional()
-});
-var gristSafeRefListValueSchema = import_zod.z.object({
-  rowIds: import_zod.z.array(import_zod.z.number()),
-  displays: import_zod.z.array(import_zod.z.string()).optional()
-});
-var gristCellValueSchema = import_zod.z.union([
-  import_zod.z.null(),
-  import_zod.z.string(),
-  import_zod.z.number(),
-  import_zod.z.boolean(),
-  import_zod.z.date(),
-  import_zod.z.array(import_zod.z.unknown()),
-  gristSafeRefValueSchema,
-  gristSafeRefListValueSchema
-]);
+// src/emulator/core/display-helpers.ts
 function inferDisplayHelpersByRef(columns) {
   const out = {};
   const helperColumns = Object.entries(columns).filter(
@@ -918,8 +899,9 @@ function createWidgetApiImpl(state, bus) {
     async getOptions() {
       return Object.keys(state.widgetOptions).length > 0 ? { ...state.widgetOptions } : null;
     },
+    // Replaces every option, as Grist's WidgetAPI.setOptions does.
     async setOptions(options) {
-      state.widgetOptions = { ...state.widgetOptions, ...options };
+      state.widgetOptions = { ...options };
       emit();
     },
     async clearOptions() {
@@ -985,157 +967,6 @@ function buildGristThemeHostMessage(appearance, options) {
   };
 }
 
-// src/emulator/transports/iframe.ts
-var import_grain_rpc = require("grain-rpc");
-function createIframeTransport(options) {
-  const { iframe, state, bus, api, targetOrigin = "*" } = options;
-  const timers = /* @__PURE__ */ new Set();
-  const rpc = new import_grain_rpc.Rpc({
-    sendMessage: (msg) => {
-      const target = iframe.contentWindow;
-      if (!target) return;
-      target.postMessage(msg, targetOrigin);
-    },
-    logger: { info: () => {
-    }, warn: () => {
-    } }
-  });
-  rpc.queueOutgoingUntilReadyMessage();
-  const receiveFromWidget = rpc.receiveMessage.bind(rpc);
-  rpc.receiveMessage = (msg) => {
-    if (msg && typeof msg === "object" && msg.mtype === import_grain_rpc.MsgType.RpcCall && msg.mdest === "grist") {
-      const copy = { ...msg };
-      delete copy.mdest;
-      receiveFromWidget(copy);
-      return;
-    }
-    receiveFromWidget(msg);
-  };
-  const onMessage = (event) => {
-    if (event.source !== iframe.contentWindow) return;
-    if (!isRpcEnvelope(event.data)) return;
-    rpc.receiveMessage(event.data);
-  };
-  window.addEventListener("message", onMessage);
-  rpc.registerImpl("GristView", api.GristView);
-  rpc.registerImpl("GristDocAPI", api.GristDocAPI);
-  rpc.registerImpl("WidgetAPI", api.WidgetAPI);
-  rpc.registerImpl("CustomSectionAPI", api.CustomSectionAPI);
-  rpc.registerImpl("_grist_api", api.GristAPI);
-  rpc.registerImpl("CommandAPI", api.CommandAPI);
-  const buildInteraction = options.buildInteraction ?? defaultInteraction(state);
-  const cursorOf = options.cursor ?? (() => state.selection.cursor);
-  const initialCursorOf = options.initialCursor ?? (() => state.selection.rowId);
-  function fireDataChange(tableId, opts) {
-    safePostMessage({
-      tableId: tableId ?? state.selection.tableId,
-      dataChange: true,
-      ...opts?.mappingsChange ? { mappingsChange: true } : {}
-    });
-  }
-  function fireCursor(rowId, opts) {
-    const id = rowId === void 0 ? initialCursorOf() : rowId;
-    if (id === null) return;
-    safePostMessage({
-      tableId: state.selection.tableId,
-      rowId: id,
-      cursor: cursorOf(),
-      ...opts?.mappingsChange ? { mappingsChange: true } : {}
-    });
-  }
-  function fireOptions() {
-    safePostMessage({
-      options: hasOptions(state.widgetOptions) ? { ...state.widgetOptions } : null,
-      settings: { ...buildInteraction() }
-    });
-  }
-  function fireTheme(message) {
-    safePostMessage(message);
-  }
-  function emitInitialState(opts) {
-    fireOptions();
-    if (options.initialTheme) {
-      fireTheme(buildGristThemeHostMessage(options.initialTheme, { fromReady: true }));
-    }
-    fireDataChange(void 0, opts);
-    fireCursor(void 0, opts);
-  }
-  function emitInitialStateWithReplay(opts) {
-    emitInitialState(opts);
-    queueMicrotask(() => emitInitialState(opts));
-    const timer = setTimeout(() => {
-      timers.delete(timer);
-      emitInitialState(opts);
-    }, 0);
-    timers.add(timer);
-  }
-  const offBus = bus.on((event) => {
-    switch (event.type) {
-      case "ready":
-        emitInitialStateWithReplay();
-        break;
-      case "data-change":
-        fireDataChange(event.tableId);
-        break;
-      case "cursor-change": {
-        const rowId = event.rowId === null ? state.selection.rowId : event.rowId;
-        if (rowId !== null) {
-          safePostMessage({
-            tableId: event.tableId,
-            rowId,
-            cursor: cursorOf()
-          });
-        }
-        fireDataChange(event.tableId);
-        break;
-      }
-      case "options-change":
-        fireOptions();
-        break;
-      case "mappings-change":
-        emitInitialStateWithReplay({ mappingsChange: true });
-        break;
-      case "theme-change":
-        fireTheme(event.message);
-        break;
-    }
-  });
-  rpc.processIncoming();
-  function safePostMessage(payload) {
-    try {
-      rpc.postMessage(payload);
-    } catch (err) {
-      console.warn("[grist-emulator/iframe] failed to deliver postMessage", err);
-    }
-  }
-  return {
-    dispose() {
-      window.removeEventListener("message", onMessage);
-      offBus();
-      for (const timer of timers) clearTimeout(timer);
-      timers.clear();
-    },
-    fireDataChange,
-    fireCursor,
-    fireOptions,
-    fireTheme,
-    emitInitialState
-  };
-}
-function hasOptions(options) {
-  return Object.keys(options).length > 0;
-}
-function isRpcEnvelope(data) {
-  if (!data || typeof data !== "object") return false;
-  return typeof data.mtype === "number";
-}
-function defaultInteraction(state) {
-  return () => ({
-    access_level: state.configuration?.requiredAccess ?? "read table",
-    ...state.widgetInteraction
-  });
-}
-
 // src/sdk/helpers/grist-user-actions.ts
 function gristUpdateRecordAction(tableId, rowId, patch) {
   return ["UpdateRecord", tableId, rowId, patch];
@@ -1191,14 +1022,6 @@ function createInlineTransport(options) {
           logErr(err);
         }
       }
-      lastRecord = { record: null, mappings };
-      for (const [cb] of recordCbs) {
-        try {
-          cb(null, mappings);
-        } catch (err) {
-          logErr(err);
-        }
-      }
       return;
     }
     if (rowId === null) {
@@ -1537,57 +1360,57 @@ function installFakeIframeContext(target) {
 }
 
 // src/emulator/validators.ts
-var import_zod2 = require("zod");
-var emulatorRowSchema = import_zod2.z.object({ id: import_zod2.z.number() }).catchall(import_zod2.z.unknown());
-var formulaKindSchema = import_zod2.z.enum(["computed", "trigger", "none", "empty_slot"]);
-var replicaColumnSchema = import_zod2.z.object({
-  colRef: import_zod2.z.number().optional(),
-  type: import_zod2.z.string().optional(),
-  label: import_zod2.z.string().optional(),
-  parentPos: import_zod2.z.number().optional(),
-  isFormula: import_zod2.z.boolean().optional(),
+var import_zod = require("zod");
+var emulatorRowSchema = import_zod.z.object({ id: import_zod.z.number() }).catchall(import_zod.z.unknown());
+var formulaKindSchema = import_zod.z.enum(["computed", "trigger", "none", "empty_slot"]);
+var replicaColumnSchema = import_zod.z.object({
+  colRef: import_zod.z.number().optional(),
+  type: import_zod.z.string().optional(),
+  label: import_zod.z.string().optional(),
+  parentPos: import_zod.z.number().optional(),
+  isFormula: import_zod.z.boolean().optional(),
   formulaKind: formulaKindSchema.optional(),
-  formula: import_zod2.z.string().optional(),
-  description: import_zod2.z.string().optional(),
-  widgetOptions: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
-  displayColRef: import_zod2.z.number().optional(),
-  visibleColRef: import_zod2.z.number().optional()
+  formula: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  widgetOptions: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  displayColRef: import_zod.z.number().optional(),
+  visibleColRef: import_zod.z.number().optional()
 }).strict();
-var replicaTableSchema = import_zod2.z.object({
-  label: import_zod2.z.string().optional(),
-  columns: import_zod2.z.record(import_zod2.z.string(), replicaColumnSchema).optional(),
-  rows: import_zod2.z.array(emulatorRowSchema).optional(),
-  rowCount: import_zod2.z.number().optional(),
-  dataOmitted: import_zod2.z.boolean().optional(),
-  dataOmittedReason: import_zod2.z.string().optional(),
-  error: import_zod2.z.string().optional()
+var replicaTableSchema = import_zod.z.object({
+  label: import_zod.z.string().optional(),
+  columns: import_zod.z.record(import_zod.z.string(), replicaColumnSchema).optional(),
+  rows: import_zod.z.array(emulatorRowSchema).optional(),
+  rowCount: import_zod.z.number().optional(),
+  dataOmitted: import_zod.z.boolean().optional(),
+  dataOmittedReason: import_zod.z.string().optional(),
+  error: import_zod.z.string().optional()
 }).strict();
-var replicaSelectionSchema = import_zod2.z.object({
-  tableId: import_zod2.z.string().optional(),
-  rowId: import_zod2.z.union([import_zod2.z.number(), import_zod2.z.literal("new"), import_zod2.z.null()]).optional(),
-  mappings: import_zod2.z.unknown().nullable().optional(),
-  cursor: import_zod2.z.unknown().optional()
+var replicaSelectionSchema = import_zod.z.object({
+  tableId: import_zod.z.string().optional(),
+  rowId: import_zod.z.union([import_zod.z.number(), import_zod.z.literal("new"), import_zod.z.null()]).optional(),
+  mappings: import_zod.z.unknown().nullable().optional(),
+  cursor: import_zod.z.unknown().optional()
 }).strict();
-var replicaWidgetConfigurationSchema = import_zod2.z.object({
-  requiredAccess: import_zod2.z.string().optional(),
-  columns: import_zod2.z.unknown().optional(),
-  allowSelectBy: import_zod2.z.boolean().optional(),
-  hasCustomOptions: import_zod2.z.boolean().optional()
+var replicaWidgetConfigurationSchema = import_zod.z.object({
+  requiredAccess: import_zod.z.string().optional(),
+  columns: import_zod.z.unknown().optional(),
+  allowSelectBy: import_zod.z.boolean().optional(),
+  hasCustomOptions: import_zod.z.boolean().optional()
 }).strict();
-var replicaAccessTokenSchema = import_zod2.z.object({
-  token: import_zod2.z.string(),
-  baseUrl: import_zod2.z.string(),
-  ttlMsecs: import_zod2.z.number()
+var replicaAccessTokenSchema = import_zod.z.object({
+  token: import_zod.z.string(),
+  baseUrl: import_zod.z.string(),
+  ttlMsecs: import_zod.z.number()
 }).strict();
-var replicaDocumentSchema = import_zod2.z.object({
-  generatedAt: import_zod2.z.string(),
-  source: import_zod2.z.string().optional(),
-  docName: import_zod2.z.string().optional(),
-  mode: import_zod2.z.enum(["schema-only", "schema+samples", "schema+data"]).optional(),
-  tables: import_zod2.z.record(import_zod2.z.string(), replicaTableSchema),
+var replicaDocumentSchema = import_zod.z.object({
+  generatedAt: import_zod.z.string(),
+  source: import_zod.z.string().optional(),
+  docName: import_zod.z.string().optional(),
+  mode: import_zod.z.enum(["schema-only", "schema+samples", "schema+data"]).optional(),
+  tables: import_zod.z.record(import_zod.z.string(), replicaTableSchema),
   selection: replicaSelectionSchema.optional(),
-  widgetOptions: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
-  widgetInteraction: import_zod2.z.unknown().optional(),
+  widgetOptions: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  widgetInteraction: import_zod.z.unknown().optional(),
   configuration: replicaWidgetConfigurationSchema.optional(),
   accessToken: replicaAccessTokenSchema.nullable().optional()
 }).strict().refine((value) => Object.keys(value.tables).length > 0, {
@@ -1618,34 +1441,21 @@ function createGristEmulator(options) {
   const state = createDocument({
     ...validatedDocument,
     widgetOptions: options.widgetOptions ?? validatedDocument.widgetOptions,
-    widgetInteraction: options.widgetInteraction ?? validatedDocument.widgetInteraction ?? { access_level: "read table" }
+    // No access_level by default: the emulator then grants the access the
+    // widget asks for in grist.ready(), as a user accepting it in Grist would.
+    widgetInteraction: options.widgetInteraction ?? validatedDocument.widgetInteraction ?? {}
   });
   const bus = createEventBus();
   const api = createApiBundle(state, bus);
-  const transportKind = options.transport?.kind ?? "inline";
-  let transport;
-  let grist;
-  if (transportKind === "iframe") {
-    if (options.transport?.kind !== "iframe") throw new Error("transport mismatch");
-    transport = createIframeTransport({
-      iframe: options.transport.iframe,
-      targetOrigin: options.transport.targetOrigin,
-      state,
-      bus,
-      api,
-      initialTheme: options.initialTheme
-    });
-  } else {
-    const inline = createInlineTransport({
-      state,
-      bus,
-      api,
-      initialTheme: options.initialTheme,
-      target: options.transport?.kind === "inline" ? options.transport.target : void 0
-    });
-    transport = inline;
-    grist = inline.grist;
-  }
+  const inline = createInlineTransport({
+    state,
+    bus,
+    api,
+    initialTheme: options.initialTheme,
+    target: options.transport?.target
+  });
+  const transport = inline;
+  const grist = inline.grist;
   function apply(actions) {
     return applyUserActions(state, bus, actions);
   }