@atlaskit/editor-plugin-table 7.16.11 → 7.16.13

package/src/utils/snapping.ts

@@ -1,137 +1,124 @@
 import type { GuidelineConfig } from '@atlaskit/editor-common/guideline';
 import { isVerticalPosition } from '@atlaskit/editor-common/guideline';
 import {
-  akEditorCalculatedWideLayoutWidth,
-  akEditorDefaultLayoutWidth,
-  akEditorFullWidthLayoutWidth,
-  akEditorGutterPadding,
+	akEditorCalculatedWideLayoutWidth,
+	akEditorDefaultLayoutWidth,
+	akEditorFullWidthLayoutWidth,
+	akEditorGutterPadding,
 } from '@atlaskit/editor-shared-styles';
 
-import { tableResizerWidth } from '../ui/consts';
-
 const numberOfLanesInDefaultLayoutWidth = 12;
 
 const calculateSubSnappingWidths = (totalLanes: number, totalWidth: number) =>
-  new Array(Math.round(totalLanes / 2) - 1)
-    .fill(totalWidth / totalLanes)
-    .map((v, i) => v * (i + 1) * 2);
+	new Array(Math.round(totalLanes / 2) - 1)
+		.fill(totalWidth / totalLanes)
+		.map((v, i) => v * (i + 1) * 2);
 
 export const calculateDefaultSnappings = (lengthOffset: number = 0) => [
-  ...calculateSubSnappingWidths(
-    numberOfLanesInDefaultLayoutWidth,
-    akEditorDefaultLayoutWidth + lengthOffset,
-  ),
-  akEditorDefaultLayoutWidth + lengthOffset,
-  akEditorCalculatedWideLayoutWidth + lengthOffset,
-  akEditorFullWidthLayoutWidth + lengthOffset,
+	...calculateSubSnappingWidths(
+		numberOfLanesInDefaultLayoutWidth,
+		akEditorDefaultLayoutWidth + lengthOffset,
+	),
+	akEditorDefaultLayoutWidth + lengthOffset,
+	akEditorCalculatedWideLayoutWidth + lengthOffset,
+	akEditorFullWidthLayoutWidth + lengthOffset,
 ];
 
 export type GuidelineExcludeConfig = {
-  innerGuidelines: boolean;
-  breakoutPoints: boolean;
+	innerGuidelines: boolean;
+	breakoutPoints: boolean;
 };
 
 // FF TablePreserve for calculateDefaultSnappings
 export const calculateDefaultTablePreserveSnappings = (
-  lengthOffset = 0,
-  editorContainerWith = akEditorFullWidthLayoutWidth,
-  exclude: GuidelineExcludeConfig = {
-    innerGuidelines: false,
-    breakoutPoints: false,
-  },
+	lengthOffset = 0,
+	editorContainerWith = akEditorFullWidthLayoutWidth,
+	exclude: GuidelineExcludeConfig = {
+		innerGuidelines: false,
+		breakoutPoints: false,
+	},
 ) => {
-  const dynamicFullWidthLine =
-    editorContainerWith - akEditorGutterPadding * 2 >=
-    akEditorFullWidthLayoutWidth
-      ? akEditorFullWidthLayoutWidth
-      : editorContainerWith - akEditorGutterPadding * 2 - tableResizerWidth;
+	const dynamicFullWidthLine =
+		editorContainerWith - akEditorGutterPadding * 2 >= akEditorFullWidthLayoutWidth
+			? akEditorFullWidthLayoutWidth
+			: editorContainerWith - akEditorGutterPadding * 2;
 
-  const guides = [dynamicFullWidthLine - lengthOffset];
+	const guides = [dynamicFullWidthLine - lengthOffset];
 
-  if (!exclude.breakoutPoints) {
-    guides.unshift(
-      akEditorDefaultLayoutWidth + lengthOffset,
-      akEditorCalculatedWideLayoutWidth + lengthOffset,
-    );
-  }
+	if (!exclude.breakoutPoints) {
+		guides.unshift(
+			akEditorDefaultLayoutWidth + lengthOffset,
+			akEditorCalculatedWideLayoutWidth + lengthOffset,
+		);
+	}
 
-  if (!exclude.innerGuidelines) {
-    guides.unshift(
-      0,
-      ...calculateSubSnappingWidths(
-        numberOfLanesInDefaultLayoutWidth,
-        akEditorDefaultLayoutWidth + lengthOffset,
-      ),
-    );
-  }
+	if (!exclude.innerGuidelines) {
+		guides.unshift(
+			0,
+			...calculateSubSnappingWidths(
+				numberOfLanesInDefaultLayoutWidth,
+				akEditorDefaultLayoutWidth + lengthOffset,
+			),
+		);
+	}
 
-  return guides;
+	return guides;
 };
 
 export const defaultSnappingWidths = calculateDefaultSnappings();
 
+export const PRESERVE_TABLE_SNAPPING_LENGTH_OFFSET = 0;
 // FF TablePreserve for defaultSnappingWidths
 export const defaultTablePreserveSnappingWidths = (
-  editorContainerWidth: number,
-  exclude: GuidelineExcludeConfig = {
-    innerGuidelines: false,
-    breakoutPoints: false,
-  },
+	lengthOffset: number,
+	editorContainerWidth: number,
+	exclude: GuidelineExcludeConfig = {
+		innerGuidelines: false,
+		breakoutPoints: false,
+	},
 ) => {
-  return editorContainerWidth - akEditorGutterPadding * 2 >
-    akEditorFullWidthLayoutWidth
-    ? calculateDefaultSnappings()
-    : calculateDefaultTablePreserveSnappings(
-        0,
-        editorContainerWidth,
-        exclude,
-      );
+	return editorContainerWidth - akEditorGutterPadding * 2 > akEditorFullWidthLayoutWidth
+		? calculateDefaultSnappings()
+		: calculateDefaultTablePreserveSnappings(lengthOffset, editorContainerWidth, exclude); // lengthOffset was hardcoded 0 here, created PRESERVE_TABLE_SNAPPING_LENGTH_OFFSET instead.
 };
 
 /**
- * Returns keys of guidelines that are closest to the table and withthin the snapGap
+ * Returns keys of guidelines that are closest to the table and within the snapGap
  */
 export const findClosestSnap = (
-  currentWidth: number,
-  snapWidths: number[],
-  guidelines: GuidelineConfig[],
-  snapGap: number = 0,
-  tolerance: number = 0,
+	currentWidth: number,
+	snapWidths: number[],
+	guidelines: GuidelineConfig[],
+	snapGap: number = 0,
+	tolerance: number = 0,
 ) => {
-  const closestGapIndex = snapWidths.reduce(
-    (prev, curr, index) =>
-      Math.abs(curr - currentWidth) < Math.abs(snapWidths[prev] - currentWidth)
-        ? index
-        : prev,
-    0,
-  );
-  const gap = Math.abs(snapWidths[closestGapIndex] - currentWidth);
-  if (gap < snapGap) {
-    const snappingWidth = Math.round(snapWidths[closestGapIndex]);
-    const guidelineKeys = guidelines.reduce<string[]>((acc, guideline) => {
-      // NOTE: The snap points are based on the guidelines, however their formatted as a length value whereas the guidelines
-      // are point based. The point base x coords are calculated by halving the lengths. This means we can convert the
-      // point base position to length by simply multiplying by 2.
-      const length = Math.round(
-        Math.abs(
-          isVerticalPosition(guideline.position)
-            ? guideline.position.x
-            : guideline.position.y,
-        ) * 2,
-      );
-      if (
-        snappingWidth >= length - tolerance &&
-        snappingWidth <= length + tolerance
-      ) {
-        acc.push(guideline.key);
-      }
-      return acc;
-    }, []);
+	const closestGapIndex = snapWidths.reduce(
+		(prev, curr, index) =>
+			Math.abs(curr - currentWidth) < Math.abs(snapWidths[prev] - currentWidth) ? index : prev,
+		0,
+	);
+	const gap = Math.abs(snapWidths[closestGapIndex] - currentWidth);
+	if (gap < snapGap) {
+		const snappingWidth = Math.round(snapWidths[closestGapIndex]);
+		const guidelineKeys = guidelines.reduce<string[]>((acc, guideline) => {
+			// NOTE: The snap points are based on the guidelines, however their formatted as a length value whereas the guidelines
+			// are point based. The point base x coords are calculated by halving the lengths. This means we can convert the
+			// point base position to length by simply multiplying by 2.
+			const length = Math.round(
+				Math.abs(
+					isVerticalPosition(guideline.position) ? guideline.position.x : guideline.position.y,
+				) * 2,
+			);
+			if (snappingWidth >= length - tolerance && snappingWidth <= length + tolerance) {
+				acc.push(guideline.key);
+			}
+			return acc;
+		}, []);
 
-    return {
-      gap,
-      keys: guidelineKeys,
-    };
-  }
-  return { gap, keys: [] };
+		return {
+			gap,
+			keys: guidelineKeys,
+		};
+	}
+	return { gap, keys: [] };
 };

package/src/utils/table.ts

@@ -8,61 +8,61 @@ import { TableMap } from '@atlaskit/editor-tables/table-map';
 import { findTable } from '@atlaskit/editor-tables/utils';
 
 export const getMergedCellsPositions = (tr: Transaction): number[] => {
-  const table = findTable(tr.selection);
-  if (!table) {
-    return [];
-  }
+	const table = findTable(tr.selection);
+	if (!table) {
+		return [];
+	}
 
-  const map = TableMap.get(table.node);
-  const cellPositions = new Set();
-  const mergedCells: number[] = [];
+	const map = TableMap.get(table.node);
+	const cellPositions = new Set();
+	const mergedCells: number[] = [];
 
-  map.map.forEach((value) => {
-    if (cellPositions.has(value)) {
-      mergedCells.push(value);
-    } else {
-      cellPositions.add(value);
-    }
-  });
+	map.map.forEach((value) => {
+		if (cellPositions.has(value)) {
+			mergedCells.push(value);
+		} else {
+			cellPositions.add(value);
+		}
+	});
 
-  return mergedCells;
+	return mergedCells;
 };
 
 export const colsToRect = (cols: Array<number>, noOfRows: number): Rect => ({
-  left: Math.min(...cols),
-  right: Math.max(...cols) + 1,
-  top: 0,
-  bottom: noOfRows,
+	left: Math.min(...cols),
+	right: Math.max(...cols) + 1,
+	top: 0,
+	bottom: noOfRows,
 });
 
 export const getAssistiveMessage = (
-  prevTableNode: PmNode,
-  currentTableNode: PmNode,
-  intl: IntlShape,
+	prevTableNode: PmNode,
+	currentTableNode: PmNode,
+	intl: IntlShape,
 ) => {
-  const { formatMessage } = intl;
-  const prevTableMap = TableMap.get(prevTableNode);
-  const currentTableMap = TableMap.get(currentTableNode);
+	const { formatMessage } = intl;
+	const prevTableMap = TableMap.get(prevTableNode);
+	const currentTableMap = TableMap.get(currentTableNode);
 
-  if (currentTableMap.width !== prevTableMap.width) {
-    const diff = Math.abs(currentTableMap.width - prevTableMap.width);
-    if (currentTableMap.width > prevTableMap.width) {
-      return formatMessage(messages.columnsAreInserted, { count: diff });
-    }
-    if (currentTableMap.width < prevTableMap.width) {
-      return formatMessage(messages.columnsAreRemoved, { count: diff });
-    }
-  }
+	if (currentTableMap.width !== prevTableMap.width) {
+		const diff = Math.abs(currentTableMap.width - prevTableMap.width);
+		if (currentTableMap.width > prevTableMap.width) {
+			return formatMessage(messages.columnsAreInserted, { count: diff });
+		}
+		if (currentTableMap.width < prevTableMap.width) {
+			return formatMessage(messages.columnsAreRemoved, { count: diff });
+		}
+	}
 
-  if (currentTableMap.height !== prevTableMap.height) {
-    const diff = Math.abs(currentTableMap.height - prevTableMap.height);
-    if (currentTableMap.height > prevTableMap.height) {
-      return formatMessage(messages.rowsAreInserted, { count: diff });
-    }
-    if (currentTableMap.height < prevTableMap.height) {
-      return formatMessage(messages.rowsAreRemoved, { count: diff });
-    }
-  }
+	if (currentTableMap.height !== prevTableMap.height) {
+		const diff = Math.abs(currentTableMap.height - prevTableMap.height);
+		if (currentTableMap.height > prevTableMap.height) {
+			return formatMessage(messages.rowsAreInserted, { count: diff });
+		}
+		if (currentTableMap.height < prevTableMap.height) {
+			return formatMessage(messages.rowsAreRemoved, { count: diff });
+		}
+	}
 
-  return '';
+	return '';
 };

package/src/utils/transforms.ts

@@ -1,10 +1,10 @@
 import type { Transaction } from '@atlaskit/editor-prosemirror/state';
 
 export const combineTransforms = (
-  transforms: Array<(tr: Transaction) => Transaction>,
-  tr: Transaction,
+	transforms: Array<(tr: Transaction) => Transaction>,
+	tr: Transaction,
 ) => {
-  return transforms.reduce((prev, curr) => {
-    return curr(prev);
-  }, tr);
+	return transforms.reduce((prev, curr) => {
+		return curr(prev);
+	}, tr);
 };

package/src/utils/update-plugin-state-decorations.ts

@@ -1,8 +1,5 @@
 import type { EditorState } from '@atlaskit/editor-prosemirror/state';
-import type {
-  Decoration,
-  DecorationSet,
-} from '@atlaskit/editor-prosemirror/view';
+import type { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
 
 import { getDecorations } from '../pm-plugins/decorations/plugin';
 import type { TableDecorations } from '../types';
@@ -10,8 +7,7 @@ import type { TableDecorations } from '../types';
 import { updateDecorations } from './decoration';
 
 export const updatePluginStateDecorations = (
-  state: EditorState,
-  decorations: Decoration[],
-  key: TableDecorations,
-): DecorationSet =>
-  updateDecorations(state.doc, getDecorations(state), decorations, key);
+	state: EditorState,
+	decorations: Decoration[],
+	key: TableDecorations,
+): DecorationSet => updateDecorations(state.doc, getDecorations(state), decorations, key);