cloud-hosting-platform/site-builder
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Josh Knapp
2026-07-14 06:42:59 -07:00
parent 1d9460c173
commit 88df4f2888
5 changed files with 523 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
craft/src/panels/right/styles/GenericPropsEditor.tsx
+81 -2
View File
@@ -1,4 +1,4 @@
import React from 'react';
import React, { useState } from 'react';
import {
TEXT_COLORS,
BG_COLORS,
@@ -17,12 +17,85 @@ import {
useNodeProp,
} from './shared';
import { ArrayItemFieldsEditor } from './ArrayItemFields';
import { Modal } from '../../../ui/Modal';
import { CodeEditor } from '../../../ui/CodeEditor';
/* ---------- "Edit HTML" modal for the HtmlBlock `code` prop ----------
`code` is raw HTML (potentially many lines, embedded <style>/<script>),
so it gets a dedicated syntax-highlighted CodeEditor in a modal instead
of falling into the generic single-line/textarea string-prop rendering
below (see GenericPropsEditor's SKIP of the `code` key). */
const HtmlCodeField: React.FC<{ value: string; onChange: (v: string) => void }> = ({ value, onChange }) => {
const [open, setOpen] = useState(false);
return (
<CollapsibleSection title="HTML Code">
<div style={sectionGap}>
<button
onClick={() => setOpen(true)}
style={{
width: '100%', padding: '8px 12px', fontSize: 12, fontWeight: 600,
display: 'flex', alignItems: 'center', justifyContent: 'center', gap: 6,
background: '#27272a', color: '#e4e4e7', border: '1px solid #3f3f46',
borderRadius: 6, cursor: 'pointer',
}}
>
<i className="fa fa-code" /> Edit HTML
</button>
</div>
<Modal open={open} onClose={() => setOpen(false)} width="min(720px, 90vw)">
<div
style={{
background: 'var(--color-bg-surface)',
border: '1px solid var(--color-border)',
borderRadius: 12,
boxShadow: '0 20px 60px rgba(0,0,0,0.5)',
display: 'flex',
flexDirection: 'column',
overflow: 'hidden',
}}
onClick={(e) => e.stopPropagation()}
>
<div style={{
display: 'flex', alignItems: 'center', justifyContent: 'space-between',
padding: '14px 16px', borderBottom: '1px solid var(--color-border)',
}}>
<div style={{ fontSize: 14, fontWeight: 600, color: 'var(--color-text)' }}>Edit HTML</div>
<button
onClick={() => setOpen(false)}
style={{
width: 28, height: 28, display: 'inline-flex', alignItems: 'center', justifyContent: 'center',
background: 'none', border: '1px solid var(--color-border)', borderRadius: 6,
color: 'var(--color-text-muted)', cursor: 'pointer', fontSize: 13,
}}
>
<i className="fa fa-times" />
</button>
</div>
<div style={{ padding: 16 }}>
<CodeEditor value={value} onChange={onChange} language="html" height={420} />
</div>
<div style={{ padding: '10px 16px', borderTop: '1px solid var(--color-border)', display: 'flex', justifyContent: 'flex-end' }}>
<button
onClick={() => setOpen(false)}
style={{
padding: '7px 20px', fontSize: 13, fontWeight: 600,
background: 'var(--color-accent)', color: '#fff', border: 'none', borderRadius: 6, cursor: 'pointer',
}}
>
Done
</button>
</div>
</div>
</Modal>
</CollapsibleSection>
);
};
/* ---------- SMART GENERIC PROPS EDITOR (Fallback) ---------- */
export const GenericPropsEditor: React.FC<{ selectedId: string; nodeProps: Record<string, any>; typeName: string }> = ({
selectedId, nodeProps, typeName,
}) => {
const SKIP_PROPS = new Set(['style', 'children', 'cssId', 'cssClass']);
const SKIP_PROPS = new Set(['style', 'children', 'cssId', 'cssClass', 'code']);
const { setProp: setPropValue, setPropStyle: setStyleValue } = useNodeProp(selectedId);
@@ -35,9 +108,15 @@ export const GenericPropsEditor: React.FC<{ selectedId: string; nodeProps: Recor
const arrayProps = allProps.filter(([_, val]) => Array.isArray(val));
const style = nodeProps.style || {};
const hasCodeProp = typeof nodeProps.code === 'string';
return (
<>
{/* Raw HTML (HtmlBlock's `code` prop) -- dedicated CodeEditor modal */}
{hasCodeProp && (
<HtmlCodeField value={nodeProps.code} onChange={(v) => setPropValue('code', v)} />
)}
{/* String props */}
{stringProps.length > 0 && (
<CollapsibleSection title="Properties">
craft/src/panels/topbar/HeadCodeModal.test.tsx
+85
View File
@@ -0,0 +1,85 @@
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 { HeadCodeModal } from './HeadCodeModal';
import { SiteDesignProvider, useSiteDesign } from '../../state/SiteDesignContext';
/* ---------- DOM test harness -- same react-dom/client + `act` pattern used
throughout src/ui/*.test.tsx (no @testing-library/react in this repo). ---------- */
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();
}
document.body.style.overflow = '';
});
// Exposes the current headCode so assertions can read it back after a
// simulated edit -- CodeEditor writes through `updateDesign`, this just
// surfaces the result.
function Harness({ onReady }: { onReady: (headCode: string) => void }) {
const { design } = useSiteDesign();
onReady(design.headCode);
return null;
}
describe('HeadCodeModal', () => {
// HeadCodeModal portals its content to document.body (see the comment in
// HeadCodeModal.tsx), so the rendered DOM lives outside `container` --
// query document.body instead.
test('renders the CodeEditor (fallback textarea path) seeded with the current headCode', () => {
render(
<SiteDesignProvider>
<HeadCodeModal open onClose={vi.fn()} />
</SiteDesignProvider>,
);
// CodeMirror loads via async dynamic import (see CodeEditor.test.tsx);
// synchronously after mount the fallback textarea is what's live.
const textarea = document.body.querySelector<HTMLTextAreaElement>('[data-testid="code-editor-fallback"]');
expect(textarea).not.toBeNull();
expect(textarea!.value).toBe('');
expect(textarea!.dataset.language).toBe('html');
});
test('typing in the editor writes through to SiteDesignContext.headCode', () => {
let latestHeadCode = '';
render(
<SiteDesignProvider>
<HeadCodeModal open onClose={vi.fn()} />
<Harness onReady={(v) => { latestHeadCode = v; }} />
</SiteDesignProvider>,
);
const textarea = document.body.querySelector<HTMLTextAreaElement>('[data-testid="code-editor-fallback"]')!;
act(() => {
const setter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')!.set!;
setter.call(textarea, '<meta name="x" content="y">');
textarea.dispatchEvent(new Event('input', { bubbles: true }));
});
expect(latestHeadCode).toBe('<meta name="x" content="y">');
});
test('does not render when closed', () => {
render(
<SiteDesignProvider>
<HeadCodeModal open={false} onClose={vi.fn()} />
</SiteDesignProvider>,
);
expect(document.body.querySelector('[data-testid="code-editor-fallback"]')).toBeNull();
});
});
craft/src/panels/topbar/HeadCodeModal.tsx
+7 -18
View File
@@ -2,6 +2,7 @@ import React from 'react';
import { createPortal } from 'react-dom';
import { useSiteDesign } from '../../state/SiteDesignContext';
import { Modal } from '../../ui/Modal';
import { CodeEditor } from '../../ui/CodeEditor';
interface HeadCodeModalProps {
open: boolean;
@@ -55,28 +56,16 @@ export const HeadCodeModal: React.FC<HeadCodeModalProps> = ({ open, onClose }) =
Code added here will be injected into the <code style={{ background: 'rgba(255,255,255,0.08)', padding: '1px 4px', borderRadius: 3, fontSize: 11 }}>&lt;head&gt;</code> of every page on your site. Use it for analytics, custom fonts, or global CSS.
</div>
<textarea
<div style={{ flex: 1, minHeight: 300 }}>
<CodeEditor
value={design.headCode || ''}
onChange={(e) => updateDesign({ headCode: e.target.value })}
onChange={(code) => updateDesign({ headCode: code })}
language="html"
height="100%"
placeholder={"<!-- Google Analytics -->\n<script async src=\"https://...\"></script>\n\n<!-- Custom Fonts -->\n<link href=\"https://fonts.googleapis.com/...\" rel=\"stylesheet\">\n\n<style>\n /* Global CSS overrides */\n body { }\n</style>"}
style={{
flex: 1,
minHeight: 300,
padding: 14,
background: '#0d0d0f',
color: '#e4e4e7',
border: '1px solid #3f3f46',
borderRadius: 8,
fontFamily: 'Source Code Pro, Consolas, monospace',
fontSize: 13,
lineHeight: 1.6,
resize: 'vertical',
outline: 'none',
tabSize: 2,
}}
spellCheck={false}
/>
</div>
</div>
{/* Footer */}
<div style={{
craft/src/ui/CodeEditor.test.tsx
+90
View File
@@ -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');
});
});
craft/src/ui/CodeEditor.tsx
+257
View File
@@ -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>
);
};