qms-angular 1.0.86 → 1.0.89

package/src/assets/qms-ckeditor-plugin/src/plugins/table/tableediting.js

@@ -0,0 +1,160 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module table/tableediting
+ */
+
+import { Plugin } from 'ckeditor5/src/core';
+
+import upcastTable, { ensureParagraphInTableCell, skipEmptyTableRow } from './converters/upcasttable';
+import {
+	convertParagraphInTableCell,
+	downcastInsertCell,
+	downcastInsertRow,
+	downcastInsertTable,
+	downcastRemoveRow,
+	downcastTableHeadingColumnsChange
+} from './converters/downcast';
+
+import InsertTableCommand from './commands/inserttablecommand';
+import InsertRowCommand from './commands/insertrowcommand';
+import InsertColumnCommand from './commands/insertcolumncommand';
+import SplitCellCommand from './commands/splitcellcommand';
+import MergeCellCommand from './commands/mergecellcommand';
+import RemoveRowCommand from './commands/removerowcommand';
+import RemoveColumnCommand from './commands/removecolumncommand';
+import SetHeaderRowCommand from './commands/setheaderrowcommand';
+import SetHeaderColumnCommand from './commands/setheadercolumncommand';
+import MergeCellsCommand from './commands/mergecellscommand';
+import SelectRowCommand from './commands/selectrowcommand';
+import SelectColumnCommand from './commands/selectcolumncommand';
+import TableUtils from '../table/tableutils';
+
+import injectTableLayoutPostFixer from './converters/table-layout-post-fixer';
+import injectTableCellParagraphPostFixer from './converters/table-cell-paragraph-post-fixer';
+import injectTableCellRefreshPostFixer from './converters/table-cell-refresh-post-fixer';
+import injectTableHeadingRowsRefreshPostFixer from './converters/table-heading-rows-refresh-post-fixer';
+
+import './theme/tableediting.css';
+
+/**
+ * The table editing feature.
+ *
+ * @extends module:core/plugin~Plugin
+ */
+export default class TableEditing extends Plugin {
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'TableEditing';
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	init() {
+		const editor = this.editor;
+		const model = editor.model;
+		const schema = model.schema;
+		const conversion = editor.conversion;
+
+		schema.register( 'table', {
+			allowWhere: '$block',
+			allowAttributes: [ 'headingRows', 'headingColumns' ],
+			isObject: true,
+			isBlock: true
+		} );
+
+		schema.register( 'tableRow', {
+			allowIn: 'table',
+			isLimit: true
+		} );
+
+		schema.register( 'tableCell', {
+			allowIn: 'tableRow',
+			allowAttributes: [ 'colspan', 'rowspan' ],
+			isLimit: true,
+			isSelectable: true
+		} );
+
+		// Allow all $block content inside a table cell.
+		schema.extend( '$block', { allowIn: 'tableCell' } );
+
+		// Table conversion.
+		conversion.for( 'upcast' ).add( upcastTable() );
+
+		conversion.for( 'editingDowncast' ).add( downcastInsertTable( { asWidget: true } ) );
+		conversion.for( 'dataDowncast' ).add( downcastInsertTable() );
+
+		// Table row conversion.
+		conversion.for( 'upcast' ).elementToElement( { model: 'tableRow', view: 'tr' } );
+		conversion.for( 'upcast' ).add( skipEmptyTableRow() );
+
+		conversion.for( 'editingDowncast' ).add( downcastInsertRow() );
+		conversion.for( 'editingDowncast' ).add( downcastRemoveRow() );
+
+		// Table cell conversion.
+		conversion.for( 'upcast' ).elementToElement( { model: 'tableCell', view: 'td' } );
+		conversion.for( 'upcast' ).elementToElement( { model: 'tableCell', view: 'th' } );
+		conversion.for( 'upcast' ).add( ensureParagraphInTableCell( 'td' ) );
+		conversion.for( 'upcast' ).add( ensureParagraphInTableCell( 'th' ) );
+
+		conversion.for( 'editingDowncast' ).add( downcastInsertCell() );
+
+		// Duplicates code - needed to properly refresh paragraph inside a table cell.
+		editor.conversion.for( 'editingDowncast' ).elementToElement( {
+			model: 'paragraph',
+			view: convertParagraphInTableCell,
+			converterPriority: 'high'
+		} );
+
+		// Table attributes conversion.
+		conversion.attributeToAttribute( { model: 'colspan', view: 'colspan' } );
+		conversion.attributeToAttribute( { model: 'rowspan', view: 'rowspan' } );
+
+		// Table heading columns conversion (a change of heading rows requires a reconversion of the whole table).
+		conversion.for( 'editingDowncast' ).add( downcastTableHeadingColumnsChange() );
+
+		// Define all the commands.
+		editor.commands.add( 'insertTable', new InsertTableCommand( editor ) );
+		editor.commands.add( 'insertTableRowAbove', new InsertRowCommand( editor, { order: 'above' } ) );
+		editor.commands.add( 'insertTableRowBelow', new InsertRowCommand( editor, { order: 'below' } ) );
+		editor.commands.add( 'insertTableColumnLeft', new InsertColumnCommand( editor, { order: 'left' } ) );
+		editor.commands.add( 'insertTableColumnRight', new InsertColumnCommand( editor, { order: 'right' } ) );
+
+		editor.commands.add( 'removeTableRow', new RemoveRowCommand( editor ) );
+		editor.commands.add( 'removeTableColumn', new RemoveColumnCommand( editor ) );
+
+		editor.commands.add( 'splitTableCellVertically', new SplitCellCommand( editor, { direction: 'vertically' } ) );
+		editor.commands.add( 'splitTableCellHorizontally', new SplitCellCommand( editor, { direction: 'horizontally' } ) );
+
+		editor.commands.add( 'mergeTableCells', new MergeCellsCommand( editor ) );
+
+		editor.commands.add( 'mergeTableCellRight', new MergeCellCommand( editor, { direction: 'right' } ) );
+		editor.commands.add( 'mergeTableCellLeft', new MergeCellCommand( editor, { direction: 'left' } ) );
+		editor.commands.add( 'mergeTableCellDown', new MergeCellCommand( editor, { direction: 'down' } ) );
+		editor.commands.add( 'mergeTableCellUp', new MergeCellCommand( editor, { direction: 'up' } ) );
+
+		editor.commands.add( 'setTableColumnHeader', new SetHeaderColumnCommand( editor ) );
+		editor.commands.add( 'setTableRowHeader', new SetHeaderRowCommand( editor ) );
+
+		editor.commands.add( 'selectTableRow', new SelectRowCommand( editor ) );
+		editor.commands.add( 'selectTableColumn', new SelectColumnCommand( editor ) );
+
+		injectTableHeadingRowsRefreshPostFixer( model );
+		injectTableLayoutPostFixer( model );
+		injectTableCellRefreshPostFixer( model, editor.editing.mapper );
+		injectTableCellParagraphPostFixer( model );
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	static get requires() {
+		return [ TableUtils ];
+	}
+}

package/src/assets/qms-ckeditor-plugin/src/plugins/table/tablekeyboard.js

@@ -0,0 +1,343 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module table/tablekeyboard
+ */
+
+import TableSelection from './tableselection';
+import TableWalker from './tablewalker';
+
+import { Plugin } from 'ckeditor5/src/core';
+import { getLocalizedArrowKeyCodeDirection } from 'ckeditor5/src/utils';
+import { getSelectedTableCells, getTableCellsContainingSelection } from './utils/selection';
+
+/**
+ * This plugin enables keyboard navigation for tables.
+ * It is loaded automatically by the {@link module:table/table~Table} plugin.
+ *
+ * @extends module:core/plugin~Plugin
+ */
+export default class TableKeyboard extends Plugin {
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'TableKeyboard';
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	static get requires() {
+		return [ TableSelection ];
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	init() {
+		const view = this.editor.editing.view;
+		const viewDocument = view.document;
+
+		// Handle Tab key navigation.
+		this.editor.keystrokes.set( 'Tab', ( ...args ) => this._handleTabOnSelectedTable( ...args ), { priority: 'low' } );
+		this.editor.keystrokes.set( 'Tab', this._getTabHandler( true ), { priority: 'low' } );
+		this.editor.keystrokes.set( 'Shift+Tab', this._getTabHandler( false ), { priority: 'low' } );
+
+		this.listenTo( viewDocument, 'arrowKey', ( ...args ) => this._onArrowKey( ...args ), { context: 'table' } );
+	}
+
+	/**
+	 * Handles {@link module:engine/view/document~Document#event:keydown keydown} events for the <kbd>Tab</kbd> key executed
+	 * when the table widget is selected.
+	 *
+	 * @private
+	 * @param {module:engine/view/observer/keyobserver~KeyEventData} data Key event data.
+	 * @param {Function} cancel The stop/stopPropagation/preventDefault function.
+	 */
+	_handleTabOnSelectedTable( data, cancel ) {
+		const editor = this.editor;
+		const selection = editor.model.document.selection;
+		const selectedElement = selection.getSelectedElement();
+
+		if ( !selectedElement || !selectedElement.is( 'element', 'table' ) ) {
+			return;
+		}
+
+		cancel();
+
+		editor.model.change( writer => {
+			writer.setSelection( writer.createRangeIn( selectedElement.getChild( 0 ).getChild( 0 ) ) );
+		} );
+	}
+
+	/**
+	 * Returns a handler for {@link module:engine/view/document~Document#event:keydown keydown} events for the <kbd>Tab</kbd> key executed
+	 * inside table cells.
+	 *
+	 * @private
+	 * @param {Boolean} isForward Whether this handler will move the selection to the next or the previous cell.
+	 */
+	_getTabHandler( isForward ) {
+		const editor = this.editor;
+
+		return ( domEventData, cancel ) => {
+			const selection = editor.model.document.selection;
+			let tableCell = getTableCellsContainingSelection( selection )[ 0 ];
+
+			if ( !tableCell ) {
+				tableCell = this.editor.plugins.get( 'TableSelection' ).getFocusCell();
+			}
+
+			if ( !tableCell ) {
+				return;
+			}
+
+			cancel();
+
+			const tableRow = tableCell.parent;
+			const table = tableRow.parent;
+
+			const currentRowIndex = table.getChildIndex( tableRow );
+			const currentCellIndex = tableRow.getChildIndex( tableCell );
+
+			const isFirstCellInRow = currentCellIndex === 0;
+
+			if ( !isForward && isFirstCellInRow && currentRowIndex === 0 ) {
+				// Set the selection over the whole table if the selection was in the first table cell.
+				editor.model.change( writer => {
+					writer.setSelection( writer.createRangeOn( table ) );
+				} );
+
+				return;
+			}
+
+			const isLastCellInRow = currentCellIndex === tableRow.childCount - 1;
+			const isLastRow = currentRowIndex === table.childCount - 1;
+
+			if ( isForward && isLastRow && isLastCellInRow ) {
+				editor.execute( 'insertTableRowBelow' );
+
+				// Check if the command actually added a row. If `insertTableRowBelow` execution didn't add a row (because it was disabled
+				// or it got overwritten) set the selection over the whole table to mirror the first cell case.
+				if ( currentRowIndex === table.childCount - 1 ) {
+					editor.model.change( writer => {
+						writer.setSelection( writer.createRangeOn( table ) );
+					} );
+
+					return;
+				}
+			}
+
+			let cellToFocus;
+
+			// Move to the first cell in the next row.
+			if ( isForward && isLastCellInRow ) {
+				const nextRow = table.getChild( currentRowIndex + 1 );
+
+				cellToFocus = nextRow.getChild( 0 );
+			}
+			// Move to the last cell in the previous row.
+			else if ( !isForward && isFirstCellInRow ) {
+				const previousRow = table.getChild( currentRowIndex - 1 );
+
+				cellToFocus = previousRow.getChild( previousRow.childCount - 1 );
+			}
+			// Move to the next/previous cell.
+			else {
+				cellToFocus = tableRow.getChild( currentCellIndex + ( isForward ? 1 : -1 ) );
+			}
+
+			editor.model.change( writer => {
+				writer.setSelection( writer.createRangeIn( cellToFocus ) );
+			} );
+		};
+	}
+
+	/**
+	 * Handles {@link module:engine/view/document~Document#event:keydown keydown} events.
+	 *
+	 * @private
+	 * @param {module:utils/eventinfo~EventInfo} eventInfo
+	 * @param {module:engine/view/observer/domeventdata~DomEventData} domEventData
+	 */
+	_onArrowKey( eventInfo, domEventData ) {
+		const editor = this.editor;
+		const keyCode = domEventData.keyCode;
+
+		const direction = getLocalizedArrowKeyCodeDirection( keyCode, editor.locale.contentLanguageDirection );
+		const wasHandled = this._handleArrowKeys( direction, domEventData.shiftKey );
+
+		if ( wasHandled ) {
+			domEventData.preventDefault();
+			domEventData.stopPropagation();
+			eventInfo.stop();
+		}
+	}
+
+	/**
+	 * Handles arrow keys to move the selection around the table.
+	 *
+	 * @private
+	 * @param {'left'|'up'|'right'|'down'} direction The direction of the arrow key.
+	 * @param {Boolean} expandSelection If the current selection should be expanded.
+	 * @returns {Boolean} Returns `true` if key was handled.
+	 */
+	_handleArrowKeys( direction, expandSelection ) {
+		const model = this.editor.model;
+		const selection = model.document.selection;
+		const isForward = [ 'right', 'down' ].includes( direction );
+
+		// In case one or more table cells are selected (from outside),
+		// move the selection to a cell adjacent to the selected table fragment.
+		const selectedCells = getSelectedTableCells( selection );
+
+		if ( selectedCells.length ) {
+			let focusCell;
+
+			if ( expandSelection ) {
+				focusCell = this.editor.plugins.get( 'TableSelection' ).getFocusCell();
+			} else {
+				focusCell = isForward ? selectedCells[ selectedCells.length - 1 ] : selectedCells[ 0 ];
+			}
+
+			this._navigateFromCellInDirection( focusCell, direction, expandSelection );
+
+			return true;
+		}
+
+		// Abort if we're not in a table cell.
+		const tableCell = selection.focus.findAncestor( 'tableCell' );
+
+		/* istanbul ignore if: paranoid check */
+		if ( !tableCell ) {
+			return false;
+		}
+
+		// Navigation is in the opposite direction than the selection direction so this is shrinking of the selection.
+		// Selection for sure will not approach cell edge.
+		if ( expandSelection && !selection.isCollapsed && selection.isBackward == isForward ) {
+			return false;
+		}
+
+		// Let's check if the selection is at the beginning/end of the cell.
+		if ( this._isSelectionAtCellEdge( selection, tableCell, isForward ) ) {
+			this._navigateFromCellInDirection( tableCell, direction, expandSelection );
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns `true` if the selection is at the boundary of a table cell according to the navigation direction.
+	 *
+	 * @private
+	 * @param {module:engine/model/selection~Selection} selection The current selection.
+	 * @param {module:engine/model/element~Element} tableCell The current table cell element.
+	 * @param {Boolean} isForward The expected navigation direction.
+	 * @returns {Boolean}
+	 */
+	_isSelectionAtCellEdge( selection, tableCell, isForward ) {
+		const model = this.editor.model;
+		const schema = this.editor.model.schema;
+
+		const focus = isForward ? selection.getLastPosition() : selection.getFirstPosition();
+
+		// If the current limit element is not table cell we are for sure not at the cell edge.
+		// Also `modifySelection` will not let us out of it.
+		if ( !schema.getLimitElement( focus ).is( 'element', 'tableCell' ) ) {
+			const boundaryPosition = model.createPositionAt( tableCell, isForward ? 'end' : 0 );
+
+			return boundaryPosition.isTouching( focus );
+		}
+
+		const probe = model.createSelection( focus );
+
+		model.modifySelection( probe, { direction: isForward ? 'forward' : 'backward' } );
+
+		// If there was no change in the focus position, then it's not possible to move the selection there.
+		return focus.isEqual( probe.focus );
+	}
+
+	/**
+	 * Moves the selection from the given table cell in the specified direction.
+	 *
+	 * @protected
+	 * @param {module:engine/model/element~Element} focusCell The table cell that is current multi-cell selection focus.
+	 * @param {'left'|'up'|'right'|'down'} direction Direction in which selection should move.
+	 * @param {Boolean} [expandSelection=false] If the current selection should be expanded.
+	 */
+	_navigateFromCellInDirection( focusCell, direction, expandSelection = false ) {
+		const model = this.editor.model;
+
+		const table = focusCell.findAncestor( 'table' );
+		const tableMap = [ ...new TableWalker( table, { includeAllSlots: true } ) ];
+		const { row: lastRow, column: lastColumn } = tableMap[ tableMap.length - 1 ];
+
+		const currentCellInfo = tableMap.find( ( { cell } ) => cell == focusCell );
+		let { row, column } = currentCellInfo;
+
+		switch ( direction ) {
+			case 'left':
+				column--;
+				break;
+
+			case 'up':
+				row--;
+				break;
+
+			case 'right':
+				column += currentCellInfo.cellWidth;
+				break;
+
+			case 'down':
+				row += currentCellInfo.cellHeight;
+				break;
+		}
+
+		const isOutsideVertically = row < 0 || row > lastRow;
+		const isBeforeFirstCell = column < 0 && row <= 0;
+		const isAfterLastCell = column > lastColumn && row >= lastRow;
+
+		// Note that if the table cell at the end of a row is row-spanned then isAfterLastCell will never be true.
+		// However, we don't know if user was navigating on the last row or not, so let's stay in the table.
+
+		if ( isOutsideVertically || isBeforeFirstCell || isAfterLastCell ) {
+			model.change( writer => {
+				writer.setSelection( writer.createRangeOn( table ) );
+			} );
+
+			return;
+		}
+
+		if ( column < 0 ) {
+			column = expandSelection ? 0 : lastColumn;
+			row--;
+		} else if ( column > lastColumn ) {
+			column = expandSelection ? lastColumn : 0;
+			row++;
+		}
+
+		const cellToSelect = tableMap.find( cellInfo => cellInfo.row == row && cellInfo.column == column ).cell;
+		const isForward = [ 'right', 'down' ].includes( direction );
+		const tableSelection = this.editor.plugins.get( 'TableSelection' );
+
+		if ( expandSelection && tableSelection.isEnabled ) {
+			const anchorCell = tableSelection.getAnchorCell() || focusCell;
+
+			tableSelection.setCellSelection( anchorCell, cellToSelect );
+		} else {
+			const positionToSelect = model.createPositionAt( cellToSelect, isForward ? 0 : 'end' );
+
+			model.change( writer => {
+				writer.setSelection( positionToSelect );
+			} );
+		}
+	}
+}
+

package/src/assets/qms-ckeditor-plugin/src/plugins/table/tablemouse/mouseeventsobserver.js

@@ -0,0 +1,72 @@
+/**
+ * @license Copyright (c) 2003-2021, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module table/tableselection/mouseeventsobserver
+ */
+
+import { DomEventObserver } from 'ckeditor5/src/engine';
+
+/**
+ * The mouse selection event observer.
+ *
+ * It registers listeners for the following DOM events:
+ *
+ * - `'mousemove'`
+ * - `'mouseup'`
+ * - `'mouseleave'`
+ *
+ * Note that this observer is disabled by default. To enable this observer, it needs to be added to
+ * {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * The observer is registered by the {@link module:table/tableselection~TableSelection} plugin.
+ *
+ * @extends module:engine/view/observer/domeventobserver~DomEventObserver
+ */
+export default class MouseEventsObserver extends DomEventObserver {
+	/**
+	 * @inheritDoc
+	 */
+	constructor( view ) {
+		super( view );
+
+		this.domEventType = [ 'mousemove', 'mouseleave' ];
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	onDomEvent( domEvent ) {
+		this.fire( domEvent.type, domEvent );
+	}
+}
+
+/**
+ * Fired when the mouse is moved over one of the editables.
+ *
+ * Introduced by {@link module:table/tableselection/mouseeventsobserver~MouseEventsObserver}.
+ *
+ * Note that this event is not available by default. To make it available,
+ * {@link module:table/tableselection/mouseeventsobserver~MouseEventsObserver} needs to be added
+ * to {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:table/tableselection/mouseeventsobserver~MouseEventsObserver
+ * @event module:engine/view/document~Document#event:mousemove
+ * @param {module:engine/view/observer/domeventdata~DomEventData} data Event data.
+ */
+
+/**
+ * Fired when the mouse is moved out of one of the editables.
+ *
+ * Introduced by {@link module:table/tableselection/mouseeventsobserver~MouseEventsObserver}.
+ *
+ * Note that this event is not available by default. To make it available,
+ * {@link module:table/tableselection/mouseeventsobserver~MouseEventsObserver} needs to be added
+ * to {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:table/tableselection/mouseeventsobserver~MouseEventsObserver
+ * @event module:engine/view/document~Document#event:mouseleave
+ * @param {module:engine/view/observer/domeventdata~DomEventData} data Event data.
+ */