feat(builder): CodeMirror 6 code editor for HTML/CSS/JS with lazy loading

Replaces the plain single-line input (HtmlBlock's `code` prop, via GenericPropsEditor) and the plain <textarea> (HeadCodeModal's site-wide head code) with a proper syntax-highlighted, tab-completing code editor. - New src/ui/CodeEditor.tsx: reusable CodeMirror 6 editor (state/view/ commands/autocomplete/language/lang-html/lang-css/lang-javascript/ theme-one-dark). All @codemirror/* packages are pulled in via a single dynamic import() inside the component so they land in separate lazy chunks instead of the main bundle -- confirmed via `npm run build`: main editor.js grew by only ~5.5KB (657KB -> 663KB raw) while ~570KB of CodeMirror source split into index*.js chunks that only load when a code editor modal is actually opened. While that import is in flight, or if it ever fails, the component renders a plain <textarea> so typing never breaks. - GenericPropsEditor.tsx: special-cases the `code` prop (used only by HtmlBlock today) into an "Edit HTML" button that opens the CodeEditor in a modal (language="html"), instead of rendering it as a single-line text input alongside the component's other string props. - HeadCodeModal.tsx: swaps its <textarea> for CodeEditor (language="html" -- head code is HTML with embedded <script>/<style>), keeping the existing SiteDesignContext.updateDesign({ headCode }) wiring. GuidedStyles.tsx untouched: HtmlBlock's displayName ("HTML") already matches GuidedStyles' `isUtility` regex and routes to GenericPropsEditor, so no dispatcher change was needed. HtmlBlock.tsx untouched: purifyHtml/toHtml sanitization is unchanged, as specified. Skipped the optional AnimationControl/VisibilityControl addition -- HtmlBlock has no dedicated StylePanel (it shares GenericPropsEditor with Divider/Spacer/every unmatched type), and doing it well would mean adding real Animation/Visibility widgets to that shared editor for every consumer, which is a bigger change than "trivial" for this package's scope. Tests: CodeEditor.test.tsx and HeadCodeModal.test.tsx both exploit the fact that dynamic import() always resolves on a later microtask, so asserting against the DOM immediately after the initial synchronous render deterministically exercises the <textarea> fallback path (value display, onChange wiring, language prop plumbing) without needing to mock @codemirror/*. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-14 06:42:59 -07:00
parent 1d9460c173
commit 88df4f2888
5 changed files with 523 additions and 23 deletions
@@ -0,0 +1,90 @@
+import { describe, test, expect, vi, afterEach } from 'vitest';
+import React from 'react';
+import { createRoot, Root } from 'react-dom/client';
+import { act } from 'react-dom/test-utils';
+import { CodeEditor } from './CodeEditor';
+
+/* ---------- DOM test harness (no @testing-library/react in this repo; see
+   src/ui/AssetPicker.test.tsx / src/ui/Modal.test.tsx for the same
+   react-dom/client + react-dom/test-utils `act` pattern). ----------
+
+   CodeMirror is loaded via dynamic import() (see CodeEditor.tsx), which is
+   always async -- even for an already-resolved/cached module, `import()`
+   only settles on a later microtask. That means immediately after the
+   initial synchronous `act(() => root.render(...))` below, the component is
+   still in its 'loading' state and renders the <textarea> fallback. These
+   tests deliberately assert against that first-tick DOM (never awaiting
+   the CodeMirror promise), so they exercise exactly the fallback path a
+   real headless/offline environment would fall back to, deterministically
+   and without needing to mock @codemirror/*. */
+
+let container: HTMLDivElement;
+let root: Root;
+
+function render(ui: React.ReactElement) {
+  container = document.createElement('div');
+  document.body.appendChild(container);
+  act(() => {
+    root = createRoot(container);
+    root.render(ui);
+  });
+}
+
+afterEach(() => {
+  if (container) {
+    act(() => { root.unmount(); });
+    container.remove();
+  }
+});
+
+function fallbackTextarea(): HTMLTextAreaElement {
+  const el = container.querySelector<HTMLTextAreaElement>('[data-testid="code-editor-fallback"]');
+  if (!el) throw new Error('fallback textarea not found');
+  return el;
+}
+
+describe('CodeEditor', () => {
+  test('shows the textarea fallback immediately (CodeMirror loads async)', () => {
+    render(<CodeEditor value="<p>hi</p>" onChange={vi.fn()} />);
+    const textarea = fallbackTextarea();
+    expect(textarea.value).toBe('<p>hi</p>');
+  });
+
+  test('the CodeMirror mount root is hidden while the fallback is showing', () => {
+    render(<CodeEditor value="" onChange={vi.fn()} />);
+    const cmRoot = container.querySelector<HTMLDivElement>('[data-testid="code-editor-cm-root"]');
+    expect(cmRoot?.style.display).toBe('none');
+  });
+
+  test('onChange fires with the new value when typing in the fallback textarea', () => {
+    const onChange = vi.fn();
+    render(<CodeEditor value="<p>hi</p>" onChange={onChange} />);
+    const textarea = fallbackTextarea();
+    act(() => {
+      const setter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')!.set!;
+      setter.call(textarea, '<p>updated</p>');
+      textarea.dispatchEvent(new Event('input', { bubbles: true }));
+    });
+    expect(onChange).toHaveBeenCalledWith('<p>updated</p>');
+  });
+
+  test('accepts a language prop without throwing (html/css/javascript/auto)', () => {
+    for (const language of ['html', 'css', 'javascript', 'auto'] as const) {
+      expect(() => render(<CodeEditor value="" onChange={vi.fn()} language={language} />)).not.toThrow();
+      const textarea = fallbackTextarea();
+      expect(textarea.dataset.language).toBe(language);
+      act(() => { root.unmount(); });
+      container.remove();
+    }
+  });
+
+  test('defaults to html language when none is passed', () => {
+    render(<CodeEditor value="" onChange={vi.fn()} />);
+    expect(fallbackTextarea().dataset.language).toBe('html');
+  });
+
+  test('respects a custom height', () => {
+    render(<CodeEditor value="" onChange={vi.fn()} height={480} />);
+    expect((container.firstElementChild as HTMLElement).style.height).toBe('480px');
+  });
+});
@@ -0,0 +1,257 @@
+import React, { useEffect, useRef, useState } from 'react';
+import type { EditorView as EditorViewType } from '@codemirror/view';
+
+export type CodeEditorLanguage = 'html' | 'css' | 'javascript' | 'auto';
+
+export interface CodeEditorProps {
+  value: string;
+  onChange: (value: string) => void;
+  /** 'auto' behaves like 'html' -- the HTML language mode already highlights
+   *  embedded <script>/<style> blocks, which covers the common "auto" case
+   *  of mixed markup. */
+  language?: CodeEditorLanguage;
+  height?: number | string;
+  placeholder?: string;
+}
+
+/* ----------------------------------------------------------------
+   Lazy-loaded CodeMirror 6.
+
+   All @codemirror/* packages are pulled in via dynamic import() so they
+   land in their own chunk(s) (see vite.config.ts chunkFileNames) instead of
+   bloating the main editor.js bundle -- most sessions never open a code
+   editor. The module set is fetched once (module-level promise, shared
+   across every CodeEditor instance on the page) and cached forever.
+
+   While the import is in flight -- or if it ever fails (offline, CDN
+   hiccup, an environment where CodeMirror can't mount e.g. some headless
+   test runners) -- callers get a plain <textarea> so editing never breaks,
+   just loses syntax highlighting/autocomplete.
+   ---------------------------------------------------------------- */
+
+interface CmModules {
+  EditorState: typeof import('@codemirror/state').EditorState;
+  EditorView: typeof import('@codemirror/view').EditorView;
+  keymap: typeof import('@codemirror/view').keymap;
+  lineNumbers: typeof import('@codemirror/view').lineNumbers;
+  highlightActiveLine: typeof import('@codemirror/view').highlightActiveLine;
+  highlightActiveLineGutter: typeof import('@codemirror/view').highlightActiveLineGutter;
+  drawSelection: typeof import('@codemirror/view').drawSelection;
+  defaultKeymap: typeof import('@codemirror/commands').defaultKeymap;
+  history: typeof import('@codemirror/commands').history;
+  historyKeymap: typeof import('@codemirror/commands').historyKeymap;
+  indentWithTab: typeof import('@codemirror/commands').indentWithTab;
+  syntaxHighlighting: typeof import('@codemirror/language').syntaxHighlighting;
+  defaultHighlightStyle: typeof import('@codemirror/language').defaultHighlightStyle;
+  bracketMatching: typeof import('@codemirror/language').bracketMatching;
+  indentOnInput: typeof import('@codemirror/language').indentOnInput;
+  foldGutter: typeof import('@codemirror/language').foldGutter;
+  autocompletion: typeof import('@codemirror/autocomplete').autocompletion;
+  completionKeymap: typeof import('@codemirror/autocomplete').completionKeymap;
+  closeBrackets: typeof import('@codemirror/autocomplete').closeBrackets;
+  closeBracketsKeymap: typeof import('@codemirror/autocomplete').closeBracketsKeymap;
+  html: typeof import('@codemirror/lang-html').html;
+  css: typeof import('@codemirror/lang-css').css;
+  javascript: typeof import('@codemirror/lang-javascript').javascript;
+  oneDark: typeof import('@codemirror/theme-one-dark').oneDark;
+}
+
+let cmModulesPromise: Promise<CmModules> | null = null;
+
+function loadCodeMirror(): Promise<CmModules> {
+  if (!cmModulesPromise) {
+    cmModulesPromise = Promise.all([
+      import('@codemirror/state'),
+      import('@codemirror/view'),
+      import('@codemirror/commands'),
+      import('@codemirror/language'),
+      import('@codemirror/autocomplete'),
+      import('@codemirror/lang-html'),
+      import('@codemirror/lang-css'),
+      import('@codemirror/lang-javascript'),
+      import('@codemirror/theme-one-dark'),
+    ]).then(([state, view, commands, language, autocomplete, langHtml, langCss, langJs, theme]) => ({
+      EditorState: state.EditorState,
+      EditorView: view.EditorView,
+      keymap: view.keymap,
+      lineNumbers: view.lineNumbers,
+      highlightActiveLine: view.highlightActiveLine,
+      highlightActiveLineGutter: view.highlightActiveLineGutter,
+      drawSelection: view.drawSelection,
+      defaultKeymap: commands.defaultKeymap,
+      history: commands.history,
+      historyKeymap: commands.historyKeymap,
+      indentWithTab: commands.indentWithTab,
+      syntaxHighlighting: language.syntaxHighlighting,
+      defaultHighlightStyle: language.defaultHighlightStyle,
+      bracketMatching: language.bracketMatching,
+      indentOnInput: language.indentOnInput,
+      foldGutter: language.foldGutter,
+      autocompletion: autocomplete.autocompletion,
+      completionKeymap: autocomplete.completionKeymap,
+      closeBrackets: autocomplete.closeBrackets,
+      closeBracketsKeymap: autocomplete.closeBracketsKeymap,
+      html: langHtml.html,
+      css: langCss.css,
+      javascript: langJs.javascript,
+      oneDark: theme.oneDark,
+    }));
+  }
+  return cmModulesPromise;
+}
+
+function languageExtension(mods: CmModules, language: CodeEditorLanguage) {
+  switch (language) {
+    case 'css':
+      return mods.css();
+    case 'javascript':
+      return mods.javascript();
+    case 'html':
+    case 'auto':
+    default:
+      // lang-html already highlights + completes embedded <script>/<style>
+      // blocks as JS/CSS, which is exactly what "auto" wants for mixed
+      // HTML snippets (head code, HTML blocks).
+      return mods.html({ autoCloseTags: true });
+  }
+}
+
+const fallbackStyle: React.CSSProperties = {
+  width: '100%',
+  height: '100%',
+  padding: 14,
+  background: '#0d0d0f',
+  color: '#e4e4e7',
+  border: '1px solid #3f3f46',
+  borderRadius: 8,
+  fontFamily: 'Source Code Pro, Consolas, monospace',
+  fontSize: 13,
+  lineHeight: 1.6,
+  resize: 'none',
+  outline: 'none',
+  tabSize: 2,
+  boxSizing: 'border-box',
+};
+
+export const CodeEditor: React.FC<CodeEditorProps> = ({
+  value,
+  onChange,
+  language = 'html',
+  height = 320,
+  placeholder,
+}) => {
+  const containerRef = useRef<HTMLDivElement | null>(null);
+  const viewRef = useRef<EditorViewType | null>(null);
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  // Tracks the last value this component itself emitted, so the
+  // value-sync effect below doesn't stomp on in-progress typing when the
+  // parent re-renders with the exact same string it was just handed.
+  const lastEmittedRef = useRef(value);
+  const [status, setStatus] = useState<'loading' | 'ready' | 'error'>('loading');
+
+  useEffect(() => {
+    let cancelled = false;
+    setStatus('loading');
+
+    loadCodeMirror()
+      .then((mods) => {
+        if (cancelled || !containerRef.current) return;
+        const updateListener = mods.EditorView.updateListener.of((update) => {
+          if (update.docChanged) {
+            const next = update.state.doc.toString();
+            lastEmittedRef.current = next;
+            onChangeRef.current(next);
+          }
+        });
+        const state = mods.EditorState.create({
+          doc: value,
+          extensions: [
+            mods.lineNumbers(),
+            mods.highlightActiveLineGutter(),
+            mods.highlightActiveLine(),
+            mods.history(),
+            mods.foldGutter(),
+            mods.drawSelection(),
+            mods.indentOnInput(),
+            mods.syntaxHighlighting(mods.defaultHighlightStyle, { fallback: true }),
+            mods.bracketMatching(),
+            mods.closeBrackets(),
+            mods.autocompletion(),
+            mods.keymap.of([
+              ...mods.closeBracketsKeymap,
+              ...mods.historyKeymap,
+              ...mods.completionKeymap,
+              ...mods.defaultKeymap,
+              mods.indentWithTab,
+            ]),
+            languageExtension(mods, language),
+            mods.oneDark,
+            mods.EditorView.lineWrapping,
+            updateListener,
+          ],
+        });
+        const view = new mods.EditorView({ state, parent: containerRef.current });
+        viewRef.current = view;
+        setStatus('ready');
+      })
+      .catch((err) => {
+        // eslint-disable-next-line no-console
+        console.error('CodeEditor: CodeMirror failed to load, falling back to a plain textarea', err);
+        if (!cancelled) setStatus('error');
+      });
+
+    return () => {
+      cancelled = true;
+      viewRef.current?.destroy();
+      viewRef.current = null;
+    };
+    // Re-mount on language change (language is fixed for HTML/CSS/JS
+    // targets in this app -- it never flips on an already-open editor --
+    // but re-creating cleanly if it ever does is simpler/safer than trying
+    // to reconfigure the LanguageSupport extension in place).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [language]);
+
+  // Keep the live CodeMirror doc in sync if `value` changes from outside
+  // (e.g. the modal is reused for a different field) without clobbering
+  // the cursor position/selection on every keystroke-driven re-render.
+  useEffect(() => {
+    const view = viewRef.current;
+    if (!view || status !== 'ready') return;
+    if (value === lastEmittedRef.current) return;
+    const current = view.state.doc.toString();
+    if (current === value) return;
+    view.dispatch({ changes: { from: 0, to: current.length, insert: value } });
+    lastEmittedRef.current = value;
+  }, [value, status]);
+
+  const showFallback = status !== 'ready';
+
+  return (
+    <div style={{ position: 'relative', height, minHeight: height }}>
+      <div
+        ref={containerRef}
+        data-testid="code-editor-cm-root"
+        style={{
+          height: '100%',
+          overflow: 'auto',
+          borderRadius: 8,
+          border: '1px solid #3f3f46',
+          display: showFallback ? 'none' : 'block',
+        }}
+      />
+      {showFallback && (
+        <textarea
+          data-testid="code-editor-fallback"
+          data-language={language}
+          value={value}
+          onChange={(e) => onChange(e.target.value)}
+          placeholder={status === 'loading' ? (placeholder || 'Loading editor…') : placeholder}
+          spellCheck={false}
+          style={fallbackStyle}
+        />
+      )}
+    </div>
+  );
+};