testomatio-editor-blocks 0.4.64 → 0.4.66

package/src/editor/customMarkdownConverter.test.ts

@@ -2685,90 +2685,6 @@ describe("markdownToBlocks", () => {
       },
     ]);
   });
-
-  it("preserves opening-fence content when it is not a clean language identifier", () => {
-    const markdown = [
-      "```curl `http://localhost:3000/projects/classic-project/test/e1c1b38c/edit` \\",
-      "{{baseURL}}/endpoint?query_param_one=value_one&query_param_two=value_two",
-      "```",
-    ].join("\n");
-    const blocks = markdownToBlocks(markdown);
-    expect(blocks).toEqual([
-      {
-        type: "codeBlock",
-        props: { language: "" },
-        content: [
-          {
-            type: "text",
-            text: [
-              "curl `http://localhost:3000/projects/classic-project/test/e1c1b38c/edit` \\",
-              "{{baseURL}}/endpoint?query_param_one=value_one&query_param_two=value_two",
-            ].join("\n"),
-            styles: {},
-          },
-        ],
-        children: [],
-      },
-    ]);
-  });
-
-  it("round-trips an opening-fence-with-content code block to stable markdown", () => {
-    const markdown = [
-      "```curl `http://localhost:3000/projects/classic-project/test/e1c1b38c/edit` \\",
-      "{{baseURL}}/endpoint?query_param_one=value_one&query_param_two=value_two",
-      "```",
-    ].join("\n");
-    const blocks = markdownToBlocks(markdown);
-    const serialized = blocksToMarkdown(blocks as CustomEditorBlock[]);
-    expect(serialized).toBe(
-      [
-        "```",
-        "curl `http://localhost:3000/projects/classic-project/test/e1c1b38c/edit` \\",
-        "{{baseURL}}/endpoint?query_param_one=value_one&query_param_two=value_two",
-        "```",
-      ].join("\n"),
-    );
-    expect(markdownToBlocks(serialized)).toEqual(blocks);
-  });
-
-  it("preserves hyphenated language identifiers like shell-session", () => {
-    const markdown = ["```shell-session", "$ ls", "```"].join("\n");
-    const blocks = markdownToBlocks(markdown);
-    expect(blocks).toEqual([
-      {
-        type: "codeBlock",
-        props: { language: "shell-session" },
-        content: [{ type: "text", text: "$ ls", styles: {} }],
-        children: [],
-      },
-    ]);
-  });
-
-  it("preserves digit-prefixed language identifiers like 1c-enterprise", () => {
-    const markdown = ["```1c-enterprise", "code", "```"].join("\n");
-    const blocks = markdownToBlocks(markdown);
-    expect(blocks).toEqual([
-      {
-        type: "codeBlock",
-        props: { language: "1c-enterprise" },
-        content: [{ type: "text", text: "code", styles: {} }],
-        children: [],
-      },
-    ]);
-  });
-
-  it("sanitizes a malformed in-memory language prop on serialize", () => {
-    const blocks: CustomEditorBlock[] = [
-      {
-        id: "1",
-        type: "codeBlock",
-        props: { ...baseProps, language: "curl http://x" } as any,
-        content: [{ type: "text", text: "body", styles: {} }] as any,
-        children: [],
-      },
-    ];
-    expect(blocksToMarkdown(blocks)).toBe(["```", "body", "```"].join("\n"));
-  });
 });
 
 describe("file block serialization", () => {
@@ -3137,3 +3053,138 @@ describe("blank line <-> empty paragraph mapping", () => {
     expect(blocksToMarkdown(blocks as CustomEditorBlock[])).toBe(markdown);
   });
 });
+
+describe("test/suite metadata comments", () => {
+  it("parses a one-liner test comment into a testMeta block", () => {
+    const blocks = markdownToBlocks("<!-- test id: @T12345678 -->");
+    expect(blocks).toEqual([
+      {
+        type: "testMeta",
+        props: {
+          metaKind: "test",
+          metaFields: JSON.stringify([{ key: "id", value: "@T12345678" }]),
+          metaInline: true,
+        },
+        children: [],
+      },
+    ]);
+  });
+
+  it("round-trips a one-liner test comment", () => {
+    const markdown = "<!-- test id: @T12345678 -->";
+    const blocks = markdownToBlocks(markdown);
+    expect(blocksToMarkdown(blocks as CustomEditorBlock[])).toBe(markdown);
+  });
+
+  it("parses a multi-line suite block with ordered fields", () => {
+    const markdown = [
+      "<!-- suite",
+      "id: @S12345678",
+      "emoji: 🔐",
+      "tags: smoke, regression",
+      "assignee: qa@example.com",
+      "-->",
+    ].join("\n");
+    const blocks = markdownToBlocks(markdown);
+    expect(blocks).toEqual([
+      {
+        type: "testMeta",
+        props: {
+          metaKind: "suite",
+          metaFields: JSON.stringify([
+            { key: "id", value: "@S12345678" },
+            { key: "emoji", value: "🔐" },
+            { key: "tags", value: "smoke, regression" },
+            { key: "assignee", value: "qa@example.com" },
+          ]),
+          metaInline: false,
+        },
+        children: [],
+      },
+    ]);
+  });
+
+  it("round-trips a multi-line suite block", () => {
+    const markdown = [
+      "<!-- suite",
+      "id: @S12345678",
+      "emoji: 🔐",
+      "tags: smoke, regression",
+      "assignee: qa@example.com",
+      "-->",
+    ].join("\n");
+    const blocks = markdownToBlocks(markdown);
+    expect(blocksToMarkdown(blocks as CustomEditorBlock[])).toBe(markdown);
+  });
+
+  it("ignores lines without a colon inside a metadata block", () => {
+    const markdown = [
+      "<!-- test",
+      "id: @T12345678",
+      "this line is ignored",
+      "priority: high",
+      "-->",
+    ].join("\n");
+    const blocks = markdownToBlocks(markdown);
+    expect((blocks[0].props as any).metaFields).toBe(
+      JSON.stringify([
+        { key: "id", value: "@T12345678" },
+        { key: "priority", value: "high" },
+      ]),
+    );
+  });
+
+  it("serializes a one-liner that gained extra fields as a block", () => {
+    const blocks: CustomEditorBlock[] = [
+      {
+        id: "m1",
+        type: "testMeta",
+        props: {
+          metaKind: "test",
+          metaFields: JSON.stringify([
+            { key: "id", value: "@T12345678" },
+            { key: "priority", value: "high" },
+          ]),
+          metaInline: true,
+        } as any,
+        content: undefined as any,
+        children: [],
+      },
+    ];
+    expect(blocksToMarkdown(blocks)).toBe(
+      ["<!-- test", "id: @T12345678", "priority: high", "-->"].join("\n"),
+    );
+  });
+
+  it("skips fields with empty values when serializing", () => {
+    const blocks: CustomEditorBlock[] = [
+      {
+        id: "m2",
+        type: "testMeta",
+        props: {
+          metaKind: "test",
+          metaFields: JSON.stringify([
+            { key: "id", value: "@T12345678" },
+            { key: "priority", value: "high" },
+            { key: "tags", value: "" },
+            { key: "", value: "orphan" },
+          ]),
+          metaInline: false,
+        } as any,
+        content: undefined as any,
+        children: [],
+      },
+    ];
+    expect(blocksToMarkdown(blocks)).toBe(
+      ["<!-- test", "id: @T12345678", "priority: high", "-->"].join("\n"),
+    );
+  });
+
+  it("leaves a generic HTML comment as paragraph text", () => {
+    const blocks = markdownToBlocks("<!-- ai/agent generated description -->");
+    expect(blocks[0].type).toBe("paragraph");
+    expect(blocksToMarkdown(blocks as CustomEditorBlock[])).toBe(
+      "<!-- ai/agent generated description -->",
+    );
+  });
+});

package/src/editor/customMarkdownConverter.ts

@@ -334,8 +334,7 @@ function serializeBlock(
       return lines;
     }
     case "codeBlock": {
-      const rawLanguage = (block.props as any).language || "";
-      const language = /[\s`]/.test(rawLanguage) ? "" : rawLanguage;
+      const language = (block.props as any).language || "";
       const fence = "```" + language;
       const body = inlineContentToPlainText(block.content);
       lines.push(fence);
@@ -390,6 +389,36 @@ function serializeBlock(
       }
       return lines;
     }
+    case "testMeta": {
+      const kind = (block.props as any).metaKind === "suite" ? "suite" : "test";
+      const inline = Boolean((block.props as any).metaInline);
+      let fields: { key: string; value: string }[] = [];
+      try {
+        const parsed = JSON.parse(((block.props as any).metaFields ?? "[]") as string);
+        if (Array.isArray(parsed)) {
+          fields = parsed
+            .filter((f) => f && typeof f === "object" && typeof f.key === "string")
+            .map((f) => ({ key: f.key.trim(), value: typeof f.value === "string" ? f.value.trim() : "" }))
+            // Skip incomplete fields: both a key and a value are required.
+            .filter((f) => f.key.length > 0 && f.value.length > 0);
+        }
+      } catch {
+        fields = [];
+      }
+
+      // Preserve the one-liner form only when it still fits on a single line
+      // (a one-liner holds at most one `key: value` pair).
+      if (inline && fields.length <= 1) {
+        const field = fields[0];
+        lines.push(field ? `<!-- ${kind} ${field.key}: ${field.value} -->` : `<!-- ${kind} -->`);
+        return lines;
+      }
+
+      lines.push(`<!-- ${kind}`);
+      fields.forEach((field) => lines.push(`${field.key}: ${field.value}`));
+      lines.push("-->");
+      return lines;
+    }
     case "testStep":
     case "snippet": {
       const isSnippet = block.type === "snippet";
@@ -1291,16 +1320,8 @@ function parseCodeBlock(lines: string[], index: number): { block: CustomPartialB
     };
   }
 
-  const info = afterOpening.trim();
-  let language = "";
+  const language = afterOpening.trim();
   const body: string[] = [];
-  if (info.length > 0) {
-    if (/[\s`]/.test(info)) {
-      body.push(afterOpening);
-    } else {
-      language = info;
-    }
-  }
   let next = index + 1;
   while (next < lines.length && !lines[next].startsWith("```") ) {
     body.push(lines[next]);
@@ -1364,6 +1385,92 @@ function parseParagraph(lines: string[], index: number): { block: CustomPartialB
   };
 }
 
+const META_COMMENT_OPEN_REGEX = /^<!--\s*(test|suite)(?=\s|-->|$)/i;
+
+function metaFieldsFromBody(bodyLines: string[]): { key: string; value: string }[] {
+  const fields: { key: string; value: string }[] = [];
+  for (const raw of bodyLines) {
+    const line = raw.trim();
+    if (!line) continue;
+    const colon = line.indexOf(":");
+    // "Each line is `key: value`; lines without `:` are ignored."
+    if (colon === -1) continue;
+    const key = line.slice(0, colon).trim();
+    const value = line.slice(colon + 1).trim();
+    if (!key) continue;
+    fields.push({ key, value });
+  }
+  return fields;
+}
+
+function parseMetaComment(
+  lines: string[],
+  index: number,
+): { block: CustomPartialBlock; nextIndex: number } | null {
+  const first = lines[index];
+  const openMatch = first.match(META_COMMENT_OPEN_REGEX);
+  if (!openMatch) {
+    return null;
+  }
+  const kind = openMatch[1].toLowerCase();
+
+  let bodyLines: string[] = [];
+  let inline = false;
+  let nextIndex: number;
+
+  // One-liner: opening and closing markers on the same line.
+  const oneLine = first.match(/^<!--\s*(?:test|suite)\b\s*([\s\S]*?)\s*-->\s*$/i);
+  if (oneLine) {
+    inline = true;
+    if (oneLine[1].trim()) {
+      bodyLines = [oneLine[1].trim()];
+    }
+    nextIndex = index + 1;
+  } else {
+    // Block form: keyword line, fields on their own lines, closing `-->`.
+    const afterKeyword = first.replace(/^<!--\s*(?:test|suite)\b/i, "").trim();
+    if (afterKeyword) {
+      bodyLines.push(afterKeyword);
+    }
+    let next = index + 1;
+    let closed = false;
+    while (next < lines.length) {
+      const current = lines[next];
+      if (/-->\s*$/.test(current)) {
+        const beforeClose = current.replace(/-->\s*$/, "").trim();
+        if (beforeClose) {
+          bodyLines.push(beforeClose);
+        }
+        next += 1;
+        closed = true;
+        break;
+      }
+      bodyLines.push(current);
+      next += 1;
+    }
+    if (!closed) {
+      // Unterminated comment — let normal parsing handle these lines.
+      return null;
+    }
+    nextIndex = next;
+  }
+
+  const fields = metaFieldsFromBody(bodyLines);
+
+  return {
+    block: {
+      type: "testMeta",
+      props: {
+        metaKind: kind,
+        metaFields: JSON.stringify(fields),
+        metaInline: inline,
+      },
+      children: [],
+    } as CustomPartialBlock,
+    nextIndex,
+  };
+}
+
 function parseSnippetWrapper(
   lines: string[],
   index: number,
@@ -1506,6 +1613,15 @@ export function markdownToBlocks(markdown: string, _options?: MarkdownToBlocksOp
       continue;
     }
 
+    // Test/suite metadata comments can appear anywhere (typically at the top of
+    // a document or right after a heading), so this runs ungated.
+    const metaComment = parseMetaComment(lines, index);
+    if (metaComment) {
+      blocks.push(metaComment.block);
+      index = metaComment.nextIndex;
+      continue;
+    }
+
     const snippetWrapper = stepsHeadingLevel !== null
       ? parseSnippetWrapper(lines, index)
       : null;

package/src/editor/customSchema.tsx

@@ -2,6 +2,7 @@ import { defaultBlockSpecs } from "@blocknote/core";
 import { BlockNoteSchema } from "@blocknote/core";
 import { stepBlock } from "./blocks/step";
 import { snippetBlock } from "./blocks/snippet";
+import { testMetaBlock } from "./blocks/testMeta";
 import { fileBlock } from "./blocks/fileBlock";
 import { htmlToMarkdown, markdownToHtml } from "./blocks/markdown";
 
@@ -11,6 +12,7 @@ export const customSchema = BlockNoteSchema.create({
     file: fileBlock,
     testStep: stepBlock,
     snippet: snippetBlock,
+    testMeta: testMetaBlock,
   },
 });
 

package/src/editor/styles.css

@@ -595,6 +595,207 @@ html.dark .bn-step-editor .overtype-wrapper .overtype-preview a.step-preview-lin
   flex-shrink: 0;
 }
 
+/* ============================================
+   HEADING SIZES INSIDE THE EDITOR
+   Override BlockNote's default heading scale (3em / 2em / 1.3em) with a
+   compact 22px → 14px range. BlockNote derives heading font-size from the
+   `--level` custom property, so we just redefine it per level.
+   ============================================ */
+.testomatio-editor [data-content-type="heading"] {
+  --level: 22px; /* h1 (level 1 has no [data-level] rule of its own) */
+}
+.testomatio-editor [data-content-type="heading"][data-level="2"] {
+  --level: 20px;
+}
+.testomatio-editor [data-content-type="heading"][data-level="3"] {
+  --level: 18px;
+}
+.testomatio-editor [data-content-type="heading"][data-level="4"] {
+  --level: 16px;
+}
+.testomatio-editor [data-content-type="heading"][data-level="5"] {
+  --level: 14px;
+}
+.testomatio-editor [data-content-type="heading"][data-level="6"] {
+  --level: 14px;
+}
+/* Keep size stable during BlockNote's heading-transition animation. */
+.testomatio-editor [data-prev-level="1"] {
+  --prev-level: 22px;
+}
+.testomatio-editor [data-prev-level="2"] {
+  --prev-level: 20px;
+}
+.testomatio-editor [data-prev-level="3"] {
+  --prev-level: 18px;
+}
+
+/* ============================================
+   TEST / SUITE METADATA BLOCK
+   Dimmed card for `<!-- test ... -->` / `<!-- suite ... -->` comments.
+   ============================================ */
+.bn-testmeta {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  width: 100%;
+  box-sizing: border-box;
+  padding: 6px 10px;
+  background: var(--bg-muted);
+  /*border: 1px solid var(--border-default);*/
+  /* Stronger top edge signals that the test case begins below this line. */
+  border-top: 3px solid var(--color-slate-400);
+  /*border-radius: 8px;*/
+  margin-top: 2rem;
+  opacity: 0.5;
+}
+
+/* Header line: `TEST  @T1233456 ............ [+]` — label, id, and add button
+   always share one row. */
+.bn-testmeta__header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-left: 8px;
+}
+
+.bn-testmeta__header .bn-testmeta__add-wrap {
+  margin-left: auto;
+}
+
+.bn-testmeta__label {
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--text-muted);
+  flex-shrink: 0;
+}
+
+.bn-testmeta__id {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.bn-testmeta__rows {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.bn-testmeta__row {
+  display: grid;
+  grid-template-columns: 140px minmax(0, 1fr) 24px;
+  align-items: center;
+  gap: 8px;
+}
+
+.bn-testmeta__key {
+  min-width: 0;
+  font-size: 13px;
+  color: var(--text-muted);
+}
+
+/* Defined values blend into the block like normal text, and only reveal the
+   input affordance on hover/focus ("activate on click"). */
+.bn-testmeta__key--input,
+.bn-testmeta__value {
+  width: 100%;
+  height: 26px;
+  padding: 0 8px;
+  box-sizing: border-box;
+  font-family: inherit;
+  font-size: 13px;
+  color: var(--text-primary);
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: 6px;
+  cursor: text;
+}
+
+.bn-testmeta__key--input:hover,
+.bn-testmeta__value:hover {
+  border-color: var(--border-light);
+}
+
+.bn-testmeta__key--input:focus,
+.bn-testmeta__value:focus {
+  outline: none;
+  background: var(--bg-white);
+  border-color: var(--step-input-border-focus);
+  box-shadow: 0 0 0 2px var(--step-input-shadow);
+}
+
+.bn-testmeta__remove,
+.bn-testmeta__add {
+  width: 24px;
+  height: 24px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 18px;
+  line-height: 1;
+  color: var(--text-muted);
+  background: transparent;
+  border: none;
+  border-radius: 6px;
+  cursor: pointer;
+  padding: 0;
+}
+
+.bn-testmeta__remove:hover,
+.bn-testmeta__add:hover {
+  background: var(--step-bg-button-hover);
+  color: var(--text-primary);
+}
+
+.bn-testmeta__add-wrap {
+  position: relative;
+}
+
+.bn-testmeta__menu {
+  position: absolute;
+  top: calc(100% + 4px);
+  right: 0;
+  z-index: 100;
+  min-width: 160px;
+  max-height: 240px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  padding: 4px;
+  background: var(--bg-white-opaque);
+  border: 1px solid var(--border-default);
+  border-radius: 8px;
+  box-shadow: 0 8px 24px var(--shadow-medium);
+}
+
+.bn-testmeta__menu-item {
+  display: block;
+  width: 100%;
+  padding: 6px 8px;
+  text-align: left;
+  font-family: inherit;
+  font-size: 13px;
+  color: var(--text-primary);
+  background: transparent;
+  border: none;
+  border-radius: 6px;
+  cursor: pointer;
+}
+
+.bn-testmeta__menu-item:hover {
+  background: var(--bg-muted);
+}
+
+.bn-testmeta__menu-item--custom {
+  margin-top: 2px;
+  border-top: 1px solid var(--border-light);
+  border-radius: 0 0 6px 6px;
+  color: var(--text-muted);
+}
+
 .bn-snippet-dropdown {
   position: relative;
 }

package/src/editor/testMetaFields.ts

@@ -0,0 +1,53 @@
+export type MetaFieldSuggestion = {
+  /** The field key that gets inserted, e.g. "priority". */
+  key: string;
+  /** Optional display label; defaults to `key`. */
+  label?: string;
+};
+
+/**
+ * Either a flat list (applied to both test and suite blocks) or per-kind lists.
+ * Configure from the host app via `setMetaFieldSuggestions` so embedders can
+ * plug in their own set of suggested metadata fields.
+ */
+export type MetaFieldSuggestionsConfig =
+  | MetaFieldSuggestion[]
+  | { test?: MetaFieldSuggestion[]; suite?: MetaFieldSuggestion[] };
+
+// Defaults follow the classical Testomatio markdown format. `id` is intentionally
+// omitted: it is a read-only, system-assigned field, not something users add.
+const DEFAULT_TEST_FIELDS: MetaFieldSuggestion[] = [
+  { key: "priority" },
+  { key: "type" },
+  { key: "tags" },
+  { key: "labels" },
+  { key: "assignee" },
+  { key: "creator" },
+  { key: "shared" },
+];
+
+const DEFAULT_SUITE_FIELDS: MetaFieldSuggestion[] = [
+  { key: "emoji" },
+  { key: "tags" },
+  { key: "labels" },
+  { key: "assignee" },
+];
+
+let configured: MetaFieldSuggestionsConfig | null = null;
+
+export function setMetaFieldSuggestions(config: MetaFieldSuggestionsConfig | null) {
+  configured = config;
+}
+
+export function getMetaFieldSuggestions(kind: "test" | "suite"): MetaFieldSuggestion[] {
+  if (configured) {
+    if (Array.isArray(configured)) {
+      return configured;
+    }
+    const list = kind === "suite" ? configured.suite : configured.test;
+    if (list) {
+      return list;
+    }
+  }
+  return kind === "suite" ? DEFAULT_SUITE_FIELDS : DEFAULT_TEST_FIELDS;
+}

package/src/index.ts

@@ -6,6 +6,13 @@ export {
 } from "./editor/customSchema";
 export { stepBlock, canInsertStepOrSnippet, isStepsHeading, addStepsBlock, addSnippetBlock } from "./editor/blocks/step";
 export { snippetBlock } from "./editor/blocks/snippet";
+export { testMetaBlock } from "./editor/blocks/testMeta";
+export {
+  setMetaFieldSuggestions,
+  getMetaFieldSuggestions,
+  type MetaFieldSuggestion,
+  type MetaFieldSuggestionsConfig,
+} from "./editor/testMetaFields";
 export { markdownToHtml, htmlToMarkdown } from "./editor/blocks/markdown";
 
 export {