qms-angular 1.0.86 → 1.0.89

package/src/assets/qms-ckeditor-plugin/src/plugins/table/converters/table-cell-refresh-post-fixer.js

@@ -0,0 +1,75 @@
+/**
+ * @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/converters/table-cell-refresh-post-fixer
+ */
+
+import { isSingleParagraphWithoutAttributes } from './downcast';
+
+/**
+ * Injects a table cell post-fixer into the model which marks the table cell in the differ to have it re-rendered.
+ *
+ * Model `paragraph` inside a table cell can be rendered as `<span>` or `<p>`. It is rendered as `<span>` if this is the only block
+ * element in that table cell and it does not have any attributes. It is rendered as `<p>` otherwise.
+ *
+ * When table cell content changes, for example a second `paragraph` element is added, we need to ensure that the first `paragraph` is
+ * re-rendered so it changes from `<span>` to `<p>`. The easiest way to do it is to re-render the entire table cell.
+ *
+ * @param {module:engine/model/model~Model} model
+ * @param {module:engine/conversion/mapper~Mapper} mapper
+ */
+export default function injectTableCellRefreshPostFixer( model, mapper ) {
+	model.document.registerPostFixer( () => tableCellRefreshPostFixer( model.document.differ, mapper ) );
+}
+
+function tableCellRefreshPostFixer( differ, mapper ) {
+	// Stores cells to be refreshed, so the table cell will be refreshed once for multiple changes.
+
+	// 1. Gather all changes inside table cell.
+	const cellsToCheck = new Set();
+
+	for ( const change of differ.getChanges() ) {
+		const parent = change.type == 'attribute' ? change.range.start.parent : change.position.parent;
+
+		if ( parent.is( 'element', 'tableCell' ) ) {
+			cellsToCheck.add( parent );
+		}
+	}
+
+	// @if CK_DEBUG_TABLE // console.log( `Post-fixing table: Checking table cell to refresh (${ cellsToCheck.size }).` );
+	// @if CK_DEBUG_TABLE // let paragraphsRefreshed = 0;
+
+	for ( const tableCell of cellsToCheck.values() ) {
+		for ( const paragraph of [ ...tableCell.getChildren() ].filter( child => shouldRefresh( child, mapper ) ) ) {
+			// @if CK_DEBUG_TABLE // console.log( `Post-fixing table: refreshing paragraph in table cell (${++paragraphsRefreshed}).` );
+			differ.refreshItem( paragraph );
+		}
+	}
+
+	// Always return false to prevent the refresh post-fixer from re-running on the same set of changes and going into an infinite loop.
+	// This "post-fixer" does not change the model structure so there shouldn't be need to run other post-fixers again.
+	// See https://github.com/ckeditor/ckeditor5/issues/1936 & https://github.com/ckeditor/ckeditor5/issues/8200.
+	return false;
+}
+
+// Check if given model element needs refreshing.
+//
+// @param {module:engine/model/element~Element} modelElement
+// @param {module:engine/conversion/mapper~Mapper} mapper
+// @returns {Boolean}
+function shouldRefresh( child, mapper ) {
+	if ( !child.is( 'element', 'paragraph' ) ) {
+		return false;
+	}
+
+	const viewElement = mapper.toViewElement( child );
+
+	if ( !viewElement ) {
+		return false;
+	}
+
+	return isSingleParagraphWithoutAttributes( child ) !== viewElement.is( 'element', 'span' );
+}

package/src/assets/qms-ckeditor-plugin/src/plugins/table/converters/table-heading-rows-refresh-post-fixer.js

@@ -0,0 +1,55 @@
+/**
+ * @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/converters/table-heading-rows-refresh-post-fixer
+ */
+
+/**
+ * Injects a table post-fixer into the model which marks the table in the differ to have it re-rendered.
+ *
+ * Table heading rows are represented in the model by a `headingRows` attribute. However, in the view, it's represented as separate
+ * sections of the table (`<thead>` or `<tbody>`) and changing `headingRows` attribute requires moving table rows between two sections.
+ * This causes problems with structural changes in a table (like adding and removing rows) thus atomic converters cannot be used.
+ *
+ * When table `headingRows` attribute changes, the entire table is re-rendered.
+ *
+ * @param {module:engine/model/model~Model} model
+ */
+export default function injectTableHeadingRowsRefreshPostFixer( model ) {
+	model.document.registerPostFixer( () => tableHeadingRowsRefreshPostFixer( model ) );
+}
+
+function tableHeadingRowsRefreshPostFixer( model ) {
+	const differ = model.document.differ;
+
+	// Stores tables to be refreshed so the table will be refreshed once for multiple changes.
+	const tablesToRefresh = new Set();
+
+	for ( const change of differ.getChanges() ) {
+		if ( change.type != 'attribute' ) {
+			continue;
+		}
+
+		const element = change.range.start.nodeAfter;
+
+		if ( element && element.is( 'element', 'table' ) && change.attributeKey == 'headingRows' ) {
+			tablesToRefresh.add( element );
+		}
+	}
+
+	if ( tablesToRefresh.size ) {
+		// @if CK_DEBUG_TABLE // console.log( `Post-fixing table: refreshing heading rows (${ tablesToRefresh.size }).` );
+
+		for ( const table of tablesToRefresh.values() ) {
+			// Should be handled by a `triggerBy` configuration. See: https://github.com/ckeditor/ckeditor5/issues/8138.
+			differ.refreshItem( table );
+		}
+
+		return true;
+	}
+
+	return false;
+}

package/src/assets/qms-ckeditor-plugin/src/plugins/table/converters/table-layout-post-fixer.js

@@ -0,0 +1,399 @@
+/**
+ * @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/converters/table-layout-post-fixer
+ */
+
+import TableWalker from './../tablewalker';
+import { createEmptyTableCell, updateNumericAttribute } from '../utils/common';
+
+/**
+ * Injects a table layout post-fixer into the model.
+ *
+ * The role of the table layout post-fixer is to ensure that the table rows have the correct structure
+ * after a {@link module:engine/model/model~Model#change `change()`} block was executed.
+ *
+ * The correct structure means that:
+ *
+ * * All table rows have the same size.
+ * * None of the table cells extend vertically beyond their section (either header or body).
+ * * A table cell has always at least one element as a child.
+ *
+ * If the table structure is not correct, the post-fixer will automatically correct it in two steps:
+ *
+ * 1. It will clip table cells that extend beyond their section.
+ * 2. It will add empty table cells to the rows that are narrower than the widest table row.
+ *
+ * ## Clipping overlapping table cells
+ *
+ * Such situation may occur when pasting a table (or a part of a table) to the editor from external sources.
+ *
+ * For example, see the following table which has a cell (FOO) with the rowspan attribute (2):
+ *
+ *		<table headingRows="1">
+ *			<tableRow>
+ *				<tableCell rowspan="2"><paragraph>FOO</paragraph></tableCell>
+ *				<tableCell colspan="2"><paragraph>BAR</paragraph></tableCell>
+ *			</tableRow>
+ *			<tableRow>
+ *				<tableCell><paragraph>BAZ</paragraph></tableCell>
+ *				<tableCell><paragraph>XYZ</paragraph></tableCell>
+ *			</tableRow>
+ *		</table>
+ *
+ * It will be rendered in the view as:
+ *
+ *		<table>
+ *			<thead>
+ *				<tr>
+ *					<td rowspan="2">FOO</td>
+ *					<td colspan="2">BAR</td>
+ *				</tr>
+ *			</thead>
+ *			<tbody>
+ *				<tr>
+ *					<td>BAZ</td>
+ *					<td>XYZ</td>
+ *				</tr>
+ *			</tbody>
+ *		</table>
+ *
+ * In the above example the table will be rendered as a table with two rows: one in the header and second one in the body.
+ * The table cell (FOO) cannot span over multiple rows as it would extend from the header to the body section.
+ * The `rowspan` attribute must be changed to (1). The value (1) is the default value of the `rowspan` attribute
+ * so the `rowspan` attribute will be removed from the model.
+ *
+ * The table cell with BAZ in the content will be in the first column of the table.
+ *
+ * ## Adding missing table cells
+ *
+ * The table post-fixer will insert empty table cells to equalize table row sizes (the number of columns).
+ * The size of a table row is calculated by counting column spans of table cells, both horizontal (from the same row) and
+ * vertical (from the rows above).
+ *
+ * In the above example, the table row in the body section of the table is narrower then the row from the header: it has two cells
+ * with the default colspan (1). The header row has one cell with colspan (1) and the second with colspan (2).
+ * The table cell (FOO) does not extend beyond the head section (and as such will be fixed in the first step of this post-fixer).
+ * The post-fixer will add a missing table cell to the row in the body section of the table.
+ *
+ * The table from the above example will be fixed and rendered to the view as below:
+ *
+ *		<table>
+ *			<thead>
+ *				<tr>
+ *					<td rowspan="2">FOO</td>
+ *					<td colspan="2">BAR</td>
+ *				</tr>
+ *			</thead>
+ *			<tbody>
+ *				<tr>
+ *					<td>BAZ</td>
+ *					<td>XYZ</td>
+ *				</tr>
+ *			</tbody>
+ *		</table>
+ *
+ * ## Collaboration and undo - Expectations vs post-fixer results
+ *
+ * The table post-fixer only ensures proper structure without a deeper analysis of the nature of the change. As such, it might lead
+ * to a structure which was not intended by the user. In particular, it will also fix undo steps (in conjunction with collaboration)
+ * in which the editor content might not return to the original state.
+ *
+ * This will usually happen when one or more users change the size of the table.
+ *
+ * As an example see the table below:
+ *
+ *		<table>
+ *			<tbody>
+ *				<tr>
+ *					<td>11</td>
+ *					<td>12</td>
+ *				</tr>
+ *				<tr>
+ *					<td>21</td>
+ *					<td>22</td>
+ *				</tr>
+ *			</tbody>
+ *		</table>
+ *
+ * and the user actions:
+ *
+ * 1. Both users have a table with two rows and two columns.
+ * 2. User A adds a column at the end of the table. This will insert empty table cells to two rows.
+ * 3. User B adds a row at the end of the table. This will insert a row with two empty table cells.
+ * 4. Both users will have a table as below:
+ *
+ *
+ *		<table>
+ *			<tbody>
+ *				<tr>
+ *					<td>11</td>
+ *					<td>12</td>
+ *					<td>(empty, inserted by A)</td>
+ *				</tr>
+ *				<tr>
+ *					<td>21</td>
+ *					<td>22</td>
+ *					<td>(empty, inserted by A)</td>
+ *				</tr>
+ *				<tr>
+ *					<td>(empty, inserted by B)</td>
+ *					<td>(empty, inserted by B)</td>
+ *				</tr>
+ *			</tbody>
+ *		</table>
+ *
+ * The last row is shorter then others so the table post-fixer will add an empty row to the last row:
+ *
+ *		<table>
+ *			<tbody>
+ *				<tr>
+ *					<td>11</td>
+ *					<td>12</td>
+ *					<td>(empty, inserted by A)</td>
+ *				</tr>
+ *				<tr>
+ *					<td>21</td>
+ *					<td>22</td>
+ *					<td>(empty, inserted by A)</td>
+ *				</tr>
+ *				<tr>
+ *					<td>(empty, inserted by B)</td>
+ *					<td>(empty, inserted by B)</td>
+ *					<td>(empty, inserted by the post-fixer)</td>
+ *				</tr>
+ *			</tbody>
+ *		</table>
+ *
+ * Unfortunately undo does not know the nature of the changes and depending on which user applies the post-fixer changes, undoing them
+ * might lead to a broken table. If User B undoes inserting the column to the table, the undo engine will undo only the operations of
+ * inserting empty cells to rows from the initial table state (row 1 and 2) but the cell in the post-fixed row will remain:
+ *
+ *		<table>
+ *			<tbody>
+ *				<tr>
+ *					<td>11</td>
+ *					<td>12</td>
+ *				</tr>
+ *				<tr>
+ *					<td>21</td>
+ *					<td>22</td>
+ *				</tr>
+ *				<tr>
+ *					<td>(empty, inserted by B)</td>
+ *					<td>(empty, inserted by B)</td>
+ *					<td>(empty, inserted by a post-fixer)</td>
+ *				</tr>
+ *			</tbody>
+ *		</table>
+ *
+ * After undo, the table post-fixer will detect that two rows are shorter than others and will fix the table to:
+ *
+ *		<table>
+ *			<tbody>
+ *				<tr>
+ *					<td>11</td>
+ *					<td>12</td>
+ *					<td>(empty, inserted by a post-fixer after undo)</td>
+ *				</tr>
+ *				<tr>
+ *					<td>21</td>
+ *					<td>22</td>
+ *					<td>(empty, inserted by a post-fixer after undo)</td>
+ *				</tr>
+ *				<tr>
+ *					<td>(empty, inserted by B)</td>
+ *					<td>(empty, inserted by B)</td>
+ *					<td>(empty, inserted by a post-fixer)</td>
+ *				</tr>
+ *			</tbody>
+ *		</table>
+ * @param {module:engine/model/model~Model} model
+ */
+export default function injectTableLayoutPostFixer( model ) {
+	model.document.registerPostFixer( writer => tableLayoutPostFixer( writer, model ) );
+}
+
+// The table layout post-fixer.
+//
+// @param {module:engine/model/writer~Writer} writer
+// @param {module:engine/model/model~Model} model
+function tableLayoutPostFixer( writer, model ) {
+	const changes = model.document.differ.getChanges();
+
+	let wasFixed = false;
+
+	// Do not analyze the same table more then once - may happen for multiple changes in the same table.
+	const analyzedTables = new Set();
+
+	for ( const entry of changes ) {
+		let table;
+
+		if ( entry.name == 'table' && entry.type == 'insert' ) {
+			table = entry.position.nodeAfter;
+		}
+
+		// Fix table on adding/removing table cells and rows.
+		if ( entry.name == 'tableRow' || entry.name == 'tableCell' ) {
+			table = entry.position.findAncestor( 'table' );
+		}
+
+		// Fix table on any table's attribute change - including attributes of table cells.
+		if ( isTableAttributeEntry( entry ) ) {
+			table = entry.range.start.findAncestor( 'table' );
+		}
+
+		if ( table && !analyzedTables.has( table ) ) {
+			// Step 1: correct rowspans of table cells if necessary.
+			// The wasFixed flag should be true if any of tables in batch was fixed - might be more then one.
+			wasFixed = fixTableCellsRowspan( table, writer ) || wasFixed;
+			// Step 2: fix table rows sizes.
+			wasFixed = fixTableRowsSizes( table, writer ) || wasFixed;
+
+			analyzedTables.add( table );
+		}
+	}
+
+	return wasFixed;
+}
+
+// Fixes the invalid value of the `rowspan` attribute because a table cell cannot vertically extend beyond the table section it belongs to.
+//
+// @param {module:engine/model/element~Element} table
+// @param {module:engine/model/writer~Writer} writer
+// @returns {Boolean} Returns `true` if the table was fixed.
+function fixTableCellsRowspan( table, writer ) {
+	let wasFixed = false;
+
+	const cellsToTrim = findCellsToTrim( table );
+
+	if ( cellsToTrim.length ) {
+		// @if CK_DEBUG_TABLE // console.log( `Post-fixing table: trimming cells row-spans (${ cellsToTrim.length }).` );
+
+		wasFixed = true;
+
+		for ( const data of cellsToTrim ) {
+			updateNumericAttribute( 'rowspan', data.rowspan, data.cell, writer, 1 );
+		}
+	}
+
+	return wasFixed;
+}
+
+// Makes all table rows in a table the same size.
+//
+// @param {module:engine/model/element~Element} table
+// @param {module:engine/model/writer~Writer} writer
+// @returns {Boolean} Returns `true` if the table was fixed.
+function fixTableRowsSizes( table, writer ) {
+	let wasFixed = false;
+
+	const rowsLengths = getRowsLengths( table );
+	const rowsToRemove = [];
+
+	// Find empty rows.
+	for ( const [ rowIndex, size ] of rowsLengths.entries() ) {
+		if ( !size ) {
+			rowsToRemove.push( rowIndex );
+		}
+	}
+
+	// Remove empty rows.
+	if ( rowsToRemove.length ) {
+		// @if CK_DEBUG_TABLE // console.log( `Post-fixing table: remove empty rows (${ rowsToRemove.length }).` );
+
+		wasFixed = true;
+
+		for ( const rowIndex of rowsToRemove.reverse() ) {
+			writer.remove( table.getChild( rowIndex ) );
+			rowsLengths.splice( rowIndex, 1 );
+		}
+	}
+
+	// Verify if all the rows have the same number of columns.
+	const tableSize = rowsLengths[ 0 ];
+	const isValid = rowsLengths.every( length => length === tableSize );
+
+	if ( !isValid ) {
+		// @if CK_DEBUG_TABLE // console.log( 'Post-fixing table: adding missing cells.' );
+
+		// Find the maximum number of columns.
+		const maxColumns = rowsLengths.reduce( ( prev, current ) => current > prev ? current : prev, 0 );
+
+		for ( const [ rowIndex, size ] of rowsLengths.entries() ) {
+			const columnsToInsert = maxColumns - size;
+
+			if ( columnsToInsert ) {
+				for ( let i = 0; i < columnsToInsert; i++ ) {
+					createEmptyTableCell( writer, writer.createPositionAt( table.getChild( rowIndex ), 'end' ) );
+				}
+
+				wasFixed = true;
+			}
+		}
+	}
+
+	return wasFixed;
+}
+
+// Searches for table cells that extend beyond the table section to which they belong to. It will return an array of objects
+// that stores table cells to be trimmed and the correct value of the `rowspan` attribute to set.
+//
+// @param {module:engine/model/element~Element} table
+// @returns {Array.<{{cell, rowspan}}>}
+function findCellsToTrim( table ) {
+	const headingRows = parseInt( table.getAttribute( 'headingRows' ) || 0 );
+	const maxRows = table.childCount;
+
+	const cellsToTrim = [];
+
+	for ( const { row, cell, cellHeight } of new TableWalker( table ) ) {
+		// Skip cells that do not expand over its row.
+		if ( cellHeight < 2 ) {
+			continue;
+		}
+
+		const isInHeader = row < headingRows;
+
+		// Row limit is either end of header section or whole table as table body is after the header.
+		const rowLimit = isInHeader ? headingRows : maxRows;
+
+		// If table cell expands over its limit reduce it height to proper value.
+		if ( row + cellHeight > rowLimit ) {
+			const newRowspan = rowLimit - row;
+
+			cellsToTrim.push( { cell, rowspan: newRowspan } );
+		}
+	}
+
+	return cellsToTrim;
+}
+
+// Returns an array with lengths of rows assigned to the corresponding row index.
+//
+// @param {module:engine/model/element~Element} table
+// @returns {Array.<Number>}
+function getRowsLengths( table ) {
+	// TableWalker will not provide items for the empty rows, we need to pre-fill this array.
+	const lengths = new Array( table.childCount ).fill( 0 );
+
+	for ( const { row } of new TableWalker( table, { includeAllSlots: true } ) ) {
+		lengths[ row ]++;
+	}
+
+	return lengths;
+}
+
+// Checks if the differ entry for an attribute change is one of the table's attributes.
+//
+// @param entry
+// @returns {Boolean}
+function isTableAttributeEntry( entry ) {
+	const isAttributeType = entry.type === 'attribute';
+	const key = entry.attributeKey;
+
+	return isAttributeType && ( key === 'headingRows' || key === 'colspan' || key === 'rowspan' );
+}

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

@@ -0,0 +1,126 @@
+/**
+ * @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/converters/tableproperites
+ */
+
+/**
+ * Conversion helper for upcasting attributes using normalized styles.
+ *
+ * @param {module:engine/conversion/conversion~Conversion} conversion
+ * @param {String} modelElement
+ * @param {String} modelAttribute
+ * @param {String} styleName
+ */
+export function upcastStyleToAttribute( conversion, modelElement, modelAttribute, styleName ) {
+	conversion.for( 'upcast' ).attributeToAttribute( {
+		view: {
+			styles: {
+				[ styleName ]: /[\s\S]+/
+			}
+		},
+		model: {
+			name: modelElement,
+			key: modelAttribute,
+			value: viewElement => viewElement.getNormalizedStyle( styleName )
+		}
+	} );
+}
+
+/**
+ * Conversion helper for upcasting border styles for view elements.
+ *
+ * @param {module:engine/conversion/conversion~Conversion} conversion
+ * @param {String} viewElementName
+ */
+export function upcastBorderStyles( conversion, viewElementName ) {
+	conversion.for( 'upcast' ).add( dispatcher => dispatcher.on( 'element:' + viewElementName, ( evt, data, conversionApi ) => {
+		// If the element was not converted by element-to-element converter,
+		// we should not try to convert the style. See #8393.
+		if ( !data.modelRange ) {
+			return;
+		}
+
+		// TODO: this is counter-intuitive: ie.: if only `border-top` is defined then `hasStyle( 'border' )` also returns true.
+		// TODO: this might needs to be fixed in styles normalizer.
+		const stylesToConsume = [
+			'border-top',
+			'border-right',
+			'border-bottom',
+			'border-left'
+		].filter( styleName => data.viewItem.hasStyle( styleName ) );
+
+		if ( !stylesToConsume.length ) {
+			return;
+		}
+
+		const matcherPattern = {
+			styles: stylesToConsume
+		};
+
+		// Try to consume appropriate values from consumable values list.
+		if ( !conversionApi.consumable.test( data.viewItem, matcherPattern ) ) {
+			return;
+		}
+
+		const modelElement = [ ...data.modelRange.getItems( { shallow: true } ) ].pop();
+
+		conversionApi.consumable.consume( data.viewItem, matcherPattern );
+
+		conversionApi.writer.setAttribute( 'borderStyle', data.viewItem.getNormalizedStyle( 'border-style' ), modelElement );
+		conversionApi.writer.setAttribute( 'borderColor', data.viewItem.getNormalizedStyle( 'border-color' ), modelElement );
+		conversionApi.writer.setAttribute( 'borderWidth', data.viewItem.getNormalizedStyle( 'border-width' ), modelElement );
+	} ) );
+}
+
+/**
+ * Conversion helper for downcasting an attribute to a style.
+ *
+ * @param {module:engine/conversion/conversion~Conversion} conversion
+ * @param {String} modelElement
+ * @param {String} modelAttribute
+ * @param {String} styleName
+ */
+export function downcastAttributeToStyle( conversion, modelElement, modelAttribute, styleName ) {
+	conversion.for( 'downcast' ).attributeToAttribute( {
+		model: {
+			name: modelElement,
+			key: modelAttribute
+		},
+		view: modelAttributeValue => ( {
+			key: 'style',
+			value: {
+				[ styleName ]: modelAttributeValue
+			}
+		} )
+	} );
+}
+
+/**
+ * Conversion helper for downcasting attributes from the model table to a view table (not to `<figure>`).
+ *
+ * @param {module:engine/conversion/conversion~Conversion} conversion
+ * @param {String} modelAttribute
+ * @param {String} styleName
+ */
+export function downcastTableAttribute( conversion, modelAttribute, styleName ) {
+	conversion.for( 'downcast' ).add( dispatcher => dispatcher.on( `attribute:${ modelAttribute }:table`, ( evt, data, conversionApi ) => {
+		const { item, attributeNewValue } = data;
+		const { mapper, writer } = conversionApi;
+
+		if ( !conversionApi.consumable.consume( data.item, evt.name ) ) {
+			return;
+		}
+
+		const table = [ ...mapper.toViewElement( item ).getChildren() ].find( child => child.is( 'element', 'table' ) );
+
+		if ( attributeNewValue ) {
+			writer.setStyle( styleName, attributeNewValue, table );
+		} else {
+			writer.removeStyle( styleName, table );
+		}
+	} ) );
+}