@worktile/theia 3.0.8 → 3.0.9

package/esm2015/plugins/table/table.editor.js

@@ -1,183 +1,183 @@
-import { Editor, Element, Transforms, Text, Node } from 'slate';
-import { TableOptions } from './table.types';
-import { Alignment, ALIGN_BLOCK_TYPES, ElementKinds, MarkProps, VerticalAlignment } from '../../constants/node-types';
-import { insertColumn } from './transforms/insert-column';
-import { insertRow } from './transforms/insert-row';
-import { insertTable } from './transforms/insert-table';
-import { removeColumn } from './transforms/remove-column';
-import { removeRow } from './transforms/remove-row';
-import { removeTable } from './transforms/remove-table';
-import { clearCell } from './transforms/clear-cell';
-import { getAboveByType } from '../../queries/get-above-by-type';
-import { AngularEditor, ELEMENT_TO_COMPONENT } from 'slate-angular';
-import * as TheTransforms from '../../transforms';
-import { getOriginCell } from './utils/calc-span';
-export const TableEditor = {
-    insertTable(editor, optionsParam) {
-        const opts = new TableOptions(optionsParam);
-        insertTable(opts, editor);
-    },
-    insertColumn(editor, count = 1, at, optionsParam) {
-        const opts = new TableOptions(optionsParam);
-        insertColumn(opts, editor, count, at);
-    },
-    insertRow(editor, count = 1, at, optionsParam) {
-        const opts = new TableOptions(optionsParam);
-        insertRow(opts, editor, count, at);
-    },
-    removeTable(editor, optionsParam) {
-        const opts = new TableOptions(optionsParam);
-        removeTable(opts, editor);
-    },
-    removeRow(editor, rowIndex, optionsParam) {
-        const opts = new TableOptions(optionsParam);
-        removeRow(opts, editor, rowIndex);
-    },
-    removeColumn(editor, colIndex, optionsParam) {
-        const opts = new TableOptions(optionsParam);
-        removeColumn(opts, editor, colIndex);
-    },
-    clearCell(editor, nodeEntry, optionsParam) {
-        const opts = new TableOptions(optionsParam);
-        clearCell(opts, editor, nodeEntry);
-    },
-    isActive(editor) {
-        const [table] = Editor.nodes(editor, { match: n => Element.isElement(n) && n.type === ElementKinds.table });
-        return !!table;
-    },
-    getSelectedCells(editor) {
-        const tableNode = getAboveByType(editor, ElementKinds.table);
-        if (tableNode) {
-            const tableComponent = ELEMENT_TO_COMPONENT.get(tableNode[0]);
-            const cells = tableComponent.tableStore.selectedCells;
-            if (cells.length > 0) {
-                return cells;
-            }
-        }
-        return null;
-    },
-    isAlignActive(editor, alignment) {
-        const cells = TableEditor.getSelectedCells(editor);
-        if (cells) {
-            const lastCell = cells[cells.length - 1];
-            const tableNode = getAboveByType(editor, ElementKinds.table);
-            const cellPath = [...tableNode[1], lastCell.row, lastCell.col];
-            const cell = Node.get(editor, cellPath);
-            const { align } = cell;
-            if (!align && alignment === Alignment.left) {
-                return true;
-            }
-            return align === alignment;
-        }
-        return null;
-    },
-    setAlign(editor, alignment) {
-        return TableEditor.handleSelectedCells(editor, (cellPath, cellRange) => {
-            Transforms.setNodes(editor, { align: alignment }, {
-                at: cellPath
-            });
-            Transforms.setNodes(editor, { align: undefined }, {
-                at: cellRange,
-                match: (n) => ALIGN_BLOCK_TYPES.includes(n.type)
-            });
-        });
-    },
-    setVerticalAlign(editor, alignment) {
-        const isSelected = TableEditor.handleSelectedCells(editor, cellPath => {
-            Transforms.setNodes(editor, { verticalAlign: alignment }, { at: cellPath });
-        });
-        if (!isSelected) {
-            const cellEntry = getAboveByType(editor, ElementKinds.tableCell);
-            if (cellEntry) {
-                const [, cellPath] = cellEntry;
-                Transforms.setNodes(editor, { verticalAlign: alignment }, {
-                    at: cellPath,
-                    match: (n) => n.type === ElementKinds.tableCell
-                });
-                return true;
-            }
-            return false;
-        }
-        return true;
-    },
-    isVerticalAlignActive(editor, alignment) {
-        const cells = TableEditor.getSelectedCells(editor);
-        if (cells) {
-            const lastCell = cells[cells.length - 1];
-            const tableNode = getAboveByType(editor, ElementKinds.table);
-            const cellPath = [...tableNode[1], lastCell.row, lastCell.col];
-            const cell = Node.get(editor, cellPath);
-            const { verticalAlign } = cell;
-            if (!verticalAlign && alignment === VerticalAlignment.top) {
-                return true;
-            }
-            return verticalAlign === alignment;
-        }
-        else {
-            const cellElement = getAboveByType(editor, ElementKinds.tableCell);
-            if (cellElement) {
-                const { verticalAlign } = cellElement[0];
-                if (!verticalAlign && alignment === VerticalAlignment.top) {
-                    return true;
-                }
-                return verticalAlign === alignment;
-            }
-        }
-        return null;
-    },
-    toggleMark(editor, isActive, format, value = true) {
-        return TableEditor.handleSelectedCells(editor, at => {
-            if (isActive) {
-                Transforms.unsetNodes(editor, format, {
-                    at,
-                    match: Text.isText,
-                    split: true
-                });
-            }
-            else {
-                Transforms.setNodes(editor, { [format]: value }, {
-                    at,
-                    match: Text.isText,
-                    split: true
-                });
-            }
-        });
-    },
-    clearMark(editor) {
-        return TableEditor.handleSelectedCells(editor, (cellPath, cellRange) => {
-            const unsetMarks = {};
-            MarkProps.forEach(key => {
-                unsetMarks[key] = null;
-            });
-            TheTransforms.setMarks(editor, unsetMarks, cellRange);
-        });
-    },
-    handleSelectedCells(editor, handle) {
-        const cells = TableEditor.getSelectedCells(editor);
-        if (cells) {
-            const tableNode = getAboveByType(editor, ElementKinds.table);
-            Editor.withoutNormalizing(editor, () => {
-                for (const cell of cells) {
-                    const { row, col } = cell;
-                    const cellPath = [...tableNode[1], row, col];
-                    const cellRange = { anchor: Editor.start(editor, cellPath), focus: Editor.end(editor, cellPath) };
-                    handle(cellPath, cellRange);
-                }
-            });
-            return true;
-        }
-        return false;
-    },
-    isActiveHeader(editor) {
-        const [tableRowEntry] = Editor.nodes(editor, { match: (n) => n.type === ElementKinds.tableRow });
-        return tableRowEntry && tableRowEntry[0] && tableRowEntry[0].header;
-    },
-    selectOriginCell(editor, table, rowIndex, columnIndex, isStart) {
-        const origin = getOriginCell(table, rowIndex, columnIndex);
-        if (origin) {
-            const path = AngularEditor.findPath(editor, origin);
-            Transforms.select(editor, isStart ? Editor.start(editor, path) : Editor.end(editor, path));
-        }
-    }
-};
+import { Editor, Element, Transforms, Text, Node } from 'slate';
+import { TableOptions } from './table.types';
+import { Alignment, ALIGN_BLOCK_TYPES, ElementKinds, MarkProps, VerticalAlignment } from '../../constants/node-types';
+import { insertColumn } from './transforms/insert-column';
+import { insertRow } from './transforms/insert-row';
+import { insertTable } from './transforms/insert-table';
+import { removeColumn } from './transforms/remove-column';
+import { removeRow } from './transforms/remove-row';
+import { removeTable } from './transforms/remove-table';
+import { clearCell } from './transforms/clear-cell';
+import { getAboveByType } from '../../queries/get-above-by-type';
+import { AngularEditor, ELEMENT_TO_COMPONENT } from 'slate-angular';
+import * as TheTransforms from '../../transforms';
+import { getOriginCell } from './utils/calc-span';
+export const TableEditor = {
+    insertTable(editor, optionsParam) {
+        const opts = new TableOptions(optionsParam);
+        insertTable(opts, editor);
+    },
+    insertColumn(editor, count = 1, at, optionsParam) {
+        const opts = new TableOptions(optionsParam);
+        insertColumn(opts, editor, count, at);
+    },
+    insertRow(editor, count = 1, at, optionsParam) {
+        const opts = new TableOptions(optionsParam);
+        insertRow(opts, editor, count, at);
+    },
+    removeTable(editor, optionsParam) {
+        const opts = new TableOptions(optionsParam);
+        removeTable(opts, editor);
+    },
+    removeRow(editor, rowIndex, optionsParam) {
+        const opts = new TableOptions(optionsParam);
+        removeRow(opts, editor, rowIndex);
+    },
+    removeColumn(editor, colIndex, optionsParam) {
+        const opts = new TableOptions(optionsParam);
+        removeColumn(opts, editor, colIndex);
+    },
+    clearCell(editor, nodeEntry, optionsParam) {
+        const opts = new TableOptions(optionsParam);
+        clearCell(opts, editor, nodeEntry);
+    },
+    isActive(editor) {
+        const [table] = Editor.nodes(editor, { match: n => Element.isElement(n) && n.type === ElementKinds.table });
+        return !!table;
+    },
+    getSelectedCells(editor) {
+        const tableNode = getAboveByType(editor, ElementKinds.table);
+        if (tableNode) {
+            const tableComponent = ELEMENT_TO_COMPONENT.get(tableNode[0]);
+            const cells = tableComponent.tableStore.selectedCells;
+            if (cells.length > 0) {
+                return cells;
+            }
+        }
+        return null;
+    },
+    isAlignActive(editor, alignment) {
+        const cells = TableEditor.getSelectedCells(editor);
+        if (cells) {
+            const lastCell = cells[cells.length - 1];
+            const tableNode = getAboveByType(editor, ElementKinds.table);
+            const cellPath = [...tableNode[1], lastCell.row, lastCell.col];
+            const cell = Node.get(editor, cellPath);
+            const { align } = cell;
+            if (!align && alignment === Alignment.left) {
+                return true;
+            }
+            return align === alignment;
+        }
+        return null;
+    },
+    setAlign(editor, alignment) {
+        return TableEditor.handleSelectedCells(editor, (cellPath, cellRange) => {
+            Transforms.setNodes(editor, { align: alignment }, {
+                at: cellPath
+            });
+            Transforms.setNodes(editor, { align: undefined }, {
+                at: cellRange,
+                match: (n) => ALIGN_BLOCK_TYPES.includes(n.type)
+            });
+        });
+    },
+    setVerticalAlign(editor, alignment) {
+        const isSelected = TableEditor.handleSelectedCells(editor, cellPath => {
+            Transforms.setNodes(editor, { verticalAlign: alignment }, { at: cellPath });
+        });
+        if (!isSelected) {
+            const cellEntry = getAboveByType(editor, ElementKinds.tableCell);
+            if (cellEntry) {
+                const [, cellPath] = cellEntry;
+                Transforms.setNodes(editor, { verticalAlign: alignment }, {
+                    at: cellPath,
+                    match: (n) => n.type === ElementKinds.tableCell
+                });
+                return true;
+            }
+            return false;
+        }
+        return true;
+    },
+    isVerticalAlignActive(editor, alignment) {
+        const cells = TableEditor.getSelectedCells(editor);
+        if (cells) {
+            const lastCell = cells[cells.length - 1];
+            const tableNode = getAboveByType(editor, ElementKinds.table);
+            const cellPath = [...tableNode[1], lastCell.row, lastCell.col];
+            const cell = Node.get(editor, cellPath);
+            const { verticalAlign } = cell;
+            if (!verticalAlign && alignment === VerticalAlignment.top) {
+                return true;
+            }
+            return verticalAlign === alignment;
+        }
+        else {
+            const cellElement = getAboveByType(editor, ElementKinds.tableCell);
+            if (cellElement) {
+                const { verticalAlign } = cellElement[0];
+                if (!verticalAlign && alignment === VerticalAlignment.top) {
+                    return true;
+                }
+                return verticalAlign === alignment;
+            }
+        }
+        return null;
+    },
+    toggleMark(editor, isActive, format, value = true) {
+        return TableEditor.handleSelectedCells(editor, at => {
+            if (isActive) {
+                Transforms.unsetNodes(editor, format, {
+                    at,
+                    match: Text.isText,
+                    split: true
+                });
+            }
+            else {
+                Transforms.setNodes(editor, { [format]: value }, {
+                    at,
+                    match: Text.isText,
+                    split: true
+                });
+            }
+        });
+    },
+    clearMark(editor) {
+        return TableEditor.handleSelectedCells(editor, (cellPath, cellRange) => {
+            const unsetMarks = {};
+            MarkProps.forEach(key => {
+                unsetMarks[key] = null;
+            });
+            TheTransforms.setMarks(editor, unsetMarks, cellRange);
+        });
+    },
+    handleSelectedCells(editor, handle) {
+        const cells = TableEditor.getSelectedCells(editor);
+        if (cells) {
+            const tableNode = getAboveByType(editor, ElementKinds.table);
+            Editor.withoutNormalizing(editor, () => {
+                for (const cell of cells) {
+                    const { row, col } = cell;
+                    const cellPath = [...tableNode[1], row, col];
+                    const cellRange = { anchor: Editor.start(editor, cellPath), focus: Editor.end(editor, cellPath) };
+                    handle(cellPath, cellRange);
+                }
+            });
+            return true;
+        }
+        return false;
+    },
+    isActiveHeader(editor) {
+        const [tableRowEntry] = Editor.nodes(editor, { match: (n) => n.type === ElementKinds.tableRow });
+        return tableRowEntry && tableRowEntry[0] && tableRowEntry[0].header;
+    },
+    selectOriginCell(editor, table, rowIndex, columnIndex, isStart) {
+        const origin = getOriginCell(table, rowIndex, columnIndex);
+        if (origin) {
+            const path = AngularEditor.findPath(editor, origin);
+            Transforms.select(editor, isStart ? Editor.start(editor, path) : Editor.end(editor, path));
+        }
+    }
+};
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.editor.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/table/table.editor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Editor, Element, NodeEntry, Transforms, Text, Path, Range, Node } from 'slate';\nimport { TableOptions } from './table.types';\nimport { Alignment, ALIGN_BLOCK_TYPES, ElementKinds, MarkProps, MarkTypes, VerticalAlignment } from '../../constants/node-types';\nimport { insertColumn } from './transforms/insert-column';\nimport { insertRow } from './transforms/insert-row';\nimport { insertTable } from './transforms/insert-table';\nimport { removeColumn } from './transforms/remove-column';\nimport { removeRow } from './transforms/remove-row';\nimport { removeTable } from './transforms/remove-table';\nimport { clearCell } from './transforms/clear-cell';\nimport { getAboveByType } from '../../queries/get-above-by-type';\nimport { AngularEditor, ELEMENT_TO_COMPONENT } from 'slate-angular';\nimport type { TheTableComponent } from './components/table.component';\nimport { TheEditor } from '../../interfaces';\nimport { TableCellElement, TableRowElement } from '../../custom-types';\nimport * as TheTransforms from '../../transforms';\nimport { TableElement } from '../../custom-types';\nimport { getOriginCell } from './utils/calc-span';\n\nexport const TableEditor = {\n    insertTable(editor: Editor, optionsParam?: TableOptions) {\n        const opts = new TableOptions(optionsParam);\n        insertTable(opts, editor);\n    },\n    insertColumn(editor: Editor, count: number = 1, at?: number, optionsParam?: TableOptions) {\n        const opts = new TableOptions(optionsParam);\n        insertColumn(opts, editor, count, at);\n    },\n    insertRow(editor: Editor, count: number = 1, at?: number, optionsParam?: TableOptions) {\n        const opts = new TableOptions(optionsParam);\n        insertRow(opts, editor, count, at);\n    },\n    removeTable(editor: Editor, optionsParam?: TableOptions) {\n        const opts = new TableOptions(optionsParam);\n        removeTable(opts, editor);\n    },\n    removeRow(editor: Editor, rowIndex?: number, optionsParam?: TableOptions) {\n        const opts = new TableOptions(optionsParam);\n        removeRow(opts, editor, rowIndex);\n    },\n    removeColumn(editor: Editor, colIndex?: number, optionsParam?: TableOptions) {\n        const opts = new TableOptions(optionsParam);\n        removeColumn(opts, editor, colIndex);\n    },\n    clearCell(editor: Editor, nodeEntry?: NodeEntry<Element>, optionsParam?: TableOptions) {\n        const opts = new TableOptions(optionsParam);\n        clearCell(opts, editor, nodeEntry);\n    },\n    isActive(editor: Editor) {\n        const [table] = Editor.nodes(editor, { match: n => Element.isElement(n) && n.type === ElementKinds.table });\n        return !!table;\n    },\n    getSelectedCells(editor: Editor) {\n        const tableNode = getAboveByType(editor, ElementKinds.table);\n        if (tableNode) {\n            const tableComponent = ELEMENT_TO_COMPONENT.get(tableNode[0]) as TheTableComponent;\n            const cells = tableComponent.tableStore.selectedCells;\n            if (cells.length > 0) {\n                return cells;\n            }\n        }\n        return null;\n    },\n    isAlignActive(editor: TheEditor, alignment: Alignment) {\n        const cells = TableEditor.getSelectedCells(editor);\n        if (cells) {\n            const lastCell = cells[cells.length - 1];\n            const tableNode = getAboveByType(editor, ElementKinds.table);\n            const cellPath = [...tableNode[1], lastCell.row, lastCell.col];\n            const cell = Node.get(editor, cellPath) as TableCellElement;\n            const { align } = cell;\n            if (!align && alignment === Alignment.left) {\n                return true;\n            }\n            return align === alignment;\n        }\n        return null;\n    },\n    setAlign(editor: Editor, alignment: Alignment) {\n        return TableEditor.handleSelectedCells(editor, (cellPath, cellRange) => {\n            Transforms.setNodes(\n                editor,\n                { align: alignment },\n                {\n                    at: cellPath\n                }\n            );\n            Transforms.setNodes(\n                editor,\n                { align: undefined },\n                {\n                    at: cellRange,\n                    match: (n: Element) => ALIGN_BLOCK_TYPES.includes(n.type)\n                }\n            );\n        });\n    },\n    setVerticalAlign(editor: TheEditor, alignment: VerticalAlignment) {\n        const isSelected = TableEditor.handleSelectedCells(editor, cellPath => {\n            Transforms.setNodes(editor, { verticalAlign: alignment }, { at: cellPath });\n        });\n        if (!isSelected) {\n            const cellEntry = getAboveByType(editor, ElementKinds.tableCell);\n            if (cellEntry) {\n                const [, cellPath] = cellEntry;\n                Transforms.setNodes(\n                    editor,\n                    { verticalAlign: alignment },\n                    {\n                        at: cellPath,\n                        match: (n: Element) => n.type === ElementKinds.tableCell\n                    }\n                );\n                return true;\n            }\n            return false;\n        }\n        return true;\n    },\n    isVerticalAlignActive(editor: TheEditor, alignment: VerticalAlignment) {\n        const cells = TableEditor.getSelectedCells(editor);\n        if (cells) {\n            const lastCell = cells[cells.length - 1];\n            const tableNode = getAboveByType(editor, ElementKinds.table);\n            const cellPath = [...tableNode[1], lastCell.row, lastCell.col];\n            const cell = Node.get(editor, cellPath) as TableCellElement;\n            const { verticalAlign } = cell;\n            if (!verticalAlign && alignment === VerticalAlignment.top) {\n                return true;\n            }\n            return verticalAlign === alignment;\n        } else {\n            const cellElement = getAboveByType(editor, ElementKinds.tableCell);\n            if (cellElement) {\n                const { verticalAlign } = cellElement[0];\n                if (!verticalAlign && alignment === VerticalAlignment.top) {\n                    return true;\n                }\n                return verticalAlign === alignment;\n            }\n        }\n        return null;\n    },\n    toggleMark(editor: TheEditor, isActive: boolean, format: string | string[], value: string | number | boolean = true) {\n        return TableEditor.handleSelectedCells(editor, at => {\n            if (isActive) {\n                Transforms.unsetNodes(editor, format, {\n                    at,\n                    match: Text.isText,\n                    split: true\n                });\n            } else {\n                Transforms.setNodes(\n                    editor,\n                    { [format as string]: value },\n                    {\n                        at,\n                        match: Text.isText,\n                        split: true\n                    }\n                );\n            }\n        });\n    },\n    clearMark(editor: TheEditor) {\n        return TableEditor.handleSelectedCells(editor, (cellPath, cellRange) => {\n            const unsetMarks: { [key in MarkTypes]?: null | string } = {};\n            MarkProps.forEach(key => {\n                unsetMarks[key] = null;\n            });\n            TheTransforms.setMarks(editor, unsetMarks, cellRange);\n        });\n    },\n    handleSelectedCells(editor: TheEditor, handle: (cellPath: Path, cellRange: Range) => void) {\n        const cells = TableEditor.getSelectedCells(editor);\n        if (cells) {\n            const tableNode = getAboveByType(editor, ElementKinds.table);\n            Editor.withoutNormalizing(editor, () => {\n                for (const cell of cells) {\n                    const { row, col } = cell;\n                    const cellPath = [...tableNode[1], row, col];\n                    const cellRange = { anchor: Editor.start(editor, cellPath), focus: Editor.end(editor, cellPath) };\n                    handle(cellPath, cellRange);\n                }\n            });\n            return true;\n        }\n        return false;\n    },\n    isActiveHeader(editor: TheEditor) {\n        const [tableRowEntry] = Editor.nodes(editor, { match: (n: Element) => n.type === ElementKinds.tableRow });\n        return tableRowEntry && tableRowEntry[0] && (tableRowEntry[0] as TableRowElement).header;\n    },\n    selectOriginCell(editor: TheEditor, table: TableElement, rowIndex: number, columnIndex: number, isStart: boolean) {\n        const origin = getOriginCell(table, rowIndex, columnIndex);\n        if (origin) {\n            const path = AngularEditor.findPath(editor, origin);\n            Transforms.select(editor, isStart ? Editor.start(editor, path) : Editor.end(editor, path));\n        }\n    }\n};\n"]}