Merge branch 'u/jisong/keyboardenter' into u/jisong/reconcilechildlist

microsoft · Jun 5, 2024 · 5491860 · 5491860
2 parents becf627 + 1f90c24
commit 5491860
Show file tree

Hide file tree

Showing 18 changed files with 2,542 additions and 47 deletions.
diff --git a/packages/roosterjs-content-model-core/lib/editor/Editor.ts b/packages/roosterjs-content-model-core/lib/editor/Editor.ts
@@ -32,6 +32,7 @@ import type {
     CachedElementHandler,
     DomToModelOptionForCreateModel,
     AnnounceData,
+    ExperimentalFeature,
 } from 'roosterjs-content-model-types';
 
 /**
@@ -406,6 +407,14 @@ export class Editor implements IEditor {
         core.api.announce(core, announceData);
     }
 
+    /**
+     * Check if a given feature is enabled
+     * @param featureName The name of feature to check
+     */
+    isExperimentalFeatureEnabled(featureName: ExperimentalFeature | string): boolean {
+        return this.getCore().experimentalFeatures.indexOf(featureName) >= 0;
+    }
+
     /**
      * @returns the current EditorCore object
      * @throws a standard Error if there's no core object

diff --git a/packages/roosterjs-content-model-core/test/command/paste/pasteTest.ts b/packages/roosterjs-content-model-core/test/command/paste/pasteTest.ts
@@ -136,7 +136,7 @@ describe('paste with content model & paste plugin', () => {
         paste(editor!, clipboardData);
 
         expect(setProcessorF.setProcessor).toHaveBeenCalledTimes(1);
-        expect(addParserF.addParser).toHaveBeenCalledTimes(DEFAULT_TIMES_ADD_PARSER_CALLED + 4);
+        expect(addParserF.addParser).toHaveBeenCalledTimes(DEFAULT_TIMES_ADD_PARSER_CALLED + 5);
         expect(WordDesktopFile.processPastedContentFromWordDesktop).toHaveBeenCalledTimes(1);
     });
 

diff --git a/packages/roosterjs-content-model-core/test/editor/EditorTest.ts b/packages/roosterjs-content-model-core/test/editor/EditorTest.ts
@@ -1116,4 +1116,36 @@ describe('Editor', () => {
         expect(resetSpy).toHaveBeenCalledWith();
         expect(() => editor.announce(mockedData)).toThrow();
     });
+
+    it('isExperimentalFeatureEnabled', () => {
+        const div = document.createElement('div');
+        const resetSpy = jasmine.createSpy('reset');
+        const mockedCore = {
+            plugins: [],
+            darkColorHandler: {
+                updateKnownColor: updateKnownColorSpy,
+                reset: resetSpy,
+            },
+            api: {
+                setContentModel: setContentModelSpy,
+            },
+            experimentalFeatures: ['Feature1', 'Feature2'],
+        } as any;
+
+        createEditorCoreSpy.and.returnValue(mockedCore);
+
+        const editor = new Editor(div);
+
+        const result1 = editor.isExperimentalFeatureEnabled('Feature1');
+        const result2 = editor.isExperimentalFeatureEnabled('Feature2');
+        const result3 = editor.isExperimentalFeatureEnabled('Feature3');
+
+        expect(result1).toBeTrue();
+        expect(result2).toBeTrue();
+        expect(result3).toBeFalse();
+
+        editor.dispose();
+        expect(resetSpy).toHaveBeenCalledWith();
+        expect(() => editor.isExperimentalFeatureEnabled('Feature4')).toThrow();
+    });
 });
diff --git a/packages/roosterjs-content-model-dom/lib/modelToDom/contentModelToDom.ts b/packages/roosterjs-content-model-dom/lib/modelToDom/contentModelToDom.ts
@@ -1,5 +1,6 @@
 import { isNodeOfType } from '../domUtils/isNodeOfType';
 import { toArray } from '../domUtils/toArray';
+import type { ContentModelDocumentWithPersistedCache } from '../modelApi/selection/iterateSelections';
 import type {
     ContentModelDocument,
     DOMSelection,
@@ -31,6 +32,10 @@ export function contentModelToDom(
         range.isReverted = true;
     }
 
+    if (context.domIndexer && context.allowCacheElement) {
+        (model as ContentModelDocumentWithPersistedCache).persistCache = true;
+    }
+
     root.normalize();
 
     return range;

diff --git a/packages/roosterjs-content-model-dom/test/modelApi/common/normalizeParagraphTest.ts b/packages/roosterjs-content-model-dom/test/modelApi/common/normalizeParagraphTest.ts
@@ -509,3 +509,304 @@ describe('Normalize paragraph with segmentFormat', () => {
         });
     });
 });
+
+describe('Move up format', () => {
+    const mockedCache = {} as any;
+
+    it('No format', () => {
+        const para = createParagraph();
+        const text1 = createText('test1');
+        const text2 = createText('test2');
+
+        para.segments.push(text1, text2);
+        para.cachedElement = mockedCache;
+
+        normalizeParagraph(para);
+
+        expect(para).toEqual({
+            blockType: 'Paragraph',
+            segments: [
+                {
+                    segmentType: 'Text',
+                    text: 'test1',
+                    format: {},
+                },
+                {
+                    segmentType: 'Text',
+                    text: 'test2',
+                    format: {},
+                },
+            ],
+            format: {},
+            cachedElement: mockedCache,
+        });
+    });
+
+    it('All segments have the same format', () => {
+        const para = createParagraph();
+        const text1 = createText('test1', {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: false,
+        });
+        const text2 = createText('test2', {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: true,
+        });
+
+        para.segments.push(text1, text2);
+        para.cachedElement = mockedCache;
+
+        normalizeParagraph(para);
+
+        expect(para).toEqual({
+            blockType: 'Paragraph',
+            segments: [
+                {
+                    segmentType: 'Text',
+                    text: 'test1',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '10pt',
+                        textColor: 'red',
+                        italic: false,
+                    },
+                },
+                {
+                    segmentType: 'Text',
+                    text: 'test2',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '10pt',
+                        textColor: 'red',
+                        italic: true,
+                    },
+                },
+            ],
+            format: {},
+            segmentFormat: {
+                fontFamily: 'Calibri',
+                fontSize: '10pt',
+                textColor: 'red',
+            },
+        });
+    });
+
+    it('All segments have the same format, paragraph has different format', () => {
+        const para = createParagraph(false, undefined, {
+            fontFamily: 'Arial',
+            fontSize: '12pt',
+            textColor: 'green',
+        });
+        const text1 = createText('test1', {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: false,
+        });
+        const text2 = createText('test2', {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: true,
+        });
+
+        para.segments.push(text1, text2);
+        para.cachedElement = mockedCache;
+
+        normalizeParagraph(para);
+
+        expect(para).toEqual({
+            blockType: 'Paragraph',
+            segments: [
+                {
+                    segmentType: 'Text',
+                    text: 'test1',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '10pt',
+                        textColor: 'red',
+                        italic: false,
+                    },
+                },
+                {
+                    segmentType: 'Text',
+                    text: 'test2',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '10pt',
+                        textColor: 'red',
+                        italic: true,
+                    },
+                },
+            ],
+            format: {},
+            segmentFormat: {
+                fontFamily: 'Calibri',
+                fontSize: '10pt',
+                textColor: 'red',
+            },
+        });
+    });
+
+    it('Some format are different', () => {
+        const para = createParagraph();
+        const text1 = createText('test1', {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: false,
+        });
+        const text2 = createText('test2', {
+            fontFamily: 'Calibri',
+            fontSize: '12pt',
+            textColor: 'red',
+            italic: true,
+        });
+
+        para.segments.push(text1, text2);
+        para.cachedElement = mockedCache;
+
+        normalizeParagraph(para);
+
+        expect(para).toEqual({
+            blockType: 'Paragraph',
+            segments: [
+                {
+                    segmentType: 'Text',
+                    text: 'test1',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '10pt',
+                        textColor: 'red',
+                        italic: false,
+                    },
+                },
+                {
+                    segmentType: 'Text',
+                    text: 'test2',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '12pt',
+                        textColor: 'red',
+                        italic: true,
+                    },
+                },
+            ],
+            format: {},
+            segmentFormat: { fontFamily: 'Calibri', textColor: 'red' },
+        });
+    });
+
+    it('All formats are different', () => {
+        const para = createParagraph();
+        const text1 = createText('test1', {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: false,
+        });
+        const text2 = createText('test2', {
+            fontFamily: 'Arial',
+            fontSize: '12pt',
+            textColor: 'green',
+            italic: true,
+        });
+
+        para.segments.push(text1, text2);
+        para.cachedElement = mockedCache;
+
+        normalizeParagraph(para);
+
+        expect(para).toEqual({
+            blockType: 'Paragraph',
+            segments: [
+                {
+                    segmentType: 'Text',
+                    text: 'test1',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '10pt',
+                        textColor: 'red',
+                        italic: false,
+                    },
+                },
+                {
+                    segmentType: 'Text',
+                    text: 'test2',
+                    format: {
+                        fontFamily: 'Arial',
+                        fontSize: '12pt',
+                        textColor: 'green',
+                        italic: true,
+                    },
+                },
+            ],
+            format: {},
+            cachedElement: mockedCache,
+        });
+    });
+
+    it('Already has same format in paragraph', () => {
+        const para = createParagraph(false, undefined, {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: false,
+        });
+        const text1 = createText('test1', {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: false,
+        });
+        const text2 = createText('test2', {
+            fontFamily: 'Calibri',
+            fontSize: '10pt',
+            textColor: 'red',
+            italic: true,
+        });
+
+        para.segments.push(text1, text2);
+        para.cachedElement = mockedCache;
+
+        normalizeParagraph(para);
+
+        expect(para).toEqual({
+            blockType: 'Paragraph',
+            segments: [
+                {
+                    segmentType: 'Text',
+                    text: 'test1',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '10pt',
+                        textColor: 'red',
+                        italic: false,
+                    },
+                },
+                {
+                    segmentType: 'Text',
+                    text: 'test2',
+                    format: {
+                        fontFamily: 'Calibri',
+                        fontSize: '10pt',
+                        textColor: 'red',
+                        italic: true,
+                    },
+                },
+            ],
+            format: {},
+            segmentFormat: {
+                fontFamily: 'Calibri',
+                fontSize: '10pt',
+                textColor: 'red',
+                italic: false,
+            },
+            cachedElement: mockedCache,
+        });
+    });
+});