@atlaskit/editor-plugin-table 7.16.10 → 7.16.12

package/src/utils/nodes.ts

@@ -1,155 +1,143 @@
 import { mapChildren } from '@atlaskit/editor-common/utils';
 import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
-import type {
-  EditorState,
-  Selection,
-} from '@atlaskit/editor-prosemirror/state';
+import type { EditorState, Selection } from '@atlaskit/editor-prosemirror/state';
 import { TableMap } from '@atlaskit/editor-tables/table-map';
 import { findTable } from '@atlaskit/editor-tables/utils';
 
 export const isIsolating = (node: PmNode): boolean => {
-  return !!node.type.spec.isolating;
+	return !!node.type.spec.isolating;
 };
 
 export const containsHeaderColumn = (table: PmNode): boolean => {
-  const map = TableMap.get(table);
-  // Get cell positions for first column.
-  const cellPositions = map.cellsInRect({
-    left: 0,
-    top: 0,
-    right: 1,
-    bottom: map.height,
-  });
-
-  for (let i = 0; i < cellPositions.length; i++) {
-    try {
-      const cell = table.nodeAt(cellPositions[i]);
-      if (cell && cell.type !== table.type.schema.nodes.tableHeader) {
-        return false;
-      }
-    } catch (e) {
-      return false;
-    }
-  }
-
-  return true;
+	const map = TableMap.get(table);
+	// Get cell positions for first column.
+	const cellPositions = map.cellsInRect({
+		left: 0,
+		top: 0,
+		right: 1,
+		bottom: map.height,
+	});
+
+	for (let i = 0; i < cellPositions.length; i++) {
+		try {
+			const cell = table.nodeAt(cellPositions[i]);
+			if (cell && cell.type !== table.type.schema.nodes.tableHeader) {
+				return false;
+			}
+		} catch (e) {
+			return false;
+		}
+	}
+
+	return true;
 };
 
 export const containsHeaderRow = (table: PmNode): boolean => {
-  const map = TableMap.get(table);
-  for (let i = 0; i < map.width; i++) {
-    const cell = table.nodeAt(map.map[i]);
-    if (cell && cell.type !== table.type.schema.nodes.tableHeader) {
-      return false;
-    }
-  }
-  return true;
+	const map = TableMap.get(table);
+	for (let i = 0; i < map.width; i++) {
+		const cell = table.nodeAt(map.map[i]);
+		if (cell && cell.type !== table.type.schema.nodes.tableHeader) {
+			return false;
+		}
+	}
+	return true;
 };
 
 export const checkIfHeaderColumnEnabled = (selection: Selection): boolean =>
-  filterNearSelection(selection, findTable, containsHeaderColumn, false);
+	filterNearSelection(selection, findTable, containsHeaderColumn, false);
 
 export const checkIfHeaderRowEnabled = (selection: Selection): boolean =>
-  filterNearSelection(selection, findTable, containsHeaderRow, false);
+	filterNearSelection(selection, findTable, containsHeaderRow, false);
 
 export const checkIfNumberColumnEnabled = (selection: Selection): boolean =>
-  filterNearSelection(
-    selection,
-    findTable,
-    (table) => !!table.attrs.isNumberColumnEnabled,
-    false,
-  );
+	filterNearSelection(selection, findTable, (table) => !!table.attrs.isNumberColumnEnabled, false);
 
 export const getTableWidth = (node: PmNode) => {
-  return getTableWidths(node).reduce((acc, current) => acc + current, 0);
+	return getTableWidths(node).reduce((acc, current) => acc + current, 0);
 };
 
 export const tablesHaveDifferentColumnWidths = (
-  currentTable: PmNode,
-  previousTable: PmNode,
+	currentTable: PmNode,
+	previousTable: PmNode,
 ): boolean => {
-  let currentTableWidths = getTableWidths(currentTable);
-  let previousTableWidths = getTableWidths(previousTable);
+	let currentTableWidths = getTableWidths(currentTable);
+	let previousTableWidths = getTableWidths(previousTable);
 
-  if (currentTableWidths.length !== previousTableWidths.length) {
-    return true;
-  }
+	if (currentTableWidths.length !== previousTableWidths.length) {
+		return true;
+	}
 
-  const sameWidths = currentTableWidths.every(
-    (value: number, index: number) => {
-      return value === previousTableWidths[index];
-    },
-  );
+	const sameWidths = currentTableWidths.every((value: number, index: number) => {
+		return value === previousTableWidths[index];
+	});
 
-  return sameWidths === false;
+	return sameWidths === false;
 };
 
 export const tablesHaveDifferentNoOfColumns = (
-  currentTable: PmNode,
-  previousTable: PmNode,
+	currentTable: PmNode,
+	previousTable: PmNode,
 ): boolean => {
-  const prevMap = TableMap.get(previousTable);
-  const currentMap = TableMap.get(currentTable);
+	const prevMap = TableMap.get(previousTable);
+	const currentMap = TableMap.get(currentTable);
 
-  return prevMap.width !== currentMap.width;
+	return prevMap.width !== currentMap.width;
 };
 
 export const tablesHaveDifferentNoOfRows = (
-  currentTable: PmNode,
-  previousTable: PmNode,
+	currentTable: PmNode,
+	previousTable: PmNode,
 ): boolean => {
-  const prevMap = TableMap.get(previousTable);
-  const currentMap = TableMap.get(currentTable);
+	const prevMap = TableMap.get(previousTable);
+	const currentMap = TableMap.get(currentTable);
 
-  return prevMap.height !== currentMap.height;
+	return prevMap.height !== currentMap.height;
 };
 
 function filterNearSelection<T, U>(
-  selection: Selection,
-  findNode: (selection: Selection) => { pos: number; node: PmNode } | undefined,
-  predicate: (node: PmNode, pos?: number) => T,
-  defaultValue: U,
+	selection: Selection,
+	findNode: (selection: Selection) => { pos: number; node: PmNode } | undefined,
+	predicate: (node: PmNode, pos?: number) => T,
+	defaultValue: U,
 ): T | U {
-  const found = findNode(selection);
-  if (!found) {
-    return defaultValue;
-  }
+	const found = findNode(selection);
+	if (!found) {
+		return defaultValue;
+	}
 
-  return predicate(found.node, found.pos);
+	return predicate(found.node, found.pos);
 }
 
 function getTableWidths(node: PmNode): number[] {
-  if (!node.content.firstChild) {
-    return [];
-  }
-
-  let tableWidths: Array<number> = [];
-  node.content.firstChild.content.forEach((cell) => {
-    if (Array.isArray(cell.attrs.colwidth)) {
-      const colspan = cell.attrs.colspan || 1;
-      tableWidths.push(...cell.attrs.colwidth.slice(0, colspan));
-    }
-  });
-
-  return tableWidths;
+	if (!node.content.firstChild) {
+		return [];
+	}
+
+	let tableWidths: Array<number> = [];
+	node.content.firstChild.content.forEach((cell) => {
+		if (Array.isArray(cell.attrs.colwidth)) {
+			const colspan = cell.attrs.colspan || 1;
+			tableWidths.push(...cell.attrs.colwidth.slice(0, colspan));
+		}
+	});
+
+	return tableWidths;
 }
 
 export const isTableNested = (state: EditorState, tablePos = 0): boolean => {
-  const parent = state.doc.resolve(tablePos).parent;
-  const nodeTypes = state.schema.nodes;
-
-  return (
-    parent.type === nodeTypes.layoutColumn ||
-    parent.type === nodeTypes.expand ||
-    parent.type === nodeTypes.bodiedExtension ||
-    parent.type === nodeTypes.extensionFrame
-  );
+	const parent = state.doc.resolve(tablePos).parent;
+	const nodeTypes = state.schema.nodes;
+
+	return (
+		parent.type === nodeTypes.layoutColumn ||
+		parent.type === nodeTypes.expand ||
+		parent.type === nodeTypes.bodiedExtension ||
+		parent.type === nodeTypes.extensionFrame
+	);
 };
 
 export const anyChildCellMergedAcrossRow = (node: PmNode): boolean =>
-  mapChildren(node, (child) => child.attrs.rowspan || 0).some(
-    (rowspan) => rowspan > 1,
-  );
+	mapChildren(node, (child) => child.attrs.rowspan || 0).some((rowspan) => rowspan > 1);
 
 /**
  * Check if a given node is a header row with this definition:
@@ -160,12 +148,9 @@ export const anyChildCellMergedAcrossRow = (node: PmNode): boolean =>
  * @return boolean if it meets definition
  */
 export const supportedHeaderRow = (node: PmNode): boolean => {
-  const allHeaders = mapChildren(
-    node,
-    (child) => child.type.name === 'tableHeader',
-  ).every(Boolean);
+	const allHeaders = mapChildren(node, (child) => child.type.name === 'tableHeader').every(Boolean);
 
-  const someMerged = anyChildCellMergedAcrossRow(node);
+	const someMerged = anyChildCellMergedAcrossRow(node);
 
-  return allHeaders && !someMerged;
+	return allHeaders && !someMerged;
 };

package/src/utils/paste.ts

@@ -1,8 +1,5 @@
 import { flatmap, mapSlice } from '@atlaskit/editor-common/utils';
-import type {
-  Node as PMNode,
-  Schema,
-} from '@atlaskit/editor-prosemirror/model';
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
 import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
 import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import { flatten } from '@atlaskit/editor-prosemirror/utils';
@@ -10,37 +7,32 @@ import { flatten } from '@atlaskit/editor-prosemirror/utils';
 import { getPluginState } from '../pm-plugins/plugin-factory';
 
 // lifts up the content of each cell, returning an array of nodes
-export const unwrapContentFromTable = (
-  maybeTable: PMNode,
-): PMNode | PMNode[] => {
-  const { schema } = maybeTable.type;
-  if (maybeTable.type === schema.nodes.table) {
-    const content: PMNode[] = [];
-    const { tableCell, tableHeader } = schema.nodes;
-    maybeTable.descendants((maybeCell) => {
-      if (maybeCell.type === tableCell || maybeCell.type === tableHeader) {
-        content.push(...flatten(maybeCell, false).map((child) => child.node));
-      }
-      return true;
-    });
-    return content;
-  }
-  return maybeTable;
+export const unwrapContentFromTable = (maybeTable: PMNode): PMNode | PMNode[] => {
+	const { schema } = maybeTable.type;
+	if (maybeTable.type === schema.nodes.table) {
+		const content: PMNode[] = [];
+		const { tableCell, tableHeader } = schema.nodes;
+		maybeTable.descendants((maybeCell) => {
+			if (maybeCell.type === tableCell || maybeCell.type === tableHeader) {
+				content.push(...flatten(maybeCell, false).map((child) => child.node));
+			}
+			return true;
+		});
+		return content;
+	}
+	return maybeTable;
 };
 
-export const removeTableFromFirstChild = (
-  node: PMNode,
-  i: number,
-): PMNode | PMNode[] => {
-  return i === 0 ? unwrapContentFromTable(node) : node;
+export const removeTableFromFirstChild = (node: PMNode, i: number): PMNode | PMNode[] => {
+	return i === 0 ? unwrapContentFromTable(node) : node;
 };
 
 export const removeTableFromLastChild = (
-  node: PMNode,
-  i: number,
-  fragment: Fragment,
+	node: PMNode,
+	i: number,
+	fragment: Fragment,
 ): PMNode | PMNode[] => {
-  return i === fragment.childCount - 1 ? unwrapContentFromTable(node) : node;
+	return i === fragment.childCount - 1 ? unwrapContentFromTable(node) : node;
 };
 
 /**
@@ -49,118 +41,110 @@ export const removeTableFromLastChild = (
  * This code will look for that pattern and fix it.
  */
 export const transformSliceToFixHardBreakProblemOnCopyFromCell = (
-  slice: Slice,
-  schema: Schema,
+	slice: Slice,
+	schema: Schema,
 ): Slice => {
-  const { paragraph, table, hardBreak } = schema.nodes;
-  const emptyParagraphNode = paragraph.createAndFill();
-
-  const hardBreakNode = hardBreak?.createAndFill();
-  const paragraphNodeSize = emptyParagraphNode
-    ? emptyParagraphNode.nodeSize
-    : 0;
-  const hardBreakNodeSize = hardBreakNode ? hardBreakNode.nodeSize : 0;
-  const paragraphWithHardBreakSize = paragraphNodeSize + hardBreakNodeSize;
-
-  if (
-    slice.content.childCount === 2 &&
-    slice.content.firstChild &&
-    slice.content.lastChild &&
-    slice.content.firstChild.type === table &&
-    slice.content.lastChild.type === paragraph &&
-    slice.content.lastChild.nodeSize === paragraphWithHardBreakSize
-  ) {
-    const nodes = unwrapContentFromTable(slice.content.firstChild);
-    if (nodes instanceof Array) {
-      return new Slice(
-        Fragment.from(
-          // keep only the content and discard the hardBreak
-          nodes[0],
-        ),
-        slice.openStart,
-        slice.openEnd,
-      );
-    }
-  }
-
-  return slice;
+	const { paragraph, table, hardBreak } = schema.nodes;
+	const emptyParagraphNode = paragraph.createAndFill();
+
+	const hardBreakNode = hardBreak?.createAndFill();
+	const paragraphNodeSize = emptyParagraphNode ? emptyParagraphNode.nodeSize : 0;
+	const hardBreakNodeSize = hardBreakNode ? hardBreakNode.nodeSize : 0;
+	const paragraphWithHardBreakSize = paragraphNodeSize + hardBreakNodeSize;
+
+	if (
+		slice.content.childCount === 2 &&
+		slice.content.firstChild &&
+		slice.content.lastChild &&
+		slice.content.firstChild.type === table &&
+		slice.content.lastChild.type === paragraph &&
+		slice.content.lastChild.nodeSize === paragraphWithHardBreakSize
+	) {
+		const nodes = unwrapContentFromTable(slice.content.firstChild);
+		if (nodes instanceof Array) {
+			return new Slice(
+				Fragment.from(
+					// keep only the content and discard the hardBreak
+					nodes[0],
+				),
+				slice.openStart,
+				slice.openEnd,
+			);
+		}
+	}
+
+	return slice;
 };
 
-export const transformSliceToRemoveOpenTable = (
-  slice: Slice,
-  schema: Schema,
-): Slice => {
-  // we're removing the table, tableRow and tableCell reducing the open depth by 3
-  const depthDecrement = 3;
-
-  // Case 1: A slice entirely within a single CELL
-  if (
-    // starts and ends inside of a cell
-    slice.openStart >= 4 &&
-    slice.openEnd >= 4 &&
-    // slice is a table node
-    slice.content.childCount === 1 &&
-    slice.content.firstChild!.type === schema.nodes.table
-  ) {
-    // prosemirror-view has a bug that it duplicates table entry when selecting multiple paragraphs in a table cell.
-    // https://github.com/ProseMirror/prosemirror/issues/1270
-    // The structure becomes
-    // table(genuine) > tableRow(genuine) > table(duplicated) > tableRow(duplicated) > tableCell/tableHeader(genuine) > contents(genuine)
-    // As we are removing wrapping table anyway, we keep duplicated table and tableRow for simplicity
-    let cleaned = slice;
-    if (
-      slice.content.firstChild?.content?.firstChild?.content?.firstChild
-        ?.type === schema.nodes.table
-    ) {
-      cleaned = new Slice(
-        slice.content.firstChild.content.firstChild.content,
-        slice.openStart - 2,
-        slice.openEnd - 2,
-      );
-    }
-
-    return new Slice(
-      flatmap(cleaned.content, unwrapContentFromTable),
-      cleaned.openStart - depthDecrement,
-      cleaned.openEnd - depthDecrement,
-    );
-  }
-
-  // Case 2: A slice starting within a CELL and ending outside the table
-  if (
-    // starts inside of a cell but ends outside of the starting table
-    slice.openStart >= 4 &&
-    // slice starts from a table node (and spans across more than one node)
-    slice.content.childCount > 1 &&
-    slice.content.firstChild?.type === schema.nodes.table
-  ) {
-    // repoint the slice's cutting depth so that cell content where the slice starts
-    // does not get lifted out of the cell on paste
-    return new Slice(slice.content, 1, slice.openEnd);
-  }
-
-  return slice;
+export const transformSliceToRemoveOpenTable = (slice: Slice, schema: Schema): Slice => {
+	// we're removing the table, tableRow and tableCell reducing the open depth by 3
+	const depthDecrement = 3;
+
+	// Case 1: A slice entirely within a single CELL
+	if (
+		// starts and ends inside of a cell
+		slice.openStart >= 4 &&
+		slice.openEnd >= 4 &&
+		// slice is a table node
+		slice.content.childCount === 1 &&
+		slice.content.firstChild!.type === schema.nodes.table
+	) {
+		// prosemirror-view has a bug that it duplicates table entry when selecting multiple paragraphs in a table cell.
+		// https://github.com/ProseMirror/prosemirror/issues/1270
+		// The structure becomes
+		// table(genuine) > tableRow(genuine) > table(duplicated) > tableRow(duplicated) > tableCell/tableHeader(genuine) > contents(genuine)
+		// As we are removing wrapping table anyway, we keep duplicated table and tableRow for simplicity
+		let cleaned = slice;
+		if (
+			slice.content.firstChild?.content?.firstChild?.content?.firstChild?.type ===
+			schema.nodes.table
+		) {
+			cleaned = new Slice(
+				slice.content.firstChild.content.firstChild.content,
+				slice.openStart - 2,
+				slice.openEnd - 2,
+			);
+		}
+
+		return new Slice(
+			flatmap(cleaned.content, unwrapContentFromTable),
+			cleaned.openStart - depthDecrement,
+			cleaned.openEnd - depthDecrement,
+		);
+	}
+
+	// Case 2: A slice starting within a CELL and ending outside the table
+	if (
+		// starts inside of a cell but ends outside of the starting table
+		slice.openStart >= 4 &&
+		// slice starts from a table node (and spans across more than one node)
+		slice.content.childCount > 1 &&
+		slice.content.firstChild?.type === schema.nodes.table
+	) {
+		// repoint the slice's cutting depth so that cell content where the slice starts
+		// does not get lifted out of the cell on paste
+		return new Slice(slice.content, 1, slice.openEnd);
+	}
+
+	return slice;
 };
 
-export const transformSliceToCorrectEmptyTableCells = (
-  slice: Slice,
-  schema: Schema,
-): Slice => {
-  const { tableCell, tableHeader } = schema.nodes;
-  return mapSlice(slice, (node) => {
-    if (
-      node &&
-      (node.type === tableCell || node.type === tableHeader) &&
-      !node.content.childCount
-    ) {
-      return node.type.createAndFill(node.attrs) || node;
-    }
-
-    return node;
-  });
+export const transformSliceToCorrectEmptyTableCells = (slice: Slice, schema: Schema): Slice => {
+	const { tableCell, tableHeader } = schema.nodes;
+	return mapSlice(slice, (node) => {
+		if (
+			node &&
+			(node.type === tableCell || node.type === tableHeader) &&
+			!node.content.childCount
+		) {
+			return node.type.createAndFill(node.attrs) || node;
+		}
+
+		return node;
+	});
 };
 
 export function isHeaderRowRequired(state: EditorState) {
-  const tableState = getPluginState(state);
-  return tableState && tableState.pluginConfig.isHeaderRowRequired;
+	const tableState = getPluginState(state);
+	return tableState && tableState.pluginConfig.isHeaderRowRequired;
 }