fix(editor): preserve pre-mount empty checks

Author: cdskill

libs/editor/forms/src/control-value-accessor.ts

@@ -96,7 +96,7 @@ export class QalmaControlValueAccessor
   /**
    * Current control value for the editor. Reads `html()` unconditionally so the
    * `effect` tracks it, then collapses an empty document to `''` via the
-   * DOM-free `isEmpty()` query (so `Validators.required` behaves).
+   * editor's `isEmpty()` query (so `Validators.required` behaves).
    */
   private currentValue(): string {
     const editor = this.editorHost.editor();

libs/editor/src/lib/editor/qalma-editor-controller.spec.ts

@@ -1,7 +1,14 @@
 import { computed } from '@angular/core';
-
-import { HardBreakPlugin, HorizontalRulePlugin, ImagePlugin } from '../../index';
-import { createQalmaEditor } from '../../index';
+import { vi } from 'vitest';
+
+import {
+  BlockquotePlugin,
+  HardBreakPlugin,
+  HorizontalRulePlugin,
+  ImagePlugin,
+  ListsPlugin,
+  createQalmaEditor,
+} from '../../index';
 import { mountEditor } from '../../../testing/editor-test-utils';
 
 describe('QalmaEditorController.isEmpty', () => {
@@ -101,4 +108,52 @@ describe('QalmaEditorController.isEmpty', () => {
     expect(createQalmaEditor({ content: '<p></p>' }).isEmpty()).toBe(true);
     expect(createQalmaEditor({ content: '<p>Draft</p>' }).isEmpty()).toBe(false);
   });
+
+  it('uses the document model for serialized empty content before mount', () => {
+    expect(createQalmaEditor({ content: '<p>&nbsp;</p>' }).isEmpty()).toBe(true);
+    expect(
+      createQalmaEditor({
+        content: '<p><br></p>',
+        plugins: [HardBreakPlugin],
+      }).isEmpty(),
+    ).toBe(true);
+    expect(
+      createQalmaEditor({
+        content: '<blockquote><p></p></blockquote>',
+        plugins: [BlockquotePlugin],
+      }).isEmpty(),
+    ).toBe(true);
+    expect(
+      createQalmaEditor({
+        content: '<ul><li><p></p></li></ul>',
+        plugins: [ListsPlugin],
+      }).isEmpty(),
+    ).toBe(true);
+  });
+
+  it('keeps the pre-mount empty check safe without a document global', () => {
+    const originalDocument = globalThis.document;
+
+    vi.stubGlobal('document', undefined);
+
+    try {
+      expect(createQalmaEditor({ content: '<p>&nbsp;</p>' }).isEmpty()).toBe(
+        true,
+      );
+      expect(createQalmaEditor({ content: '<p><br></p>' }).isEmpty()).toBe(
+        true,
+      );
+      expect(createQalmaEditor({ content: '<p>Draft</p>' }).isEmpty()).toBe(
+        false,
+      );
+      expect(
+        createQalmaEditor({
+          content: '<hr>',
+          plugins: [HorizontalRulePlugin],
+        }).isEmpty(),
+      ).toBe(false);
+    } finally {
+      vi.stubGlobal('document', originalDocument);
+    }
+  });
 });

libs/editor/src/lib/editor/qalma-editor-controller.ts

@@ -229,8 +229,9 @@ export class QalmaEditorController {
    * Whether the document has no user-visible content: no text and no media
    * (images, mentions, tables, horizontal rules). Empty paragraphs, empty
    * structural containers (blockquotes, lists) and hard breaks all count as
-   * empty. Computed from the document model, so it never touches the DOM and is
-   * safe to call during server-side rendering — unlike re-parsing `html()`.
+   * empty. Computed from the document model when one exists; before mount,
+   * serialized HTML is parsed through the editor schema when a DOM parser is
+   * available, with a schema-aware string fallback for server-side rendering.
    * Tracks editor state like the other read models, so it stays live inside
    * `computed`/`effect`. Form adapters use it to normalize an empty editor to an
    * empty control value.
@@ -244,9 +245,7 @@ export class QalmaEditorController {
       return isEmptyDocument(doc);
     }
 
-    const html = this.html().trim();
-
-    return html === '' || html === EMPTY_DOCUMENT_HTML;
+    return isEmptyHtmlDocument(this.html(), this.schema);
   }
 
   setEditable(editable: boolean): void {
@@ -330,6 +329,50 @@ function isEmptyDocument(doc: ProseMirrorNode): boolean {
   return !hasContent;
 }
 
+function isEmptyHtmlDocument(html: string, schema: Schema): boolean {
+  if (canParseHtmlDocument()) {
+    return isEmptyDocument(parseHtmlDocument(html, schema));
+  }
+
+  return isEmptySerializedHtml(html, schema);
+}
+
+function canParseHtmlDocument(): boolean {
+  return (
+    typeof document !== 'undefined' &&
+    typeof document.createElement === 'function'
+  );
+}
+
+function isEmptySerializedHtml(html: string, schema: Schema): boolean {
+  const trimmedHtml = html.trim();
+
+  if (trimmedHtml === '') {
+    return true;
+  }
+
+  if (
+    (schema.nodes['image'] && /<img\b/i.test(trimmedHtml)) ||
+    (schema.nodes['horizontalRule'] && /<hr\b/i.test(trimmedHtml)) ||
+    (schema.nodes['table'] && /<table\b/i.test(trimmedHtml)) ||
+    (schema.nodes['mention'] &&
+      /<span\b[^>]*\bdata-qalma-mention\b/i.test(trimmedHtml))
+  ) {
+    return false;
+  }
+
+  return (
+    trimmedHtml
+      .replace(/<br\b[^>]*>/gi, '')
+      .replace(/<[^>]+>/g, '')
+      .replace(/&nbsp;|&#160;|&#xa0;/gi, ' ')
+      .replace(/&#8203;|&#x200b;|&ZeroWidthSpace;/gi, '')
+      .replace(/\u00a0/g, ' ')
+      .replace(/\u200b/g, '')
+      .trim().length === 0
+  );
+}
+
 /**
  * A node that counts as content even when the document carries no text: media
  * atoms (images, mentions), tables, and block-level leaves (horizontal rules,