@akinon/ui-editor 1.0.3 → 1.0.4

package/dist/esm/tiptap/types/index.d.ts

@@ -93,13 +93,13 @@ export interface ToolbarConfig {
      * - `history` - Undo and redo actions
      * - `alignment` - Text alignment options (left, center, right, justify)
      *
-     * @example
+     * **Example:**
      * ```tsx
      * // Hide all formatting and media buttons
      * toolbar={{ hiddenGroups: ['formatting', 'media'] }}
      * ```
      *
-     * @example
+     * **Example:**
      * ```tsx
      * // Keep only basic text editing (hide media and alignment)
      * toolbar={{ hiddenGroups: ['media', 'alignment'] }}
@@ -131,6 +131,11 @@ export interface TextEditorProps {
      * @default false
      */
     readOnly?: boolean;
+    /**
+     * Sets a maximum height for the editor content area. If the content exceeds this height, it becomes scrollable.
+     * @default 400
+     */
+    contentHeight?: number;
     /**
      * Custom class names for different parts of the editor.
      * Use this to apply custom styling to specific editor sections.
@@ -158,6 +163,8 @@ export interface TextEditorProps {
         editorContent?: string;
         /** Class name for the toolbar container */
         editorToolbar?: string;
+        /** Class name for the source mode wrapper (if source mode is enabled) */
+        editorSourceModeWrapper?: string;
     };
     /**
      * Configuration object to customize the toolbar visibility.
@@ -181,19 +188,19 @@ export interface TextEditorProps {
      * - `history` - Undo and redo actions
      * - `alignment` - Text alignment options (left, center, right, justify)
      *
-     * @example
+     * **Example:**
      * ```tsx
      * // Hide specific formatting buttons
      * <AkiTextEditor toolbar={{ hiddenButtons: ['bold', 'italic'] }} />
      * ```
      *
-     * @example
+     * **Example:**
      * ```tsx
      * // Hide entire groups
      * <AkiTextEditor toolbar={{ hiddenGroups: ['formatting', 'media'] }} />
      * ```
      *
-     * @example
+     * **Example:**
      * ```tsx
      * // Combine both for fine-grained control
      * <AkiTextEditor

package/dist/esm/tiptap/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tiptap/types/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tiptap/types/index.ts"],"names":[],"mappings":"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"}

package/dist/esm/tiptap/utils/__tests__/clean-html.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=clean-html.test.d.ts.map

package/dist/esm/tiptap/utils/__tests__/clean-html.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean-html.test.d.ts","sourceRoot":"","sources":["../../../../../src/tiptap/utils/__tests__/clean-html.test.ts"],"names":[],"mappings":""}

package/dist/esm/tiptap/utils/__tests__/clean-html.test.js

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import { cleanDuplicateSpans } from '../clean-html';
+describe('clean-html', () => {
+    it('should return html as is in non-browser environment', () => {
+        // Simulate non-browser environment
+        // Note: This relies on how cleanDuplicateSpans checks for window/DOMParser
+        const originalWindow = global.window;
+        // @ts-expect-error Testing environment specific behavior
+        delete global.window;
+        const html = '<div>test</div>';
+        expect(cleanDuplicateSpans(html)).toBe(html);
+        global.window = originalWindow;
+    });
+    it('should remove empty spans', () => {
+        const html = '<div><span></span>Content<span> </span></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div>Content</div>');
+    });
+    it('should unwrap spans with no attributes', () => {
+        const html = '<div><span>Content</span></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div>Content</div>');
+    });
+    it('should merge nested spans with same styles', () => {
+        const html = '<div><span style="color: red;"><span style="color: red;">Content</span></span></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div><span style="color: red;">Content</span></div>');
+    });
+    it('should unwrap parent span if it has no styles but child does', () => {
+        const html = '<div><span><span style="color: red;">Content</span></span></div>';
+        const result = cleanDuplicateSpans(html);
+        // First expected: Inner content preserved
+        // The logic: parent span has no attributes -> unwrap parent -> result is child span
+        expect(result).toBe('<div><span style="color: red;">Content</span></div>');
+    });
+    it('should not merge spans with different styles', () => {
+        const html = '<div><span style="color: blue;"><span style="color: red;">Content</span></span></div>';
+        const result = cleanDuplicateSpans(html);
+        // Should keep both or just behave normally.
+        // Our logic only merges if styles are identical or parent has no style.
+        expect(result).toContain('color: blue');
+        expect(result).toContain('color: red');
+    });
+    it('should handle complex nesting', () => {
+        const html = '<div><span style="color: red;"><span style="color: red;">Red</span></span> <span style="font-weight: bold">Bold</span></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div><span style="color: red;">Red</span> <span style="font-weight: bold">Bold</span></div>');
+    });
+    it('should handle rgb colors (no conversion)', () => {
+        const html = '<div><span style="color: rgb(255, 0, 0);">Red</span></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div><span style="color: rgb(255, 0, 0);">Red</span></div>');
+    });
+    it('should unwrap parent span if it has other attributes but no style', () => {
+        const html = '<div><span class="foo"><span style="color: red;">Content</span></span></div>';
+        const result = cleanDuplicateSpans(html);
+        // Parent unwrapped because !parentStyle check passes
+        expect(result).toBe('<div><span style="color: red;">Content</span></div>');
+    });
+    it('should not merge if parent has style but child has none', () => {
+        const html = '<div><span style="color: red;"><span class="inner">Content</span></span></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div><span style="color: red;"><span class="inner">Content</span></span></div>');
+    });
+    it('should preserve script tags with type="text/inert"', () => {
+        const html = '<div><script type="text/inert">console.log("test")</script></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div><script type="text/inert">console.log("test")</script></div>');
+    });
+    it('should preserve script tags without type attribute', () => {
+        const html = '<div><script>console.log("test")</script></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div><script>console.log("test")</script></div>');
+    });
+    it('should preserve script tags and clean spans together', () => {
+        const html = '<div><span></span><script>console.log("test")</script><span>Content</span></div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div><script>console.log("test")</script>Content</div>');
+    });
+    it('should handle mixed content with text nodes', () => {
+        // This test covers line 87: return node.textContent || '';
+        // Testing text nodes between elements
+        const html = '<div>Start<p>Middle</p>End</div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div>Start<p>Middle</p>End</div>');
+    });
+    it('should handle empty text content fallback', () => {
+        // Edge case: elements with only whitespace text nodes
+        const html = '<div>   </div>';
+        const result = cleanDuplicateSpans(html);
+        expect(result).toBe('<div>   </div>');
+    });
+});

package/dist/esm/tiptap/utils/__tests__/clean-html.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest';
+
+import { cleanDuplicateSpans } from '../clean-html';
+
+describe('clean-html', () => {
+  it('should return html as is in non-browser environment', () => {
+    // Simulate non-browser environment
+    // Note: This relies on how cleanDuplicateSpans checks for window/DOMParser
+    const originalWindow = global.window;
+    // @ts-expect-error Testing environment specific behavior
+    delete global.window;
+
+    const html = '<div>test</div>';
+    expect(cleanDuplicateSpans(html)).toBe(html);
+
+    global.window = originalWindow;
+  });
+
+  it('should remove empty spans', () => {
+    const html = '<div><span></span>Content<span> </span></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe('<div>Content</div>');
+  });
+
+  it('should unwrap spans with no attributes', () => {
+    const html = '<div><span>Content</span></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe('<div>Content</div>');
+  });
+
+  it('should merge nested spans with same styles', () => {
+    const html =
+      '<div><span style="color: red;"><span style="color: red;">Content</span></span></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe('<div><span style="color: red;">Content</span></div>');
+  });
+
+  it('should unwrap parent span if it has no styles but child does', () => {
+    const html =
+      '<div><span><span style="color: red;">Content</span></span></div>';
+    const result = cleanDuplicateSpans(html);
+    // First expected: Inner content preserved
+    // The logic: parent span has no attributes -> unwrap parent -> result is child span
+    expect(result).toBe('<div><span style="color: red;">Content</span></div>');
+  });
+
+  it('should not merge spans with different styles', () => {
+    const html =
+      '<div><span style="color: blue;"><span style="color: red;">Content</span></span></div>';
+    const result = cleanDuplicateSpans(html);
+    // Should keep both or just behave normally.
+    // Our logic only merges if styles are identical or parent has no style.
+    expect(result).toContain('color: blue');
+    expect(result).toContain('color: red');
+  });
+
+  it('should handle complex nesting', () => {
+    const html =
+      '<div><span style="color: red;"><span style="color: red;">Red</span></span> <span style="font-weight: bold">Bold</span></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe(
+      '<div><span style="color: red;">Red</span> <span style="font-weight: bold">Bold</span></div>'
+    );
+  });
+
+  it('should handle rgb colors (no conversion)', () => {
+    const html = '<div><span style="color: rgb(255, 0, 0);">Red</span></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe(
+      '<div><span style="color: rgb(255, 0, 0);">Red</span></div>'
+    );
+  });
+
+  it('should unwrap parent span if it has other attributes but no style', () => {
+    const html =
+      '<div><span class="foo"><span style="color: red;">Content</span></span></div>';
+    const result = cleanDuplicateSpans(html);
+    // Parent unwrapped because !parentStyle check passes
+    expect(result).toBe('<div><span style="color: red;">Content</span></div>');
+  });
+
+  it('should not merge if parent has style but child has none', () => {
+    const html =
+      '<div><span style="color: red;"><span class="inner">Content</span></span></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe(
+      '<div><span style="color: red;"><span class="inner">Content</span></span></div>'
+    );
+  });
+
+  it('should preserve script tags with type="text/inert"', () => {
+    const html =
+      '<div><script type="text/inert">console.log("test")</script></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe(
+      '<div><script type="text/inert">console.log("test")</script></div>'
+    );
+  });
+
+  it('should preserve script tags without type attribute', () => {
+    const html = '<div><script>console.log("test")</script></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe('<div><script>console.log("test")</script></div>');
+  });
+
+  it('should preserve script tags and clean spans together', () => {
+    const html =
+      '<div><span></span><script>console.log("test")</script><span>Content</span></div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe(
+      '<div><script>console.log("test")</script>Content</div>'
+    );
+  });
+
+  it('should handle mixed content with text nodes', () => {
+    // This test covers line 87: return node.textContent || '';
+    // Testing text nodes between elements
+    const html = '<div>Start<p>Middle</p>End</div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe('<div>Start<p>Middle</p>End</div>');
+  });
+
+  it('should handle empty text content fallback', () => {
+    // Edge case: elements with only whitespace text nodes
+    const html = '<div>   </div>';
+    const result = cleanDuplicateSpans(html);
+    expect(result).toBe('<div>   </div>');
+  });
+});

package/dist/esm/tiptap/utils/__tests__/data-attributes-helper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-attributes-helper.test.d.ts.map

package/dist/esm/tiptap/utils/__tests__/data-attributes-helper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-attributes-helper.test.d.ts","sourceRoot":"","sources":["../../../../../src/tiptap/utils/__tests__/data-attributes-helper.test.ts"],"names":[],"mappings":""}

package/dist/esm/tiptap/utils/__tests__/data-attributes-helper.test.js

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+import { addDataAttributesToParent, createDataAttributesConfig, extractDataAttributes } from '../data-attributes-helper';
+describe('data-attributes-helper', () => {
+    describe('createDataAttributesConfig', () => {
+        const config = createDataAttributesConfig();
+        it('should parse data attributes from HTML element', () => {
+            const element = document.createElement('div');
+            element.setAttribute('data-test', 'value');
+            element.setAttribute('class', 'ignore-me');
+            const result = config.dataAttributes.parseHTML(element);
+            expect(result).toEqual({ 'data-test': 'value' });
+        });
+        it('should return empty object if no data attributes present', () => {
+            const element = document.createElement('div');
+            element.setAttribute('class', 'ignore-me');
+            const result = config.dataAttributes.parseHTML(element);
+            expect(result).toEqual({});
+        });
+        it('should render data attributes correctly', () => {
+            const result = config.dataAttributes.renderHTML({
+                dataAttributes: { 'data-foo': 'bar' }
+            });
+            expect(result).toEqual({ 'data-foo': 'bar' });
+        });
+        it('should handle undefined dataAttributes in renderHTML', () => {
+            const result = config.dataAttributes.renderHTML({});
+            expect(result).toEqual({});
+        });
+    });
+    describe('extractDataAttributes', () => {
+        it('should extract data attributes and separate others', () => {
+            const attrs = {
+                dataAttributes: { 'data-foo': 'bar' },
+                other: 'value'
+            };
+            const { dataAttributes, otherAttrs } = extractDataAttributes(attrs);
+            expect(dataAttributes).toEqual({ 'data-foo': 'bar' });
+            expect(otherAttrs).toEqual({ other: 'value' });
+        });
+        it('should handle missing data attributes', () => {
+            const attrs = { other: 'value' };
+            const { dataAttributes, otherAttrs } = extractDataAttributes(attrs);
+            expect(dataAttributes).toEqual({});
+            expect(otherAttrs).toEqual({ other: 'value' });
+        });
+    });
+    describe('addDataAttributesToParent', () => {
+        const config = addDataAttributesToParent(() => ({
+            default: 'value'
+        }));
+        // Helper to get methods safely
+        const getMethods = (key) => config[key];
+        it('should include parent attributes', () => {
+            expect(config.default).toBe('value');
+        });
+        describe('class attribute', () => {
+            const methods = getMethods('class');
+            it('should parse class attribute', () => {
+                const element = document.createElement('div');
+                element.setAttribute('class', 'test-class');
+                expect(methods.parseHTML(element)).toBe('test-class');
+            });
+            it('should render class attribute', () => {
+                expect(methods.renderHTML({ class: 'test-class' })).toEqual({
+                    class: 'test-class'
+                });
+            });
+            it('should return empty object if class missing', () => {
+                expect(methods.renderHTML({})).toEqual({});
+            });
+        });
+        describe('id attribute', () => {
+            const methods = getMethods('id');
+            it('should parse id attribute', () => {
+                const element = document.createElement('div');
+                element.setAttribute('id', 'test-id');
+                expect(methods.parseHTML(element)).toBe('test-id');
+            });
+            it('should render id attribute', () => {
+                expect(methods.renderHTML({ id: 'test-id' })).toEqual({
+                    id: 'test-id'
+                });
+            });
+            it('should return empty object if id missing', () => {
+                expect(methods.renderHTML({})).toEqual({});
+            });
+        });
+        describe('style attribute', () => {
+            const methods = getMethods('style');
+            it('should parse style attribute', () => {
+                const element = document.createElement('div');
+                element.setAttribute('style', 'color: red');
+                expect(methods.parseHTML(element)).toBe('color: red');
+            });
+            it('should render style attribute', () => {
+                expect(methods.renderHTML({ style: 'color: red' })).toEqual({
+                    style: 'color: red'
+                });
+            });
+            it('should return empty object if style missing', () => {
+                expect(methods.renderHTML({})).toEqual({});
+            });
+        });
+    });
+});

package/dist/esm/tiptap/utils/__tests__/data-attributes-helper.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  addDataAttributesToParent,
+  createDataAttributesConfig,
+  extractDataAttributes
+} from '../data-attributes-helper';
+
+describe('data-attributes-helper', () => {
+  describe('createDataAttributesConfig', () => {
+    const config = createDataAttributesConfig();
+
+    it('should parse data attributes from HTML element', () => {
+      const element = document.createElement('div');
+      element.setAttribute('data-test', 'value');
+      element.setAttribute('class', 'ignore-me');
+
+      const result = config.dataAttributes.parseHTML(element);
+
+      expect(result).toEqual({ 'data-test': 'value' });
+    });
+
+    it('should return empty object if no data attributes present', () => {
+      const element = document.createElement('div');
+      element.setAttribute('class', 'ignore-me');
+
+      const result = config.dataAttributes.parseHTML(element);
+
+      expect(result).toEqual({});
+    });
+
+    it('should render data attributes correctly', () => {
+      const result = config.dataAttributes.renderHTML({
+        dataAttributes: { 'data-foo': 'bar' }
+      });
+      expect(result).toEqual({ 'data-foo': 'bar' });
+    });
+
+    it('should handle undefined dataAttributes in renderHTML', () => {
+      const result = config.dataAttributes.renderHTML({});
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('extractDataAttributes', () => {
+    it('should extract data attributes and separate others', () => {
+      const attrs = {
+        dataAttributes: { 'data-foo': 'bar' },
+        other: 'value'
+      };
+
+      const { dataAttributes, otherAttrs } = extractDataAttributes(attrs);
+
+      expect(dataAttributes).toEqual({ 'data-foo': 'bar' });
+      expect(otherAttrs).toEqual({ other: 'value' });
+    });
+
+    it('should handle missing data attributes', () => {
+      const attrs = { other: 'value' };
+      const { dataAttributes, otherAttrs } = extractDataAttributes(attrs);
+
+      expect(dataAttributes).toEqual({});
+      expect(otherAttrs).toEqual({ other: 'value' });
+    });
+  });
+
+  describe('addDataAttributesToParent', () => {
+    interface AttributeConfig {
+      default: unknown;
+      parseHTML: (element: HTMLElement) => unknown;
+      renderHTML: (
+        attributes: Record<string, unknown>
+      ) => Record<string, unknown>;
+    }
+
+    const config = addDataAttributesToParent(() => ({
+      default: 'value'
+    })) as Record<string, unknown>;
+
+    // Helper to get methods safely
+    const getMethods = (key: string): AttributeConfig =>
+      config[key] as AttributeConfig;
+
+    it('should include parent attributes', () => {
+      expect(config.default).toBe('value');
+    });
+
+    describe('class attribute', () => {
+      const methods = getMethods('class');
+
+      it('should parse class attribute', () => {
+        const element = document.createElement('div');
+        element.setAttribute('class', 'test-class');
+        expect(methods.parseHTML(element)).toBe('test-class');
+      });
+
+      it('should render class attribute', () => {
+        expect(methods.renderHTML({ class: 'test-class' })).toEqual({
+          class: 'test-class'
+        });
+      });
+
+      it('should return empty object if class missing', () => {
+        expect(methods.renderHTML({})).toEqual({});
+      });
+    });
+
+    describe('id attribute', () => {
+      const methods = getMethods('id');
+
+      it('should parse id attribute', () => {
+        const element = document.createElement('div');
+        element.setAttribute('id', 'test-id');
+        expect(methods.parseHTML(element)).toBe('test-id');
+      });
+
+      it('should render id attribute', () => {
+        expect(methods.renderHTML({ id: 'test-id' })).toEqual({
+          id: 'test-id'
+        });
+      });
+
+      it('should return empty object if id missing', () => {
+        expect(methods.renderHTML({})).toEqual({});
+      });
+    });
+
+    describe('style attribute', () => {
+      const methods = getMethods('style');
+
+      it('should parse style attribute', () => {
+        const element = document.createElement('div');
+        element.setAttribute('style', 'color: red');
+        expect(methods.parseHTML(element)).toBe('color: red');
+      });
+
+      it('should render style attribute', () => {
+        expect(methods.renderHTML({ style: 'color: red' })).toEqual({
+          style: 'color: red'
+        });
+      });
+
+      it('should return empty object if style missing', () => {
+        expect(methods.renderHTML({})).toEqual({});
+      });
+    });
+  });
+});

package/dist/esm/tiptap/utils/__tests__/index.test.js

@@ -2,9 +2,7 @@ import { describe, expect, it } from 'vitest';
 import * as index from '../index';
 describe('tiptap/utils/index', () => {
     it('should export all required modules', () => {
-        expect(index).toHaveProperty('formatHtml');
         expect(index).toHaveProperty('highlightHtml');
-        expect(index).toHaveProperty('normalizeHtml');
         expect(index).toHaveProperty('getExtensions');
         expect(index).toHaveProperty('handleImageFile');
         expect(index).toHaveProperty('validateLink');

package/dist/esm/tiptap/utils/__tests__/index.test.ts

@@ -4,9 +4,7 @@ import * as index from '../index';
 
 describe('tiptap/utils/index', () => {
   it('should export all required modules', () => {
-    expect(index).toHaveProperty('formatHtml');
     expect(index).toHaveProperty('highlightHtml');
-    expect(index).toHaveProperty('normalizeHtml');
     expect(index).toHaveProperty('getExtensions');
     expect(index).toHaveProperty('handleImageFile');
     expect(index).toHaveProperty('validateLink');

package/dist/esm/tiptap/utils/__tests__/prettier-format.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prettier-format.test.d.ts.map

package/dist/esm/tiptap/utils/__tests__/prettier-format.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettier-format.test.d.ts","sourceRoot":"","sources":["../../../../../src/tiptap/utils/__tests__/prettier-format.test.ts"],"names":[],"mappings":""}

package/dist/esm/tiptap/utils/__tests__/prettier-format.test.js

@@ -0,0 +1,33 @@
+import * as prettier from 'prettier/standalone';
+import { describe, expect, it, vi } from 'vitest';
+import { formatHtmlWithPrettier } from '../prettier-format';
+vi.mock('prettier/standalone', () => ({
+    format: vi.fn()
+}));
+vi.mock('prettier/plugins/html', async (importOriginal) => {
+    const mod = await importOriginal();
+    return Object.assign({}, mod);
+});
+describe('prettier-format', () => {
+    it('should format html successfully', async () => {
+        const input = '<div>  test  </div>';
+        const formatted = '<div>test</div>';
+        vi.mocked(prettier.format).mockResolvedValue(formatted);
+        const result = await formatHtmlWithPrettier(input);
+        expect(prettier.format).toHaveBeenCalledWith(input, expect.objectContaining({
+            parser: 'html',
+            printWidth: 60
+        }));
+        expect(result).toBe(formatted);
+    });
+    it('should return original html and warn when formatting fails', async () => {
+        const input = 'Invalid HTML';
+        const error = new Error('Parse error');
+        vi.mocked(prettier.format).mockRejectedValue(error);
+        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const result = await formatHtmlWithPrettier(input);
+        expect(result).toBe(input);
+        expect(consoleSpy).not.toHaveBeenCalled();
+        consoleSpy.mockRestore();
+    });
+});