@crewlethq/ui 0.29.0 → 0.31.0

package/dist/chunk-IDBHX5SR.js

@@ -0,0 +1,12 @@
+import { readMarkdown, writeMarkdown } from './chunk-YFW4MTK4.js';
+
+// src/RichEditor/roundtrip.ts
+function roundTripMarkdown(markdown) {
+  const { doc, source } = readMarkdown(markdown);
+  return writeMarkdown(doc, source);
+}
+function canonicalMarkdown(markdown) {
+  return writeMarkdown(readMarkdown(markdown).doc);
+}
+
+export { canonicalMarkdown, roundTripMarkdown };

package/dist/{chunk-WI6K5M5X.js → chunk-M3LUNN7F.js}

@@ -1,5 +1,5 @@
 import { cx } from './chunk-ODEQTPFM.js';
-import './Document-PQGXJHB7.css';
+import './Document-G3YTZIUL.css';
 import { jsx } from 'react/jsx-runtime';
 
 function Document({ as: Tag = "div", size = "md", measure = "normal", className, children, ...rest }) {

package/dist/{chunk-QMBP23BL.js → chunk-P4BOXB6E.js}

@@ -7,7 +7,7 @@ import { Button } from './chunk-OG6CL3EB.js';
 import { IconButton } from './chunk-4FQT6ZAY.js';
 import { VisuallyHidden } from './chunk-BZFWDIV6.js';
 import { cx } from './chunk-ODEQTPFM.js';
-import './ArtifactBar-IBWB5POL.css';
+import './ArtifactBar-MLMJHWY6.css';
 import { useId, useState, useRef, useEffect } from 'react';
 import { ChevronLeftGlyph, EllipsisGlyph, ChevronDownGlyph } from '@crewlethq/icons/glyphs';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
@@ -31,6 +31,7 @@ function ArtifactBar({
   version,
   modes,
   presence,
+  status,
   kindTools = [],
   tools = [],
   menu = [],
@@ -109,6 +110,7 @@ function ArtifactBar({
           }
         ) }) : null,
         /* @__PURE__ */ jsxs("div", { className: "crewlet-artifact-bar__end", children: [
+          status ? /* @__PURE__ */ jsx("span", { className: "crewlet-artifact-bar__status", children: status }) : null,
           presence ? /* @__PURE__ */ jsx("span", { className: "crewlet-artifact-bar__presence", children: presence }) : null,
           kindTools.some((t) => !t.labelled) ? /* @__PURE__ */ jsx("span", { className: "crewlet-artifact-bar__tools crewlet-artifact-bar__wide", children: kindTools.filter((t) => !t.labelled).map((tool) => /* @__PURE__ */ jsx(ToolButton, { tool, apple }, tool.key)) }) : null,
           tools.some((t) => !t.labelled) ? /* @__PURE__ */ jsxs("span", { className: "crewlet-artifact-bar__tools crewlet-artifact-bar__wide", children: [
@@ -165,6 +167,20 @@ function ToolButton({ tool, apple }) {
 }
 function LabelledTool({ tool, apple }) {
   const shortcut = tool.keys ? ariaKeys(tool.keys, apple) : void 0;
+  if (tool.emphasis === "primary") {
+    return /* @__PURE__ */ jsx(Tooltip, { content: /* @__PURE__ */ jsx(Tip, { tool, apple }), placement: "bottom", disabled: !tool.keys, children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        size: "small",
+        variant: "primary",
+        leadingIcon: tool.icon,
+        disabledReason: tool.disabledReason,
+        "aria-keyshortcuts": shortcut,
+        onClick: tool.onSelect,
+        children: tool.label
+      }
+    ) });
+  }
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx("span", { className: "crewlet-artifact-bar__roomy", children: /* @__PURE__ */ jsx(Tooltip, { content: /* @__PURE__ */ jsx(Tip, { tool, apple }), placement: "bottom", disabled: !tool.keys, children: /* @__PURE__ */ jsx(
       Button,

package/dist/chunk-SKOYC2CF.js

@@ -0,0 +1,288 @@
+// src/Markdown/grammar.ts
+var MARKDOWN_CALLOUT_TONES = ["note", "tip", "important", "warning", "caution"];
+var MARKDOWN_CALLOUT_NAMES = {
+  note: "Note",
+  tip: "Tip",
+  important: "Important",
+  warning: "Warning",
+  caution: "Caution"
+};
+var SAFE_SCHEME = /^(https?:|mailto:)/i;
+var URL_NOISE = /[\u0000- ]/g;
+function safeHref(raw) {
+  const href = raw.trim();
+  if (href === "") return null;
+  const clean = href.replace(URL_NOISE, "");
+  if (clean.startsWith("#/")) return clean;
+  if (SAFE_SCHEME.test(clean)) return clean;
+  return null;
+}
+var HEADING = /^(#{1,6})\s+(.*)$/;
+var FENCE = /^(```|~~~)\s*([A-Za-z0-9_+-]*)\s*$/;
+var RULE = /^(?:\s*(?:-{3,}|\*{3,}|_{3,})\s*)$/;
+var BULLET = /^(\s*)([-*+])\s+(.*)$/;
+var ORDERED = /^(\s*)(\d{1,9})([.)])\s+(.*)$/;
+var QUOTE = /^\s{0,3}>\s?(.*)$/;
+var TABLE_RULE = /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)*\|?\s*$/;
+var CALLOUT = /^\[!(note|tip|important|warning|caution)\]\s*$/i;
+var TASK = /^\[([ xX])\]\s+(.*)$/;
+var FENCE_CLOSE = {
+  "```": /^`{3,}[ \t]*$/,
+  "~~~": /^~{3,}[ \t]*$/
+};
+function markdownClosesFence(line, marker) {
+  return FENCE_CLOSE[marker].test(line);
+}
+function markdownFenceOf(line) {
+  const m = FENCE.exec(line);
+  return m ? { marker: m[1] ?? "```", lang: m[2] ?? "" } : null;
+}
+function markdownHeadingOf(line) {
+  const m = HEADING.exec(line);
+  if (!m) return null;
+  return { level: (m[1] ?? "#").length, title: (m[2] ?? "").replace(/\s+#+\s*$/, "").trim() };
+}
+function markdownLines(source) {
+  return (source ?? "").replace(/\r\n?/g, "\n").split("\n");
+}
+function parseMarkdown(source) {
+  return blocksOf(markdownLines(source)).map((span) => span.block);
+}
+function parseMarkdownSpans(source) {
+  const lines = markdownLines(source);
+  return { lines, spans: blocksOf(lines) };
+}
+function blocksOf(lines) {
+  const out = [];
+  let i = 0;
+  const paragraph = [];
+  let paragraphStart = 0;
+  const flush = () => {
+    if (paragraph.length) {
+      out.push({
+        block: { kind: "paragraph", text: paragraph.join("\n") },
+        start: paragraphStart,
+        end: paragraphStart + paragraph.length
+      });
+      paragraph.length = 0;
+    }
+  };
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const start = i;
+    if (line.trim() === "") {
+      flush();
+      i++;
+      continue;
+    }
+    const fence = markdownFenceOf(line);
+    if (fence) {
+      flush();
+      const body = [];
+      i++;
+      while (i < lines.length && !markdownClosesFence(lines[i] ?? "", fence.marker)) {
+        body.push(lines[i] ?? "");
+        i++;
+      }
+      if (i >= lines.length && body.length > 0 && body[body.length - 1] === "") {
+        body.pop();
+      }
+      i = Math.min(i + 1, lines.length);
+      out.push({
+        block: { kind: "code", lang: fence.lang, text: body.join("\n"), fence: fence.marker },
+        start,
+        end: i
+      });
+      continue;
+    }
+    if (RULE.test(line)) {
+      flush();
+      i++;
+      out.push({ block: { kind: "rule" }, start, end: i });
+      continue;
+    }
+    const heading = markdownHeadingOf(line);
+    if (heading) {
+      flush();
+      i++;
+      out.push({ block: { kind: "heading", level: heading.level, text: heading.title }, start, end: i });
+      continue;
+    }
+    if (QUOTE.test(line)) {
+      flush();
+      const inner = [];
+      while (i < lines.length && QUOTE.test(lines[i] ?? "")) {
+        inner.push(QUOTE.exec(lines[i] ?? "")?.[1] ?? "");
+        i++;
+      }
+      const tone = CALLOUT.exec(inner[0] ?? "");
+      out.push({
+        block: tone ? {
+          kind: "callout",
+          tone: (tone[1] ?? "note").toLowerCase(),
+          blocks: parseMarkdown(inner.slice(1).join("\n"))
+        } : { kind: "quote", blocks: parseMarkdown(inner.join("\n")) },
+        start,
+        end: i
+      });
+      continue;
+    }
+    if (line.includes("|") && TABLE_RULE.test(lines[i + 1] ?? "")) {
+      flush();
+      const head = splitRow(line);
+      const align = splitRow(lines[i + 1] ?? "").map(alignOf);
+      i += 2;
+      const rows = [];
+      while (i < lines.length && (lines[i] ?? "").includes("|") && (lines[i] ?? "").trim() !== "") {
+        rows.push(splitRow(lines[i] ?? ""));
+        i++;
+      }
+      out.push({ block: { kind: "table", head, align, rows }, start, end: i });
+      continue;
+    }
+    if (BULLET.test(line) || ORDERED.test(line)) {
+      flush();
+      const [list, next] = parseList(lines, i);
+      out.push({ block: list, start, end: next });
+      i = next;
+      continue;
+    }
+    if (paragraph.length === 0) paragraphStart = i;
+    paragraph.push(line);
+    i++;
+  }
+  flush();
+  return out;
+}
+function alignOf(cell) {
+  const t = cell.trim();
+  if (t.startsWith(":") && t.endsWith(":")) return "center";
+  if (t.endsWith(":")) return "right";
+  return "left";
+}
+function splitRow(line) {
+  let t = line.trim();
+  if (t.startsWith("|")) t = t.slice(1);
+  if (t.endsWith("|") && !t.endsWith("\\|")) t = t.slice(0, -1);
+  const cells = [];
+  let cell = "";
+  for (let i = 0; i < t.length; i++) {
+    const c = t[i];
+    if (c === "\\" && t[i + 1] === "|") {
+      cell += "|";
+      i++;
+    } else if (c === "|") {
+      cells.push(cell.trim());
+      cell = "";
+    } else {
+      cell += c;
+    }
+  }
+  cells.push(cell.trim());
+  return cells;
+}
+function parseList(lines, start) {
+  const head = lines[start] ?? "";
+  const firstBullet = BULLET.exec(head);
+  const firstOrdered = ORDERED.exec(head);
+  const baseIndent = ((firstBullet ?? firstOrdered)?.[1] ?? "").length;
+  const ordered = firstOrdered !== null && firstBullet === null;
+  const startNumber = ordered ? Number(firstOrdered?.[2] ?? 1) : 1;
+  const marker = ordered ? firstOrdered?.[3] ?? "." : firstBullet?.[2] ?? "-";
+  const items = [];
+  let i = start;
+  let own = [];
+  let checked = null;
+  let open = false;
+  let loose = false;
+  const close = () => {
+    if (!open) return;
+    items.push({ checked, blocks: parseMarkdown(own.join("\n")) });
+    own = [];
+    checked = null;
+    open = false;
+  };
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const bullet = BULLET.exec(line);
+    const numbered = ORDERED.exec(line);
+    const found = bullet ?? numbered;
+    const indent = (found?.[1] ?? "").length;
+    if (found && indent === baseIndent) {
+      if (ordered !== (numbered !== null && bullet === null)) break;
+      close();
+      open = true;
+      const body = (bullet ? bullet[3] : numbered?.[4]) ?? "";
+      const task = TASK.exec(body);
+      if (task) {
+        checked = (task[1] ?? " ").toLowerCase() === "x";
+        own.push(task[2] ?? "");
+      } else {
+        own.push(body);
+      }
+      i++;
+      continue;
+    }
+    if (found && indent > baseIndent) {
+      own.push(line.slice(baseIndent));
+      i++;
+      continue;
+    }
+    if (line.trim() === "") {
+      const following = lines[i + 1] ?? "";
+      const continues = BULLET.test(following) || ORDERED.test(following) || /^\s{2,}\S/.test(following);
+      if (!continues) break;
+      const sibling = BULLET.exec(following) ?? ORDERED.exec(following);
+      if (sibling && (sibling[1] ?? "").length === baseIndent) loose = true;
+      own.push("");
+      i++;
+      continue;
+    }
+    if (found === null && /^\s{2,}\S/.test(line) && open) {
+      own.push(line.slice(baseIndent));
+      i++;
+      continue;
+    }
+    break;
+  }
+  close();
+  return [{ kind: "list", ordered, start: startNumber, marker, loose, items }, i];
+}
+var NOT_WP = String.raw`[^\s\p{P}\p{S}]`;
+var WP = String.raw`[\s\p{P}\p{S}]`;
+var PUNCT = String.raw`[\p{P}\p{S}]`;
+var leftFlanking = (d) => String.raw`(?:(?<!${NOT_WP})${d}(?!\s|$)|(?<=${NOT_WP})${d}(?!${WP}|$))`;
+var rightFlanking = (d) => String.raw`(?:(?<=${NOT_WP})${d}|(?<=${PUNCT})${d}(?!${NOT_WP}))`;
+var underOpens = (d) => String.raw`(?<!${NOT_WP})${d}(?!\s|$)`;
+var underCloses = (d) => String.raw`(?<!\s)${d}(?!${NOT_WP})`;
+var label = (name) => String.raw`(?<${name}>(?:\\[\s\S]|[^\]\\])*)`;
+var destination = (name, title) => String.raw`(?<${name}>(?:[^()\s]|\([^()\s]*\))*)(?:\s+"(?<${title}>[^"]*)")?\)`;
+var ASCII_PUNCTUATION = String.raw`[!-\/:-@\[-\x60{-~]`;
+var INLINE_SOURCE = [
+  String.raw`\\(?<esc>${ASCII_PUNCTUATION})`,
+  String.raw`(?<tick>\x60+)(?<code>[\s\S]*?)\k<tick>`,
+  String.raw`!\[` + label("alt") + String.raw`\]\(` + destination("src", "srcTitle"),
+  String.raw`\[` + label("label") + String.raw`\]\(` + destination("href", "hrefTitle"),
+  String.raw`<(?<auto>(?:https?:|mailto:)[^>\s]+)>`,
+  // A strong run closes on a `**` no third asterisk follows, so `***both***`
+  // is strong around emphasis rather than strong around `*both` and a stray.
+  leftFlanking(String.raw`\*\*`) + String.raw`(?<strong>[\s\S]+?)` + rightFlanking(String.raw`\*\*(?!\*)`),
+  underOpens("__") + String.raw`(?<strongUnder>[\s\S]+?)` + underCloses("__"),
+  leftFlanking(String.raw`\*`) + String.raw`(?<em>[\s\S]+?)` + rightFlanking(String.raw`\*`),
+  underOpens("_") + String.raw`(?<emUnder>[\s\S]+?)` + underCloses("_"),
+  String.raw`~~(?<del>[\s\S]+?)~~`
+].join("|");
+function* markdownInline(text) {
+  const pattern = new RegExp(INLINE_SOURCE, "gu");
+  for (let m = pattern.exec(text); m !== null; m = pattern.exec(text)) {
+    yield { index: m.index, end: m.index + m[0].length, groups: m.groups ?? {} };
+  }
+}
+function markdownCodeText(code) {
+  return code.replace(/^ | $/g, "");
+}
+function markdownBreaks(text, hard = false) {
+  return text.split(hard ? /(?:  +|\\)?\n/ : /(?:  +|\\)\n/);
+}
+
+export { MARKDOWN_CALLOUT_NAMES, MARKDOWN_CALLOUT_TONES, markdownBreaks, markdownClosesFence, markdownCodeText, markdownFenceOf, markdownHeadingOf, markdownInline, markdownLines, parseMarkdown, parseMarkdownSpans, safeHref };

package/dist/chunk-VOX3YRFO.js

@@ -0,0 +1,76 @@
+import { richEditorLabels } from './chunk-A4E5YLXO.js';
+import { Skeleton } from './chunk-W5J7R5EB.js';
+import { Callout } from './chunk-SVSCLHHI.js';
+import { Button } from './chunk-OG6CL3EB.js';
+import './RichEditor-NPD2KAPS.css';
+import { forwardRef, useState, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var engine = null;
+var loading = null;
+function loadEngine() {
+  loading ??= import('./Editor-YZ7KG2RD.js').then(
+    (module) => {
+      engine = module.Editor;
+      return engine;
+    },
+    (error) => {
+      loading = null;
+      throw error;
+    }
+  );
+  return loading;
+}
+function preloadRichEditor() {
+  return loadEngine().then(
+    () => void 0,
+    () => void 0
+  );
+}
+var RichEditor = forwardRef(function RichEditor2(props, ref) {
+  const [Engine, setEngine] = useState(() => engine);
+  const [failed, setFailed] = useState(false);
+  const [attempt, setAttempt] = useState(0);
+  useEffect(() => {
+    if (Engine) return;
+    let live = true;
+    loadEngine().then(
+      (loaded) => {
+        if (live) setEngine(() => loaded);
+      },
+      () => {
+        if (live) setFailed(true);
+      }
+    );
+    return () => {
+      live = false;
+    };
+  }, [Engine, attempt]);
+  if (Engine) return /* @__PURE__ */ jsx(Engine, { ref, ...props });
+  const text = richEditorLabels(props.labels);
+  if (failed) {
+    return /* @__PURE__ */ jsx(
+      Callout,
+      {
+        variant: "danger",
+        title: text.failed,
+        action: /* @__PURE__ */ jsx(
+          Button,
+          {
+            size: "small",
+            variant: "secondary",
+            onClick: () => {
+              setFailed(false);
+              setAttempt((n) => n + 1);
+            },
+            children: text.retry
+          }
+        ),
+        children: text.failedDetail
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx("div", { className: "crewlet-rich-editor crewlet-rich-editor--loading", "aria-busy": "true", children: props.fallback ?? /* @__PURE__ */ jsx(Skeleton, { variant: "text", rows: 6, label: text.loading }) });
+});
+
+export { RichEditor, preloadRichEditor };