qms-angular 1.0.86 → 1.0.89

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

@@ -0,0 +1,122 @@
+/**
+ * @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/commands/removecolumncommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+
+import TableWalker from '../tablewalker';
+import { getColumnIndexes, getSelectionAffectedTableCells } from '../utils/selection';
+
+/**
+ * The remove column command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'removeTableColumn'` editor command.
+ *
+ * To remove the column containing the selected cell, execute the command:
+ *
+ *		editor.execute( 'removeTableColumn' );
+ *
+ * @extends module:core/command~Command
+ */
+export default class RemoveColumnCommand extends Command {
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const selectedCells = getSelectionAffectedTableCells( this.editor.model.document.selection );
+		const firstCell = selectedCells[ 0 ];
+
+		if ( firstCell ) {
+			const table = firstCell.findAncestor( 'table' );
+			const tableColumnCount = this.editor.plugins.get( 'TableUtils' ).getColumns( table );
+
+			const { first, last } = getColumnIndexes( selectedCells );
+
+			this.isEnabled = last - first < ( tableColumnCount - 1 );
+		} else {
+			this.isEnabled = false;
+		}
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	execute() {
+		const [ firstCell, lastCell ] = getBoundaryCells( this.editor.model.document.selection );
+		const table = firstCell.parent.parent;
+
+		// Cache the table before removing or updating colspans.
+		const tableMap = [ ...new TableWalker( table ) ];
+
+		// Store column indexes of removed columns.
+		const removedColumnIndexes = {
+			first: tableMap.find( value => value.cell === firstCell ).column,
+			last: tableMap.find( value => value.cell === lastCell ).column
+		};
+
+		const cellToFocus = getCellToFocus( tableMap, firstCell, lastCell, removedColumnIndexes );
+
+		this.editor.model.change( writer => {
+			const columnsToRemove = removedColumnIndexes.last - removedColumnIndexes.first + 1;
+
+			this.editor.plugins.get( 'TableUtils' ).removeColumns( table, {
+				at: removedColumnIndexes.first,
+				columns: columnsToRemove
+			} );
+
+			writer.setSelection( writer.createPositionAt( cellToFocus, 0 ) );
+		} );
+	}
+}
+
+// Returns a proper table cell to focus after removing a column.
+// - selection is on last table cell it will return previous cell.
+function getCellToFocus( tableMap, firstCell, lastCell, removedColumnIndexes ) {
+	const colspan = parseInt( lastCell.getAttribute( 'colspan' ) || 1 );
+
+	// If the table cell is spanned over 2+ columns - it will be truncated so the selection should
+	// stay in that cell.
+	if ( colspan > 1 ) {
+		return lastCell;
+	}
+	// Normally, look for the cell in the same row that precedes the first cell to put selection there ("column on the left").
+	// If the deleted column is the first column of the table, there will be no predecessor: use the cell
+	// from the column that follows then (also in the same row).
+	else if ( firstCell.previousSibling || lastCell.nextSibling ) {
+		return lastCell.nextSibling || firstCell.previousSibling;
+	}
+	// It can happen that table cells have no siblings in a row, for instance, when there are row spans
+	// in the table (in the previous row). Then just look for the closest cell that is in a column
+	// that will not be removed to put the selection there.
+	else {
+		// Look for any cell in a column that precedes the first removed column.
+		if ( removedColumnIndexes.first ) {
+			return tableMap.reverse().find( ( { column } ) => {
+				return column < removedColumnIndexes.first;
+			} ).cell;
+		}
+		// If the first removed column is the first column of the table, then
+		// look for any cell that is in a column that follows the last removed column.
+		else {
+			return tableMap.reverse().find( ( { column } ) => {
+				return column > removedColumnIndexes.last;
+			} ).cell;
+		}
+	}
+}
+
+// Returns helper object returning the first and the last cell contained in given selection, based on DOM order.
+function getBoundaryCells( selection ) {
+	const referenceCells = getSelectionAffectedTableCells( selection );
+	const firstCell = referenceCells[ 0 ];
+	const lastCell = referenceCells.pop();
+
+	const returnValue = [ firstCell, lastCell ];
+
+	return firstCell.isBefore( lastCell ) ? returnValue : returnValue.reverse();
+}

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

@@ -0,0 +1,97 @@
+/**
+ * @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/commands/removerowcommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+
+import { getRowIndexes, getSelectionAffectedTableCells } from '../utils/selection';
+
+/**
+ * The remove row command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'removeTableRow'` editor command.
+ *
+ * To remove the row containing the selected cell, execute the command:
+ *
+ *		editor.execute( 'removeTableRow' );
+ *
+ * @extends module:core/command~Command
+ */
+export default class RemoveRowCommand extends Command {
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const selectedCells = getSelectionAffectedTableCells( this.editor.model.document.selection );
+		const firstCell = selectedCells[ 0 ];
+
+		if ( firstCell ) {
+			const table = firstCell.findAncestor( 'table' );
+			const tableRowCount = this.editor.plugins.get( 'TableUtils' ).getRows( table );
+			const lastRowIndex = tableRowCount - 1;
+
+			const selectedRowIndexes = getRowIndexes( selectedCells );
+
+			const areAllRowsSelected = selectedRowIndexes.first === 0 && selectedRowIndexes.last === lastRowIndex;
+
+			// Disallow selecting whole table -> delete whole table should be used instead.
+			this.isEnabled = !areAllRowsSelected;
+		} else {
+			this.isEnabled = false;
+		}
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	execute() {
+		const model = this.editor.model;
+		const referenceCells = getSelectionAffectedTableCells( model.document.selection );
+		const removedRowIndexes = getRowIndexes( referenceCells );
+
+		const firstCell = referenceCells[ 0 ];
+		const table = firstCell.findAncestor( 'table' );
+
+		const columnIndexToFocus = this.editor.plugins.get( 'TableUtils' ).getCellLocation( firstCell ).column;
+
+		model.change( writer => {
+			const rowsToRemove = removedRowIndexes.last - removedRowIndexes.first + 1;
+
+			this.editor.plugins.get( 'TableUtils' ).removeRows( table, {
+				at: removedRowIndexes.first,
+				rows: rowsToRemove
+			} );
+
+			const cellToFocus = getCellToFocus( table, removedRowIndexes.first, columnIndexToFocus );
+
+			writer.setSelection( writer.createPositionAt( cellToFocus, 0 ) );
+		} );
+	}
+}
+
+// Returns a cell that should be focused before removing the row, belonging to the same column as the currently focused cell.
+// * If the row was not the last one, the cell to focus will be in the row that followed it (before removal).
+// * If the row was the last one, the cell to focus will be in the row that preceded it (before removal).
+function getCellToFocus( table, removedRowIndex, columnToFocus ) {
+	const row = table.getChild( removedRowIndex ) || table.getChild( table.childCount - 1 );
+
+	// Default to first table cell.
+	let cellToFocus = row.getChild( 0 );
+	let column = 0;
+
+	for ( const tableCell of row.getChildren() ) {
+		if ( column > columnToFocus ) {
+			return cellToFocus;
+		}
+
+		cellToFocus = tableCell;
+		column += parseInt( tableCell.getAttribute( 'colspan' ) || 1 );
+	}
+
+	return cellToFocus;
+}

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

@@ -0,0 +1,63 @@
+/**
+ * @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/commands/selectcolumncommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+
+import TableWalker from '../tablewalker';
+import { getSelectionAffectedTableCells } from '../utils/selection';
+
+/**
+ * The select column command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'selectTableColumn'` editor command.
+ *
+ * To select the columns containing the selected cells, execute the command:
+ *
+ *		editor.execute( 'selectTableColumn' );
+ *
+ * @extends module:core/command~Command
+ */
+export default class SelectColumnCommand extends Command {
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const selectedCells = getSelectionAffectedTableCells( this.editor.model.document.selection );
+
+		this.isEnabled = selectedCells.length > 0;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	execute() {
+		const model = this.editor.model;
+		const referenceCells = getSelectionAffectedTableCells( model.document.selection );
+		const firstCell = referenceCells[ 0 ];
+		const lastCell = referenceCells.pop();
+		const table = firstCell.findAncestor( 'table' );
+
+		const tableUtils = this.editor.plugins.get( 'TableUtils' );
+		const startLocation = tableUtils.getCellLocation( firstCell );
+		const endLocation = tableUtils.getCellLocation( lastCell );
+
+		const startColumn = Math.min( startLocation.column, endLocation.column );
+		const endColumn = Math.max( startLocation.column, endLocation.column );
+
+		const rangesToSelect = [];
+
+		for ( const cellInfo of new TableWalker( table, { startColumn, endColumn } ) ) {
+			rangesToSelect.push( model.createRangeOn( cellInfo.cell ) );
+		}
+
+		model.change( writer => {
+			writer.setSelection( rangesToSelect );
+		} );
+	}
+}

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

@@ -0,0 +1,56 @@
+/**
+ * @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/commands/selectrowcommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+
+import { getRowIndexes, getSelectionAffectedTableCells } from '../utils/selection';
+
+/**
+ * The select row command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'selectTableRow'` editor command.
+ *
+ * To select the rows containing the selected cells, execute the command:
+ *
+ *		editor.execute( 'selectTableRow' );
+ *
+ * @extends module:core/command~Command
+ */
+export default class SelectRowCommand extends Command {
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const selectedCells = getSelectionAffectedTableCells( this.editor.model.document.selection );
+
+		this.isEnabled = selectedCells.length > 0;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	execute() {
+		const model = this.editor.model;
+		const referenceCells = getSelectionAffectedTableCells( model.document.selection );
+		const rowIndexes = getRowIndexes( referenceCells );
+
+		const table = referenceCells[ 0 ].findAncestor( 'table' );
+		const rangesToSelect = [];
+
+		for ( let rowIndex = rowIndexes.first; rowIndex <= rowIndexes.last; rowIndex++ ) {
+			for ( const cell of table.getChild( rowIndex ).getChildren() ) {
+				rangesToSelect.push( model.createRangeOn( cell ) );
+			}
+		}
+
+		model.change( writer => {
+			writer.setSelection( rangesToSelect );
+		} );
+	}
+}

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

@@ -0,0 +1,95 @@
+/**
+ * @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/commands/setheadercolumncommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+
+import {
+	isHeadingColumnCell,
+	updateNumericAttribute
+} from '../utils/common';
+import { getColumnIndexes, getSelectionAffectedTableCells } from '../utils/selection';
+import { getHorizontallyOverlappingCells, splitVertically } from '../utils/structure';
+
+/**
+ * The header column command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'setTableColumnHeader'` editor command.
+ *
+ * You can make the column containing the selected cell a [header](https://www.w3.org/TR/html50/tabular-data.html#the-th-element)
+ * by executing:
+ *
+ *		editor.execute( 'setTableColumnHeader' );
+ *
+ * **Note:** All preceding columns will also become headers. If the current column is already a header, executing this command
+ * will make it a regular column back again (including the following columns).
+ *
+ * @extends module:core/command~Command
+ */
+export default class SetHeaderColumnCommand extends Command {
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const model = this.editor.model;
+		const selectedCells = getSelectionAffectedTableCells( model.document.selection );
+		const tableUtils = this.editor.plugins.get( 'TableUtils' );
+		const isInTable = selectedCells.length > 0;
+
+		this.isEnabled = isInTable;
+
+		/**
+		 * Flag indicating whether the command is active. The command is active when the
+		 * {@link module:engine/model/selection~Selection} is in a header column.
+		 *
+		 * @observable
+		 * @readonly
+		 * @member {Boolean} #value
+		 */
+		this.value = isInTable && selectedCells.every( cell => isHeadingColumnCell( tableUtils, cell ) );
+	}
+
+	/**
+	 * Executes the command.
+	 *
+	 * When the selection is in a non-header column, the command will set the `headingColumns` table attribute to cover that column.
+	 *
+	 * When the selection is already in a header column, it will set `headingColumns` so the heading section will end before that column.
+	 *
+	 * @fires execute
+	 * @param {Object} [options]
+	 * @param {Boolean} [options.forceValue] If set, the command will set (`true`) or unset (`false`) the header columns according to
+	 * the `forceValue` parameter instead of the current model state.
+	 */
+	execute( options = {} ) {
+		if ( options.forceValue === this.value ) {
+			return;
+		}
+
+		const model = this.editor.model;
+		const selectedCells = getSelectionAffectedTableCells( model.document.selection );
+		const table = selectedCells[ 0 ].findAncestor( 'table' );
+
+		const { first, last } = getColumnIndexes( selectedCells );
+		const headingColumnsToSet = this.value ? first : last + 1;
+
+		model.change( writer => {
+			if ( headingColumnsToSet ) {
+				// Changing heading columns requires to check if any of a heading cell is overlapping horizontally the table head.
+				// Any table cell that has a colspan attribute > 1 will not exceed the table head so we need to fix it in columns before.
+				const overlappingCells = getHorizontallyOverlappingCells( table, headingColumnsToSet );
+
+				for ( const { cell, column } of overlappingCells ) {
+					splitVertically( cell, column, headingColumnsToSet, writer );
+				}
+			}
+
+			updateNumericAttribute( 'headingColumns', headingColumnsToSet, table, writer, 0 );
+		} );
+	}
+}

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

@@ -0,0 +1,105 @@
+/**
+ * @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/commands/setheaderrowcommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+
+import { updateNumericAttribute } from '../utils/common';
+import { getRowIndexes, getSelectionAffectedTableCells } from '../utils/selection';
+import { getVerticallyOverlappingCells, splitHorizontally } from '../utils/structure';
+
+/**
+ * The header row command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'setTableColumnHeader'` editor command.
+ *
+ * You can make the row containing the selected cell a [header](https://www.w3.org/TR/html50/tabular-data.html#the-th-element) by executing:
+ *
+ *		editor.execute( 'setTableRowHeader' );
+ *
+ * **Note:** All preceding rows will also become headers. If the current row is already a header, executing this command
+ * will make it a regular row back again (including the following rows).
+ *
+ * @extends module:core/command~Command
+ */
+export default class SetHeaderRowCommand extends Command {
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const model = this.editor.model;
+		const selectedCells = getSelectionAffectedTableCells( model.document.selection );
+		const isInTable = selectedCells.length > 0;
+
+		this.isEnabled = isInTable;
+
+		/**
+		 * Flag indicating whether the command is active. The command is active when the
+		 * {@link module:engine/model/selection~Selection} is in a header row.
+		 *
+		 * @observable
+		 * @readonly
+		 * @member {Boolean} #value
+		 */
+		this.value = isInTable && selectedCells.every( cell => this._isInHeading( cell, cell.parent.parent ) );
+	}
+
+	/**
+	 * Executes the command.
+	 *
+	 * When the selection is in a non-header row, the command will set the `headingRows` table attribute to cover that row.
+	 *
+	 * When the selection is already in a header row, it will set `headingRows` so the heading section will end before that row.
+	 *
+	 * @fires execute
+	 * @param {Object} options
+	 * @param {Boolean} [options.forceValue] If set, the command will set (`true`) or unset (`false`) the header rows according to
+	 * the `forceValue` parameter instead of the current model state.
+	 */
+	execute( options = {} ) {
+		if ( options.forceValue === this.value ) {
+			return;
+		}
+		const model = this.editor.model;
+		const selectedCells = getSelectionAffectedTableCells( model.document.selection );
+		const table = selectedCells[ 0 ].findAncestor( 'table' );
+
+		const { first, last } = getRowIndexes( selectedCells );
+		const headingRowsToSet = this.value ? first : last + 1;
+		const currentHeadingRows = table.getAttribute( 'headingRows' ) || 0;
+
+		model.change( writer => {
+			if ( headingRowsToSet ) {
+				// Changing heading rows requires to check if any of a heading cell is overlapping vertically the table head.
+				// Any table cell that has a rowspan attribute > 1 will not exceed the table head so we need to fix it in rows below.
+				const startRow = headingRowsToSet > currentHeadingRows ? currentHeadingRows : 0;
+				const overlappingCells = getVerticallyOverlappingCells( table, headingRowsToSet, startRow );
+
+				for ( const { cell } of overlappingCells ) {
+					splitHorizontally( cell, headingRowsToSet, writer );
+				}
+			}
+
+			updateNumericAttribute( 'headingRows', headingRowsToSet, table, writer, 0 );
+		} );
+	}
+
+	/**
+	 * Checks if a table cell is in the heading section.
+	 *
+	 * @param {module:engine/model/element~Element} tableCell
+	 * @param {module:engine/model/element~Element} table
+	 * @returns {Boolean}
+	 * @private
+	 */
+	_isInHeading( tableCell, table ) {
+		const headingRows = parseInt( table.getAttribute( 'headingRows' ) || 0 );
+
+		return !!headingRows && tableCell.parent.index < headingRows;
+	}
+}

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

@@ -0,0 +1,68 @@
+/**
+ * @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/commands/splitcellcommand
+ */
+
+import { Command } from 'ckeditor5/src/core';
+import { getSelectionAffectedTableCells } from '../utils/selection';
+
+/**
+ * The split cell command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'splitTableCellVertically'`
+ * and `'splitTableCellHorizontally'`  editor commands.
+ *
+ * You can split any cell vertically or horizontally by executing this command. For example, to split the selected table cell vertically:
+ *
+ *		editor.execute( 'splitTableCellVertically' );
+ *
+ * @extends module:core/command~Command
+ */
+export default class SplitCellCommand extends Command {
+	/**
+	 * Creates a new `SplitCellCommand` instance.
+	 *
+	 * @param {module:core/editor/editor~Editor} editor The editor on which this command will be used.
+	 * @param {Object} options
+	 * @param {String} options.direction Indicates whether the command should split cells `'horizontally'` or `'vertically'`.
+	 */
+	constructor( editor, options = {} ) {
+		super( editor );
+
+		/**
+		 * The direction that indicates which cell will be split.
+		 *
+		 * @readonly
+		 * @member {String} #direction
+		 */
+		this.direction = options.direction || 'horizontally';
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	refresh() {
+		const selectedCells = getSelectionAffectedTableCells( this.editor.model.document.selection );
+
+		this.isEnabled = selectedCells.length === 1;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	execute() {
+		const tableCell = getSelectionAffectedTableCells( this.editor.model.document.selection )[ 0 ];
+		const isHorizontal = this.direction === 'horizontally';
+		const tableUtils = this.editor.plugins.get( 'TableUtils' );
+
+		if ( isHorizontal ) {
+			tableUtils.splitCellHorizontally( tableCell, 2 );
+		} else {
+			tableUtils.splitCellVertically( tableCell, 2 );
+		}
+	}
+}