@colixsystems/widget-sdk 0.275.2 → 0.277.0

package/dist/lucideIconName.cjs

@@ -1,8 +1,16 @@
-// CommonJS twin of lucideIconName.js for the backend (the page service +
-// any other Node consumer require this). Keep the two in sync — same
-// algorithm, same behaviour. See lucideIconName.js for the rationale.
+// GENERATED from lucideIconName.js by scripts/generate-cjs.js — DO NOT EDIT.
+// Change lucideIconName.js, then run `npm run generate:cjs` in packages/widget-sdk.
 "use strict";
 
+// Normalize a human-typed Lucide icon name to the PascalCase form Lucide
+// exports its components under. The lucide.dev gallery shows kebab-case
+// (`arrow-right`) and its copy button hands you kebab-case, but
+// `lucide-react` / `lucide-react-native` key their components in PascalCase
+// (`ArrowRight`). This bridges the two so any of kebab / snake / spaced /
+// camel / PascalCase resolves: `arrow-right`, `arrow_right`, `arrow right`,
+// `arrowRight`, and `ArrowRight` all become `ArrowRight`; `building-2` becomes
+// `Building2`. Non-strings and blanks return "" so callers fall back to a
+// placeholder. Already-PascalCase names pass through unchanged.
 function normalizeLucideIconName(name) {
   if (typeof name !== "string") return "";
   const trimmed = name.trim();
@@ -13,5 +21,6 @@ function normalizeLucideIconName(name) {
     .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
     .join("");
 }
-
-module.exports = { normalizeLucideIconName };
+module.exports = {
+  normalizeLucideIconName,
+};

package/dist/manifest.cjs

@@ -1,11 +1,12 @@
-// CommonJS mirror of manifest.js. Lets backend services (CJS) call
-// `validateManifest(...)` without a dynamic-import detour. The two files
-// share their constants by mutual import via createRequire — manifest.js
-// re-exports the same functions defined here so there is exactly one
-// implementation.
+// GENERATED from manifest.js by scripts/generate-cjs.js — DO NOT EDIT.
+// Change manifest.js, then run `npm run generate:cjs` in packages/widget-sdk.
+"use strict";
 
 const { CONTRACT } = require("./contract.cjs");
 
+// Structural validation of a widget manifest, shared by the CLI, hosts and backend.
+
+
 const PAYLOAD_VALUE_TYPES = CONTRACT.payloadValueTypes;
 
 // sc-4505 — a payload / input field map: { <field>: { type, label? } }. This is
@@ -120,16 +121,7 @@ function validateManifestTranslations(translations, manifestId, errors) {
   }
 }
 
-// REQ-MKT-ACTION (sc-4879): a widget no longer declares server-side actions.
-//
-// `manifest.actions` was how an automation shipped before Actions existed as
-// their own marketplace deliverable — a widget was two products in one package,
-// a component that renders and a script that never renders at all. It is now
-// REFUSED rather than ignored: an author who declares it believes the
-// automation will ship, and silence would publish that misunderstanding.
-//
-// The replacement is a marketplace Action (`@colixsystems/action-sdk`), which
-// the workspace installs and configures on its own.
+// REQ-MKT-ACTION (sc-4879): refused, not ignored — the author expects it to ship.
 function validateManifestActions(_actions, errors) {
   errors.push(
     "manifest.actions is no longer supported — ship the automation as a " +

package/dist/manifest.js

@@ -1,10 +1,6 @@
-// CommonJS mirror of manifest.js. Lets backend services (CJS) call
-// `validateManifest(...)` without a dynamic-import detour. The two files
-// share their constants by mutual import via createRequire — manifest.js
-// re-exports the same functions defined here so there is exactly one
-// implementation.
+// Structural validation of a widget manifest, shared by the CLI, hosts and backend.
 
-import { CONTRACT, normaliseActionTriggerTypes } from "./contract.js";
+import { CONTRACT } from "./contract.js";
 
 const PAYLOAD_VALUE_TYPES = CONTRACT.payloadValueTypes;
 
@@ -39,20 +35,6 @@ const VALID_CATEGORIES = new Set([
 ]);
 const VALID_PLATFORMS = new Set(["web", "native"]);
 
-// REQ-WIDGET-ACTION — structural validation for manifest-declared server
-// actions. Mirrors the backend action.service caps; the runner re-validates
-// the cron expression (node-cron) and binds the tenant-local API key + table
-// at enable time, so we only check shape + size here (cross-env: no Buffer).
-const VALID_ACTION_TRIGGERS = new Set([
-  "schedule",
-  "record_created",
-  "record_updated",
-  "record_deleted",
-]);
-const ACTION_SCRIPT_MAX_BYTES = 200 * 1024;
-const ACTION_TIMEOUT_MIN_MS = 100;
-const ACTION_TIMEOUT_MAX_MS = 5 * 60 * 1000;
-
 // REQ-L10N-WIDGET — caps + patterns for manifest-declared translations.
 // The relative key pattern is deliberately tighter than the dictionary's
 // own KEY_RE: once the host namespaces it (`widget.<id>.<key>`) the result
@@ -134,54 +116,13 @@ function validateManifestTranslations(translations, manifestId, errors) {
   }
 }
 
-function validateManifestActions(actions, errors) {
-  if (!Array.isArray(actions)) {
-    errors.push("manifest.actions must be an array (omit it or use [] for none)");
-    return;
-  }
-  const seenKeys = new Set();
-  for (const a of actions) {
-    if (a === null || typeof a !== "object") {
-      errors.push("manifest.actions entries must be objects");
-      break;
-    }
-    if (!isNonEmptyString(a.key)) {
-      errors.push("manifest.actions[].key must be a non-empty string");
-    } else if (seenKeys.has(a.key)) {
-      errors.push(`manifest.actions[].key "${a.key}" is duplicated`);
-    } else {
-      seenKeys.add(a.key);
-    }
-    pushIf(errors, isNonEmptyString(a.name), "manifest.actions[].name must be a non-empty string");
-    const triggerTypes = normaliseActionTriggerTypes(a);
-    if (triggerTypes === null) {
-      errors.push(
-        `manifest.actions[].triggerTypes must be a non-empty array of unique values from ${[...VALID_ACTION_TRIGGERS].join(", ")}`,
-      );
-    } else if (triggerTypes.includes("schedule")) {
-      pushIf(
-        errors,
-        isNonEmptyString(a.scheduleCron),
-        "manifest.actions[].scheduleCron is required when triggerTypes contains 'schedule'",
-      );
-    }
-    if (!isNonEmptyString(a.scriptSource)) {
-      errors.push("manifest.actions[].scriptSource must be a non-empty string");
-    } else if (utf8ByteLength(a.scriptSource) > ACTION_SCRIPT_MAX_BYTES) {
-      errors.push("manifest.actions[].scriptSource exceeds 200 KiB");
-    }
-    if (a.timeoutMs !== undefined) {
-      const t = Number(a.timeoutMs);
-      if (!Number.isFinite(t) || t < ACTION_TIMEOUT_MIN_MS || t > ACTION_TIMEOUT_MAX_MS) {
-        errors.push("manifest.actions[].timeoutMs must be between 100 and 300000");
-      }
-    }
-    if (a.triggerTableId !== undefined || a.apiKeyId !== undefined) {
-      errors.push(
-        "manifest.actions[] must not include triggerTableId or apiKeyId — those are tenant-local and bound after install",
-      );
-    }
-  }
+// REQ-MKT-ACTION (sc-4879): refused, not ignored — the author expects it to ship.
+function validateManifestActions(_actions, errors) {
+  errors.push(
+    "manifest.actions is no longer supported — ship the automation as a " +
+      "marketplace Action (@colixsystems/action-sdk) instead of declaring it " +
+      "on a widget",
+  );
 }
 
 function canonicalCategory(c) {
@@ -361,7 +302,7 @@ function validateManifest(m) {
     }
   }
 
-  // `actions` is optional (additive in SDK 1.8.0) — only validate when present.
+  // Present at all is now an error (sc-4879) — see validateManifestActions.
   if (manifest.actions !== undefined) {
     validateManifestActions(manifest.actions, errors);
   }

package/dist/markdown-doc.js

@@ -0,0 +1,209 @@
+// sc-15080 — the bridge between the markdown subset and the editor's document.
+//
+// `<MarkdownInput>` edits a rich document but stores markdown, so `<RichText>`,
+// saved rows and every widget's `value`/`onChange` stay as they were. Reading
+// goes through `parseMarkdown`, the SAME grammar `<RichText>` renders, so the
+// editor can never show a construct differently from the reader (CLAUDE.md §3).
+// Writing emits the canonical spelling of each construct; a value the author
+// never edits is never re-written.
+//
+// Pure and DOM-free: both hosts' editors and the unit tests import it.
+
+import {
+  parseMarkdown,
+  formatMarkdownImage,
+  escapeMarkdownLabel,
+} from "./markdown.js";
+
+const textNode = (text, marks) =>
+  marks.length > 0 ? { type: "text", text, marks } : { type: "text", text };
+
+function inlineContent(spans) {
+  const nodes = [];
+  for (const span of spans || []) {
+    if (!span.text) continue;
+    const marks = [];
+    if (span.bold) marks.push({ type: "bold" });
+    if (span.italic) marks.push({ type: "italic" });
+    if (span.code) marks.push({ type: "code" });
+    if (span.href) marks.push({ type: "link", attrs: { href: span.href } });
+    nodes.push(textNode(span.text, marks));
+  }
+  return nodes;
+}
+
+const paragraph = (spans) => {
+  const content = inlineContent(spans);
+  return content.length > 0 ? { type: "paragraph", content } : { type: "paragraph" };
+};
+
+function tableNode(block) {
+  const width = Math.max(1, ...block.rows.map((row) => row.cells.length));
+  const rows = block.rows.map((row) => {
+    const cells = [];
+    for (let i = 0; i < width; i += 1) {
+      cells.push({
+        type: row.header ? "tableHeader" : "tableCell",
+        content: [paragraph(row.cells[i])],
+      });
+    }
+    return { type: "tableRow", content: cells };
+  });
+  const align = [];
+  for (let i = 0; i < width; i += 1) align.push(block.align[i] || null);
+  return { type: "table", attrs: { align }, content: rows };
+}
+
+const ordinal = (marker) => Number.parseInt(marker, 10) || 1;
+
+/**
+ * Markdown text → the editor's ProseMirror JSON document. `options` go to
+ * `parseMarkdown`; the editor passes `stripLegacyHtml: false`, because the
+ * strip would delete text like `Promise<void>` the author typed.
+ */
+export function markdownToDoc(text, options) {
+  const content = [];
+  let list = null;
+  for (const block of parseMarkdown(text, options)) {
+    const listType = block.type === "bullet" ? "bulletList" : block.type === "ordered" ? "orderedList" : null;
+    if (listType) {
+      if (!list || list.type !== listType) {
+        list = { type: listType, content: [] };
+        if (listType === "orderedList") list.attrs = { start: ordinal(block.marker) };
+        content.push(list);
+      }
+      list.content.push({ type: "listItem", content: [paragraph(block.spans)] });
+      continue;
+    }
+    list = null;
+    if (block.type === "heading") {
+      content.push({ type: "heading", attrs: { level: block.level }, content: inlineContent(block.spans) });
+    } else if (block.type === "paragraph") {
+      content.push(paragraph(block.spans));
+    } else if (block.type === "table") {
+      content.push(tableNode(block));
+    } else if (block.type === "image") {
+      content.push({ type: "image", attrs: { src: block.src, alt: block.alt, title: block.size } });
+    } else if (block.type === "code") {
+      content.push({
+        type: "codeBlock",
+        attrs: { language: block.lang || null },
+        ...(block.text ? { content: [{ type: "text", text: block.text }] } : null),
+      });
+    }
+  }
+  return { type: "doc", content: content.length > 0 ? content : [{ type: "paragraph" }] };
+}
+
+const markOf = (node, type) => (node.marks || []).find((mark) => mark.type === type);
+
+// The grammar's emphasis cannot open or close next to whitespace, so edge
+// spaces move outside the markers instead of breaking the construct.
+function wrap(text, marker) {
+  const lead = /^\s*/.exec(text)[0];
+  const trail = /\s*$/.exec(text.slice(lead.length))[0];
+  const core = text.slice(lead.length, text.length - trail.length);
+  return core ? `${lead}${marker}${core}${marker}${trail}` : text;
+}
+
+function styledText(node, inTable) {
+  let text = node.text || "";
+  if (inTable) text = text.replace(/\|/g, "\\|");
+  if (markOf(node, "code")) return wrap(text.replace(/`/g, "'"), "`");
+  if (markOf(node, "bold")) return wrap(text, "**");
+  if (markOf(node, "italic")) return wrap(text, "*");
+  return text;
+}
+
+// The grammar ends a target at whitespace or `)`, and a table cell at `|`.
+const linkTarget = (href) =>
+  String(href || "").replace(/[\s|()<>]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
+
+function inlineMarkdown(nodes, inTable) {
+  let out = "";
+  let link = null;
+  let label = "";
+  const closeLink = () => {
+    if (link) out += `[${escapeMarkdownLabel(label)}](${linkTarget(link)})`;
+    link = null;
+    label = "";
+  };
+  for (const node of nodes || []) {
+    if (node.type !== "text") continue;
+    const href = markOf(node, "link")?.attrs?.href || null;
+    if (href !== link) closeLink();
+    if (href) {
+      link = href;
+      label += styledText(node, inTable);
+    } else {
+      out += styledText(node, inTable);
+    }
+  }
+  closeLink();
+  return out.replace(/\n/g, " ");
+}
+
+const cellMarkdown = (cell) =>
+  (cell.content || []).map((child) => inlineMarkdown(child.content, true)).join(" ").trim();
+
+function alignDivider(align) {
+  if (align === "center") return ":---:";
+  if (align === "right") return "---:";
+  if (align === "left") return ":---";
+  return "---";
+}
+
+function tableMarkdown(node) {
+  const rows = (node.content || []).map((row) => (row.content || []).map(cellMarkdown));
+  if (rows.length === 0) return "";
+  const width = rows[0].length;
+  const align = node.attrs?.align || [];
+  const line = (cells) => `| ${cells.join(" | ")} |`;
+  const divider = [];
+  for (let i = 0; i < width; i += 1) divider.push(alignDivider(align[i]));
+  return [line(rows[0]), line(divider), ...rows.slice(1).map(line)].join("\n");
+}
+
+const listItemText = (item) =>
+  (item.content || []).map((child) => inlineMarkdown(child.content, false)).join(" ").trim();
+
+// An empty item or heading would read back as a stray `3.` or `##` paragraph.
+const filledItems = (list) => (list.content || []).map(listItemText).filter((text) => text !== "");
+
+function blockMarkdown(node) {
+  switch (node.type) {
+    case "heading": {
+      const text = inlineMarkdown(node.content, false).trim();
+      return text ? `${"#".repeat(node.attrs?.level || 1)} ${text}` : "";
+    }
+    case "paragraph":
+      return inlineMarkdown(node.content, false);
+    case "bulletList":
+      return filledItems(node).map((text) => `- ${text}`).join("\n");
+    case "orderedList": {
+      const start = node.attrs?.start || 1;
+      return filledItems(node).map((text, i) => `${start + i}. ${text}`).join("\n");
+    }
+    case "table":
+      return tableMarkdown(node);
+    case "image":
+      // An unsafe source was emptied on read; written back it would be prose.
+      return node.attrs?.src
+        ? formatMarkdownImage({ src: node.attrs.src, alt: node.attrs.alt, size: node.attrs.title })
+        : "";
+    case "codeBlock": {
+      const body = (node.content || []).map((child) => child.text || "").join("");
+      return `\`\`\`${node.attrs?.language || ""}\n${body}\n\`\`\``;
+    }
+    default:
+      return "";
+  }
+}
+
+/** The editor's ProseMirror JSON document → markdown text. */
+export function docToMarkdown(doc) {
+  return (doc?.content || [])
+    .map(blockMarkdown)
+    .filter((block) => block.trim() !== "")
+    .join("\n\n");
+}

package/dist/markdown-editor-bridge.js

@@ -0,0 +1,162 @@
+// sc-15080 — the bridge between `<MarkdownInput>`'s native field and the editor
+// page it hosts in a WebView (./markdown-editor-webview.js).
+//
+// React Native has no editable rich-text view, so the shared editor runs in a
+// WebView from a page bundled into the SDK: no network, no remote code. The
+// field grows with its content between `minHeight` and `maxHeight`, then the
+// page scrolls. The primitives are passed in, so the bridge is testable
+// without a device; ./markdown-editor-field.native.js binds the real ones.
+
+import React from "react";
+import { MARKDOWN_EDITOR_HTML } from "./markdown-editor-html.js";
+
+const SOURCE = { html: MARKDOWN_EDITOR_HTML };
+
+/** The script that hands `message` to the page; JSON twice makes it a literal. */
+export function editorMessageScript(message) {
+  return `window.mdEditor&&window.mdEditor.receive(${JSON.stringify(JSON.stringify(message))});true;`;
+}
+
+function readMessage(event) {
+  try {
+    const message = JSON.parse(event.nativeEvent.data);
+    return message && typeof message.type === "string" ? message : null;
+  } catch {
+    return null;
+  }
+}
+
+const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+
+/** Builds the field from React Native's `View` and the WebView component. */
+export function makeMarkdownEditorField({ View, WebView }) {
+  return React.forwardRef(function MarkdownEditorField(
+    {
+      value,
+      onChangeText,
+      onStateChange,
+      placeholder,
+      accessibilityLabel,
+      tokens,
+      minHeight,
+      maxHeight,
+      testID,
+    },
+    ref,
+  ) {
+    const web = React.useRef(null);
+    const loaded = React.useRef(false);
+    const ready = React.useRef(false);
+    const shown = React.useRef(value);
+    const selection = React.useRef("");
+    const [height, setHeight] = React.useState(minHeight);
+    const [focused, setFocused] = React.useState(false);
+
+    const send = React.useCallback((message) => {
+      if (ready.current && web.current)
+        web.current.injectJavaScript(editorMessageScript(message));
+    }, []);
+
+    React.useEffect(() => {
+      if (value === shown.current) return;
+      shown.current = value;
+      send({ type: "set", markdown: value });
+    }, [value, send]);
+
+    // A theme switch repaints the page, as it does the web field.
+    React.useEffect(() => {
+      send({ type: "style", tokens, minHeight });
+    }, [tokens, minHeight, send]);
+
+    // The OS may kill the page's process; reload it and re-send the value.
+    const restart = React.useCallback(() => {
+      ready.current = false;
+      loaded.current = false;
+      if (web.current) web.current.reload();
+    }, []);
+
+    React.useImperativeHandle(
+      ref,
+      () => ({
+        command: (name, args) => {
+          send({ type: "command", name, args });
+          return ready.current;
+        },
+        selectedText: () => selection.current,
+      }),
+      [send],
+    );
+
+    const onMessage = (event) => {
+      const message = readMessage(event);
+      if (!message) return;
+      if (message.type === "ready") {
+        ready.current = true;
+        send({
+          type: "init",
+          markdown: shown.current,
+          placeholder,
+          label: accessibilityLabel,
+          tokens,
+          minHeight,
+        });
+      } else if (
+        message.type === "change" &&
+        typeof message.markdown === "string"
+      ) {
+        shown.current = message.markdown;
+        if (typeof onChangeText === "function") onChangeText(message.markdown);
+      } else if (message.type === "height" && Number.isFinite(message.height)) {
+        setHeight(clamp(message.height, minHeight, maxHeight));
+      } else if (message.type === "focus") {
+        setFocused(message.focused === true);
+      } else if (
+        message.type === "selection" &&
+        typeof message.text === "string"
+      ) {
+        selection.current = message.text;
+      } else if (message.type === "state" && typeof onStateChange === "function") {
+        onStateChange({ inTable: message.inTable === true });
+      }
+    };
+
+    return React.createElement(
+      View,
+      {
+        testID,
+        style: {
+          height,
+          borderWidth: 1,
+          borderColor: focused ? tokens.accent : tokens.border,
+          borderRadius: tokens.radius,
+          backgroundColor: tokens.surface,
+          overflow: "hidden",
+        },
+      },
+      React.createElement(WebView, {
+        ref: web,
+        source: SOURCE,
+        originWhitelist: ["*"],
+        // The page is the editor; nothing in it may navigate the field away.
+        onShouldStartLoadWithRequest: () => !loaded.current,
+        onLoadEnd: () => {
+          loaded.current = true;
+        },
+        onMessage,
+        onContentProcessDidTerminate: restart,
+        onRenderProcessGone: restart,
+        javaScriptEnabled: true,
+        setSupportMultipleWindows: false,
+        keyboardDisplayRequiresUserAction: false,
+        hideKeyboardAccessoryView: true,
+        automaticallyAdjustContentInsets: false,
+        textZoom: 100,
+        scrollEnabled: height >= maxHeight,
+        // Android hands a parent ScrollView's gesture to the page only with this.
+        nestedScrollEnabled: true,
+        style: { backgroundColor: "transparent" },
+        testID: testID ? `${testID}-webview` : undefined,
+      }),
+    );
+  });
+}