@stephen-netu/design-system 0.2.2 → 0.5.1

package/dist/editor/extensions/autocomplete.test.js

@@ -0,0 +1,121 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { autocomplete } from './autocomplete';
+function createView(doc, config) {
+    return new EditorView({
+        state: EditorState.create({
+            doc,
+            extensions: [autocomplete(config)],
+        }),
+        parent: document.body,
+    });
+}
+describe('autocomplete', () => {
+    let view;
+    afterEach(() => {
+        if (view)
+            view.destroy();
+    });
+    const simpleSource = (context) => {
+        const word = context.state.doc.toString();
+        const options = [
+            { label: 'apple', type: 'keyword' },
+            { label: 'application', type: 'keyword' },
+            { label: 'apply', type: 'keyword' },
+            { label: 'banana', type: 'keyword' },
+        ];
+        return {
+            from: 0,
+            options: options.filter((o) => o.label.startsWith(word)),
+        };
+    };
+    it('exports a valid extension', () => {
+        const ext = autocomplete({ source: simpleSource });
+        expect(ext).toBeDefined();
+    });
+    it('accepts a CompletionSource function', () => {
+        const ext = autocomplete({ source: simpleSource });
+        view = new EditorView({
+            state: EditorState.create({
+                doc: '',
+                extensions: [ext],
+            }),
+            parent: document.body,
+        });
+        expect(view.state.doc.toString()).toBe('');
+        view.destroy();
+    });
+    it('respects defaultKeymap option', () => {
+        const ext = autocomplete({ source: simpleSource, defaultKeymap: false });
+        expect(ext).toBeDefined();
+    });
+    it('respects closeOnBlur option', () => {
+        const ext = autocomplete({ source: simpleSource, closeOnBlur: false });
+        expect(ext).toBeDefined();
+    });
+    it('uses defaultKeymap true by default', () => {
+        const ext = autocomplete({ source: simpleSource });
+        view = new EditorView({
+            state: EditorState.create({
+                doc: 'test',
+                extensions: [ext],
+            }),
+            parent: document.body,
+        });
+        expect(view).toBeDefined();
+        view.destroy();
+    });
+    it('uses closeOnBlur true by default', () => {
+        const ext = autocomplete({ source: simpleSource });
+        view = new EditorView({
+            state: EditorState.create({
+                doc: '',
+                extensions: [ext],
+            }),
+            parent: document.body,
+        });
+        expect(view).toBeDefined();
+        view.destroy();
+    });
+    it('wraps @codemirror/autocomplete autocompletion()', () => {
+        const ext = autocomplete({ source: simpleSource });
+        expect(ext).toBeTruthy();
+    });
+    it('passes override array with the provided source', () => {
+        const ext = autocomplete({ source: simpleSource });
+        view = new EditorView({
+            state: EditorState.create({
+                doc: '',
+                extensions: [ext],
+            }),
+            parent: document.body,
+        });
+        expect(view.state).toBeDefined();
+        view.destroy();
+    });
+    it('works with empty document', () => {
+        view = createView('', { source: simpleSource });
+        expect(view.state.doc.toString()).toBe('');
+    });
+    it('works with existing text', () => {
+        view = createView('hello world', { source: simpleSource });
+        expect(view.state.doc.toString()).toBe('hello world');
+    });
+    it('CompletionSource receives typed context', () => {
+        const capturingSource = (context) => ({
+            from: context.state.doc.length,
+            options: [],
+        });
+        const ext = autocomplete({ source: capturingSource });
+        expect(ext).toBeDefined();
+    });
+    it('multiple autocomplete instances do not conflict', () => {
+        const view1 = createView('abc', { source: simpleSource });
+        const view2 = createView('xyz', { source: simpleSource });
+        expect(view1.state.doc.toString()).toBe('abc');
+        expect(view2.state.doc.toString()).toBe('xyz');
+        view1.destroy();
+        view2.destroy();
+    });
+});

package/dist/editor/extensions/spellcheck.d.ts

@@ -1,7 +1,25 @@
+import { EditorView } from '@codemirror/view';
+import type { Extension } from '@codemirror/state';
 export interface SpellCheckDictionary {
-    check(word: string): boolean;
-    suggest(word: string): string[];
+    check(word: string): boolean | Promise<boolean>;
+    suggest(word: string): string[] | Promise<string[]>;
     addWord(word: string): void;
 }
-export declare function spellcheck(dictionary: SpellCheckDictionary): import("@codemirror/state").Extension;
+export interface SpellCheckCorrection {
+    original: string;
+    suggestions: string[];
+    position: {
+        top: number;
+        left: number;
+    };
+}
+export interface SpellCheckConfig {
+    onCorrectionClick?: (correction: SpellCheckCorrection, view: EditorView, from: number, to: number) => void | Promise<void>;
+}
+export declare function extractWords(text: string, maxWords?: number): {
+    word: string;
+    from: number;
+    to: number;
+}[];
+export declare function spellcheck(dictionary: SpellCheckDictionary, config?: SpellCheckConfig): Extension[];
 //# sourceMappingURL=spellcheck.d.ts.map

package/dist/editor/extensions/spellcheck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spellcheck.d.ts","sourceRoot":"","sources":["../../../src/editor/extensions/spellcheck.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACjC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAChC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAmBD,wBAAgB,UAAU,CAAC,UAAU,EAAE,oBAAoB,yCA4B1D"}
+{"version":3,"file":"spellcheck.d.ts","sourceRoot":"","sources":["../../../src/editor/extensions/spellcheck.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,oBAAoB;IACjC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACpD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C;AAED,MAAM,WAAW,gBAAgB;IAC7B,iBAAiB,CAAC,EAAE,CAChB,UAAU,EAAE,oBAAoB,EAChC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,KACT,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAID,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAqB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,CAetH;AAMD,wBAAgB,UAAU,CAAC,UAAU,EAAE,oBAAoB,EAAE,MAAM,GAAE,gBAAqB,GAAG,SAAS,EAAE,CAwEvG"}

package/dist/editor/extensions/spellcheck.js

@@ -1,8 +1,10 @@
 import { linter } from '@codemirror/lint';
-function extractWords(text) {
+import { EditorView } from '@codemirror/view';
+const MAX_WORDS_PER_LINT = 4096;
+export function extractWords(text, maxWords = MAX_WORDS_PER_LINT) {
     const words = [];
     let i = 0;
-    while (i < text.length) {
+    while (i < text.length && words.length < maxWords) {
         if (/[a-zA-Z]/.test(text[i])) {
             const start = i;
             while (i < text.length && /[a-zA-Z']/.test(text[i])) {
@@ -16,18 +18,24 @@ function extractWords(text) {
     }
     return words;
 }
-export function spellcheck(dictionary) {
-    const lintSource = (view) => {
+function wordAt(view, pos) {
+    return extractWords(view.state.doc.toString()).find(({ from, to }) => pos >= from && pos <= to) ?? null;
+}
+export function spellcheck(dictionary, config = {}) {
+    const lintSource = async (view) => {
         const diagnostics = [];
         const words = extractWords(view.state.doc.toString());
         for (const { word, from, to } of words) {
-            if (word.length > 1 && !dictionary.check(word)) {
+            if (word.length > 1 && !(await dictionary.check(word))) {
+                const suggestions = (await dictionary.suggest(word))
+                    .slice(0, 8)
+                    .sort((a, b) => a.localeCompare(b));
                 diagnostics.push({
                     from,
                     to,
                     severity: 'warning',
                     message: `"${word}"`,
-                    actions: dictionary.suggest(word).slice(0, 8).map((suggestion) => ({
+                    actions: suggestions.map((suggestion) => ({
                         name: suggestion,
                         apply(v, from, to) {
                             v.dispatch({ changes: { from, to, insert: suggestion } });
@@ -38,7 +46,41 @@ export function spellcheck(dictionary) {
         }
         return diagnostics;
     };
-    return linter(lintSource, {
-        delay: 300,
-    });
+    const clickHandler = config.onCorrectionClick
+        ? EditorView.domEventHandlers({
+            click: (event, view) => {
+                const target = event.target;
+                if (target?.closest('button, a, input, textarea, select'))
+                    return false;
+                const pos = view.posAtCoords({ x: event.clientX, y: event.clientY });
+                if (pos === null)
+                    return false;
+                const match = wordAt(view, pos);
+                if (!match || match.word.length <= 1)
+                    return false;
+                void (async () => {
+                    if (await dictionary.check(match.word))
+                        return;
+                    const coords = view.coordsAtPos(match.from);
+                    if (!coords)
+                        return;
+                    const suggestions = (await dictionary.suggest(match.word))
+                        .slice(0, 8)
+                        .sort((a, b) => a.localeCompare(b));
+                    await config.onCorrectionClick?.({
+                        original: match.word,
+                        suggestions,
+                        position: { top: coords.top, left: coords.left },
+                    }, view, match.from, match.to);
+                })();
+                return true;
+            },
+        })
+        : null;
+    return [
+        linter(lintSource, {
+            delay: 300,
+        }),
+        ...(clickHandler ? [clickHandler] : []),
+    ];
 }

package/dist/editor/extensions/spellcheck.test.js

@@ -0,0 +1,168 @@
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { spellcheck, extractWords } from './spellcheck';
+function createMockDictionary(knownWords = []) {
+    const words = new Set(knownWords.map((w) => w.toLowerCase()));
+    const personalWords = [];
+    return {
+        check: (word) => words.has(word.toLowerCase()) || personalWords.includes(word.toLowerCase()),
+        suggest: (word) => {
+            const lower = word.toLowerCase();
+            return knownWords
+                .filter((w) => w.toLowerCase() !== lower && w.toLowerCase().startsWith(lower.charAt(0)))
+                .slice(0, 5);
+        },
+        addWord: (word) => {
+            personalWords.push(word.toLowerCase());
+        },
+    };
+}
+function createView(doc, dictionary) {
+    return new EditorView({
+        state: EditorState.create({
+            doc,
+            extensions: [spellcheck(dictionary)],
+        }),
+        parent: document.body,
+    });
+}
+describe('extractWords', () => {
+    it('extracts a single word', () => {
+        const result = extractWords('hello');
+        expect(result).toEqual([{ word: 'hello', from: 0, to: 5 }]);
+    });
+    it('extracts multiple words separated by spaces', () => {
+        const result = extractWords('hello world');
+        expect(result).toEqual([
+            { word: 'hello', from: 0, to: 5 },
+            { word: 'world', from: 6, to: 11 },
+        ]);
+    });
+    it('skips non-alpha characters', () => {
+        const result = extractWords('hello 123 world');
+        expect(result).toEqual([
+            { word: 'hello', from: 0, to: 5 },
+            { word: 'world', from: 10, to: 15 },
+        ]);
+    });
+    it('handles empty string', () => {
+        expect(extractWords('')).toEqual([]);
+    });
+    it('handles string with no alpha characters', () => {
+        expect(extractWords('123 456 !@#')).toEqual([]);
+    });
+    it('includes apostrophes in words', () => {
+        const result = extractWords("don't");
+        expect(result).toEqual([{ word: "don't", from: 0, to: 5 }]);
+    });
+    it('respects maxWords limit', () => {
+        const text = 'a b c d e f g h i j';
+        const result = extractWords(text, 3);
+        expect(result.length).toBe(3);
+    });
+    it('tracks correct from/to positions', () => {
+        const result = extractWords('  hello  world  ');
+        expect(result).toEqual([
+            { word: 'hello', from: 2, to: 7 },
+            { word: 'world', from: 9, to: 14 },
+        ]);
+    });
+    it('handles single character words', () => {
+        const result = extractWords('a b c');
+        expect(result).toEqual([
+            { word: 'a', from: 0, to: 1 },
+            { word: 'b', from: 2, to: 3 },
+            { word: 'c', from: 4, to: 5 },
+        ]);
+    });
+    it('handles mixed case', () => {
+        const result = extractWords('Hello WORLD');
+        expect(result).toEqual([
+            { word: 'Hello', from: 0, to: 5 },
+            { word: 'WORLD', from: 6, to: 11 },
+        ]);
+    });
+});
+describe('spellcheck', () => {
+    let view;
+    afterEach(() => {
+        if (view)
+            view.destroy();
+    });
+    it('returns an array of extensions', () => {
+        const dict = createMockDictionary(['hello']);
+        const exts = spellcheck(dict);
+        expect(Array.isArray(exts)).toBe(true);
+        expect(exts.length).toBeGreaterThan(0);
+    });
+    it('returns a linter extension', () => {
+        const dict = createMockDictionary(['hello']);
+        const exts = spellcheck(dict);
+        expect(exts.length).toBe(1);
+    });
+    it('includes click handler when onCorrectionClick is provided', () => {
+        const dict = createMockDictionary(['hello']);
+        const exts = spellcheck(dict, { onCorrectionClick: vi.fn() });
+        expect(exts.length).toBe(2);
+    });
+    it('works with empty document', () => {
+        const dict = createMockDictionary(['hello']);
+        view = createView('', dict);
+        expect(view.state.doc.toString()).toBe('');
+    });
+    it('works with known words only', () => {
+        const dict = createMockDictionary(['hello', 'world']);
+        view = createView('hello world', dict);
+        expect(view.state.doc.toString()).toBe('hello world');
+    });
+    it('works with unknown words', () => {
+        const dict = createMockDictionary(['hello']);
+        view = createView('hello xyzzy', dict);
+        expect(view.state.doc.toString()).toBe('hello xyzzy');
+    });
+    it('accepts a SpellCheckDictionary interface', () => {
+        const dict = {
+            check: () => true,
+            suggest: () => [],
+            addWord: () => { },
+        };
+        const exts = spellcheck(dict);
+        expect(exts.length).toBeGreaterThan(0);
+    });
+    it('accepts async check and suggest', () => {
+        const dict = {
+            check: async (word) => word === 'hello',
+            suggest: async (word) => ['help', 'hell'],
+            addWord: () => { },
+        };
+        const exts = spellcheck(dict);
+        expect(exts.length).toBeGreaterThan(0);
+    });
+    it('dictionary.addWord adds to personal dictionary', () => {
+        const dict = createMockDictionary(['hello']);
+        dict.addWord('xyzzy');
+        expect(dict.check('xyzzy')).toBe(true);
+    });
+    it('dictionary.suggest returns results', () => {
+        const dict = createMockDictionary(['help', 'heap', 'heel']);
+        const suggestions = dict.suggest('hel');
+        expect(suggestions.length).toBeGreaterThan(0);
+        expect(suggestions.every((s) => s.startsWith('h'))).toBe(true);
+    });
+    it('spellcheck with no config defaults to no click handler', () => {
+        const dict = createMockDictionary(['test']);
+        const exts = spellcheck(dict, {});
+        expect(exts.length).toBe(1);
+    });
+    it('handles text with punctuation', () => {
+        const dict = createMockDictionary(['hello']);
+        view = createView('hello, world!', dict);
+        expect(view.state.doc.toString()).toBe('hello, world!');
+    });
+    it('handles multiline text', () => {
+        const dict = createMockDictionary(['hello', 'world']);
+        view = createView('hello\nworld', dict);
+        expect(view.state.doc.toString()).toBe('hello\nworld');
+    });
+});

package/dist/editor/extensions/types.d.ts

@@ -1,3 +1,4 @@
+export { type Completion, type CompletionSource } from './autocomplete';
 export { type ExpansionDictionary } from './expansion';
-export { type SpellCheckDictionary } from './spellcheck';
+export { type SpellCheckCorrection, type SpellCheckConfig, type SpellCheckDictionary } from './spellcheck';
 //# sourceMappingURL=types.d.ts.map

package/dist/editor/extensions/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/editor/extensions/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/editor/extensions/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,KAAK,oBAAoB,EAAE,KAAK,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,MAAM,cAAc,CAAC"}

package/dist/editor/index.d.ts

@@ -1,9 +1,10 @@
 export { default as MarkdownEditor } from './MarkdownEditor.svelte';
 export { default as CodeEditor } from './CodeEditor.svelte';
+export { default as CorrectionTooltip } from './components/CorrectionTooltip.svelte';
 export { autoFormat } from './extensions/autoformat';
 export { expansion } from './extensions/expansion';
 export { autocomplete } from './extensions/autocomplete';
 export { spellcheck } from './extensions/spellcheck';
 export { type ExpansionDictionary } from './extensions/expansion';
-export type { SpellCheckDictionary } from './extensions/spellcheck';
+export type { SpellCheckCorrection, SpellCheckConfig, SpellCheckDictionary } from './extensions/spellcheck';
 //# sourceMappingURL=index.d.ts.map

package/dist/editor/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,YAAY,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,YAAY,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/editor/index.js

@@ -1,5 +1,6 @@
 export { default as MarkdownEditor } from './MarkdownEditor.svelte';
 export { default as CodeEditor } from './CodeEditor.svelte';
+export { default as CorrectionTooltip } from './components/CorrectionTooltip.svelte';
 export { autoFormat } from './extensions/autoformat';
 export { expansion } from './extensions/expansion';
 export { autocomplete } from './extensions/autocomplete';

package/dist/editor/markdown-preview.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Minimal inline markdown → HTML conversion for the editor's preview pane.
+ *
+ * Intentionally lightweight (headings, bold/italic, inline code, list items,
+ * line breaks) — not a full CommonMark renderer. Extracted from
+ * MarkdownEditor.svelte so it can be unit-tested in isolation.
+ */
+export declare function markdownToHtml(md: string): string;
+//# sourceMappingURL=markdown-preview.d.ts.map

package/dist/editor/markdown-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-preview.d.ts","sourceRoot":"","sources":["../../src/editor/markdown-preview.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAWjD"}

package/dist/editor/markdown-preview.js

@@ -0,0 +1,19 @@
+/**
+ * Minimal inline markdown → HTML conversion for the editor's preview pane.
+ *
+ * Intentionally lightweight (headings, bold/italic, inline code, list items,
+ * line breaks) — not a full CommonMark renderer. Extracted from
+ * MarkdownEditor.svelte so it can be unit-tested in isolation.
+ */
+export function markdownToHtml(md) {
+    return md
+        .replace(/^### (.*$)/gim, '<h3>$1</h3>')
+        .replace(/^## (.*$)/gim, '<h2>$1</h2>')
+        .replace(/^# (.*$)/gim, '<h1>$1</h1>')
+        .replace(/\*\*(.*?)\*\*/gim, '<strong>$1</strong>')
+        .replace(/\*(.*?)\*/gim, '<em>$1</em>')
+        .replace(/`([^`]+)`/gim, '<code>$1</code>')
+        .replace(/^- (.*$)/gim, '<li>$1</li>')
+        .replace(/(<li>.*<\/li>)/s, '<ul>$1</ul>')
+        .replace(/\n/gim, '<br>');
+}

package/dist/editor/markdown-preview.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { markdownToHtml } from './markdown-preview';
+describe('editor/markdownToHtml', () => {
+    it('returns an empty string for empty input', () => {
+        expect(markdownToHtml('')).toBe('');
+    });
+    it('converts h1/h2/h3 headings', () => {
+        expect(markdownToHtml('# Title')).toBe('<h1>Title</h1>');
+        expect(markdownToHtml('## Title')).toBe('<h2>Title</h2>');
+        expect(markdownToHtml('### Title')).toBe('<h3>Title</h3>');
+    });
+    it('converts bold and italic', () => {
+        expect(markdownToHtml('**bold**')).toBe('<strong>bold</strong>');
+        expect(markdownToHtml('*italic*')).toBe('<em>italic</em>');
+    });
+    it('converts inline code', () => {
+        expect(markdownToHtml('`code`')).toBe('<code>code</code>');
+    });
+    it('wraps a run of list items in a <ul>', () => {
+        const html = markdownToHtml('- a\n- b');
+        expect(html).toContain('<ul>');
+        expect(html).toContain('<li>a</li>');
+        expect(html).toContain('<li>b</li>');
+    });
+    it('converts newlines to <br>', () => {
+        expect(markdownToHtml('line1\nline2')).toBe('line1<br>line2');
+    });
+    it('leaves plain text untouched', () => {
+        expect(markdownToHtml('just text')).toBe('just text');
+    });
+    it('handles mixed content', () => {
+        const html = markdownToHtml('# Heading\nSome **bold** and `code`.');
+        expect(html).toContain('<h1>Heading</h1>');
+        expect(html).toContain('<strong>bold</strong>');
+        expect(html).toContain('<code>code</code>');
+        expect(html).toContain('<br>');
+    });
+});

package/dist/editor/useCodeMirror.d.ts

@@ -0,0 +1,23 @@
+import { EditorView } from '@codemirror/view';
+import type { CompletionSource } from './extensions/autocomplete';
+import type { SpellCheckCorrection, SpellCheckDictionary } from './extensions/spellcheck';
+export interface UseCodeMirrorOptions {
+    getContainer: () => HTMLDivElement;
+    getInitialContent: () => string;
+    completionSource: () => CompletionSource | undefined;
+    spellCheckDictionary: () => SpellCheckDictionary | undefined;
+    onCorrectionClick: (correction: SpellCheckCorrection, view: EditorView, from: number, to: number) => void;
+    onSave: () => void;
+    onFind: () => void;
+    onFindReplace: () => void;
+    onDocChanged: (content: string) => void;
+    onEditorReady?: (view: EditorView) => void;
+    onEditorDestroy?: () => void;
+}
+export interface UseCodeMirrorApi {
+    getView: () => EditorView | null;
+    syncContent: (content: string) => void;
+    focus: () => void;
+}
+export declare function useCodeMirror(options: UseCodeMirrorOptions): UseCodeMirrorApi;
+//# sourceMappingURL=useCodeMirror.d.ts.map

package/dist/editor/useCodeMirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCodeMirror.d.ts","sourceRoot":"","sources":["../../src/editor/useCodeMirror.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE1F,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,cAAc,CAAC;IACnC,iBAAiB,EAAE,MAAM,MAAM,CAAC;IAChC,gBAAgB,EAAE,MAAM,gBAAgB,GAAG,SAAS,CAAC;IACrD,oBAAoB,EAAE,MAAM,oBAAoB,GAAG,SAAS,CAAC;IAC7D,iBAAiB,EAAE,CAAC,UAAU,EAAE,oBAAoB,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1G,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IAC3C,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,UAAU,GAAG,IAAI,CAAC;IACjC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,gBAAgB,CAwC7E"}

package/dist/editor/useCodeMirror.js

@@ -0,0 +1,40 @@
+import { onDestroy, onMount } from 'svelte';
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { buildExtensions } from './codemirror-config';
+export function useCodeMirror(options) {
+    let view = null;
+    function destroyView() {
+        view?.destroy();
+        view = null;
+        options.onEditorDestroy?.();
+    }
+    onMount(() => {
+        const extensions = buildExtensions({
+            completionSource: options.completionSource(),
+            spellCheckDictionary: options.spellCheckDictionary(),
+            onCorrectionClick: options.onCorrectionClick,
+            onSave: options.onSave,
+            onFind: options.onFind,
+            onFindReplace: options.onFindReplace,
+            onDocChanged: options.onDocChanged
+        });
+        view = new EditorView({
+            state: EditorState.create({ doc: options.getInitialContent(), extensions }),
+            parent: options.getContainer()
+        });
+        options.onEditorReady?.(view);
+    });
+    onDestroy(destroyView);
+    return {
+        getView: () => view,
+        syncContent(content) {
+            if (!view || content === view.state.doc.toString())
+                return;
+            view.dispatch({ changes: { from: 0, to: view.state.doc.length, insert: content } });
+        },
+        focus() {
+            view?.focus();
+        }
+    };
+}

package/dist/editor/useFilePersistence.d.ts

@@ -0,0 +1,32 @@
+import { EditorView } from '@codemirror/view';
+export interface UseFilePersistenceOptions {
+    getFilePath: () => string | null;
+    getContent: () => string;
+    getIsDirty: () => boolean;
+    getIsSaving: () => boolean;
+    getIsCheckingExternalChanges: () => boolean;
+    getShowExternalChangeDialog: () => boolean;
+    getLastKnownMtimeMs: () => number | null;
+    getEditorView: () => EditorView | null;
+    setContent: (content: string) => void;
+    setIsDirty: (dirty: boolean) => void;
+    setIsSaving: (saving: boolean) => void;
+    setSaveError: (error: string | null) => void;
+    setShowExternalChangeDialog: (show: boolean) => void;
+    setIsCheckingExternalChanges: (checking: boolean) => void;
+    setLastKnownMtimeMs: (mtime: number | null) => void;
+    onChange?: (content: string) => void;
+    onSave?: () => void;
+    onExternalChange?: (content: string) => void;
+}
+export interface UseFilePersistenceApi {
+    persistenceAvailable: boolean;
+    startExternalChangeMonitoring: () => () => void;
+    stopExternalChangeMonitoring: () => void;
+    checkExternalChanges: () => Promise<void>;
+    saveContent: () => Promise<void>;
+    reloadFromDisk: () => Promise<void>;
+    keepCurrent: () => void;
+}
+export declare function useFilePersistence(options: UseFilePersistenceOptions): UseFilePersistenceApi;
+//# sourceMappingURL=useFilePersistence.d.ts.map

package/dist/editor/useFilePersistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFilePersistence.d.ts","sourceRoot":"","sources":["../../src/editor/useFilePersistence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACjC,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,4BAA4B,EAAE,MAAM,OAAO,CAAC;IAC5C,2BAA2B,EAAE,MAAM,OAAO,CAAC;IAC3C,mBAAmB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACzC,aAAa,EAAE,MAAM,UAAU,GAAG,IAAI,CAAC;IACvC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACrC,WAAW,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC7C,2BAA2B,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACrD,4BAA4B,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1D,mBAAmB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACpD,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C;AAED,MAAM,WAAW,qBAAqB;IACpC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,6BAA6B,EAAE,MAAM,MAAM,IAAI,CAAC;IAChD,4BAA4B,EAAE,MAAM,IAAI,CAAC;IACzC,oBAAoB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,qBAAqB,CAmH5F"}