@uniformdev/canvas-next-rsc 19.79.1-alpha.11 → 19.80.1-alpha.126

package/dist/utils/__tests__/apply.spec.js

@@ -0,0 +1,358 @@
+import { applyDiff } from '../apply';
+import { ComponentDiffType } from '../diff';
+describe('apply', () => {
+    it('should leave a composition alone if the diff is blank', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+            },
+            diff: [],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+        });
+    });
+    it('should add a slot component if diff specifies one', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+                slots: {
+                    content: [],
+                },
+            },
+            diff: [
+                {
+                    type: ComponentDiffType.ComponentAdded,
+                    id: 'child',
+                    parentId: 'root',
+                    slot: 'content',
+                    slotIndex: 0,
+                    component: {
+                        type: 'child',
+                        _id: 'child',
+                    },
+                },
+            ],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            slots: {
+                content: [
+                    {
+                        _id: 'child',
+                        type: 'child',
+                    },
+                ],
+            },
+        });
+    });
+    it('should remove a slot component if diff specifies one', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+                slots: {
+                    content: [
+                        {
+                            type: 'child1',
+                            _id: 'child',
+                        },
+                        {
+                            type: 'child',
+                            _id: 'child2',
+                        },
+                    ],
+                },
+            },
+            diff: [
+                {
+                    type: ComponentDiffType.ComponentRemoved,
+                    id: 'child',
+                },
+            ],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            slots: {
+                content: [
+                    {
+                        type: 'child',
+                        _id: 'child2',
+                    },
+                ],
+            },
+        });
+    });
+    it('should move a slot component if diff specifies one', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+                slots: {
+                    content: [
+                        {
+                            type: 'child',
+                            _id: 'child1',
+                            slots: {
+                                content: [],
+                            },
+                        },
+                        {
+                            type: 'child',
+                            _id: 'child2',
+                        },
+                    ],
+                },
+            },
+            diff: [
+                {
+                    type: ComponentDiffType.ComponentMoved,
+                    id: 'child2',
+                    parentId: 'child1',
+                    slot: 'content',
+                    slotIndex: 0,
+                },
+            ],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            slots: {
+                content: [
+                    {
+                        type: 'child',
+                        _id: 'child1',
+                        slots: {
+                            content: [
+                                {
+                                    type: 'child',
+                                    _id: 'child2',
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        });
+    });
+    it('should move a slot component if diff specifies one, even if target does not define slot', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+                slots: {
+                    content: [
+                        {
+                            type: 'child',
+                            _id: 'child1',
+                        },
+                        {
+                            type: 'child',
+                            _id: 'child2',
+                        },
+                    ],
+                },
+            },
+            diff: [
+                {
+                    type: ComponentDiffType.ComponentMoved,
+                    id: 'child2',
+                    parentId: 'child1',
+                    slot: 'content',
+                    slotIndex: 0,
+                },
+            ],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            slots: {
+                content: [
+                    {
+                        type: 'child',
+                        _id: 'child1',
+                        slots: {
+                            content: [
+                                {
+                                    type: 'child',
+                                    _id: 'child2',
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        });
+    });
+    it('should change a parameter if diff specifies one', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+                parameters: {
+                    title: {
+                        type: 'text',
+                        value: 'Hello',
+                    },
+                },
+            },
+            diff: [
+                {
+                    type: ComponentDiffType.ParameterChanged,
+                    componentId: 'root',
+                    parameterName: 'title',
+                    value: 'Goodbye',
+                },
+            ],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            parameters: {
+                title: {
+                    type: 'text',
+                    value: 'Goodbye',
+                },
+            },
+        });
+    });
+    it('should delete a parameter if diff specifies one', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+                parameters: {
+                    title: {
+                        type: 'text',
+                        value: 'Hello',
+                    },
+                },
+            },
+            diff: [
+                {
+                    type: ComponentDiffType.ParameterRemoved,
+                    componentId: 'root',
+                    parameterName: 'title',
+                },
+            ],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            parameters: {},
+        });
+    });
+    it('should handle a component and move in a slot', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+                slots: {
+                    pageContent: [
+                        {
+                            type: 'hero',
+                            _id: '1f352a25-7acb-4893-a11c-f06bd45f27ab',
+                        },
+                        {
+                            type: 'hero',
+                            _id: '93e9fa20-d86e-4543-9ca7-927ffeab6d54',
+                        },
+                    ],
+                },
+            },
+            diff: [
+                {
+                    type: ComponentDiffType.ComponentRemoved,
+                    id: '1f352a25-7acb-4893-a11c-f06bd45f27ab',
+                },
+                {
+                    type: ComponentDiffType.ComponentMoved,
+                    id: '93e9fa20-d86e-4543-9ca7-927ffeab6d54',
+                    slotIndex: 0,
+                    parentId: undefined,
+                    slot: undefined,
+                },
+            ],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            slots: {
+                pageContent: [
+                    {
+                        type: 'hero',
+                        _id: '93e9fa20-d86e-4543-9ca7-927ffeab6d54',
+                    },
+                ],
+            },
+        });
+    });
+    it('should put components back into the correct position', () => {
+        const result = applyDiff({
+            composition: {
+                _id: 'root',
+                _name: 'root',
+                type: 'root',
+                slots: {
+                    content: [
+                        {
+                            type: 'child',
+                            _id: 'existing',
+                        },
+                    ],
+                },
+            },
+            diff: [
+                {
+                    type: ComponentDiffType.ComponentAdded,
+                    id: 'child',
+                    parentId: 'root',
+                    slot: 'content',
+                    slotIndex: 0,
+                    component: {
+                        type: 'child',
+                        _id: 'child',
+                    },
+                },
+            ],
+        });
+        expect(result).toEqual({
+            _id: 'root',
+            _name: 'root',
+            type: 'root',
+            slots: {
+                content: [
+                    {
+                        _id: 'child',
+                        type: 'child',
+                    },
+                    {
+                        type: 'child',
+                        _id: 'existing',
+                    },
+                ],
+            },
+        });
+    });
+});

package/dist/utils/__tests__/diff.spec.d.ts

@@ -0,0 +1 @@
+export {};