opentiny 6.9.0

package/src/core/main/ts/caret/ClosestCaretCandidate.ts

@@ -0,0 +1,145 @@
+import { Arr, Fun, Optional } from '@ephox/katamari';
+import { Compare, SugarElement, Traverse } from '@ephox/sugar';
+
+import { getClientRects, NodeClientRect } from '../dom/Dimensions';
+import * as NodeType from '../dom/NodeType';
+import * as ClientRect from '../geom/ClientRect';
+import * as CaretCandidate from './CaretCandidate';
+import { isFakeCaretTarget } from './FakeCaret';
+
+type GeomClientRect = ClientRect.ClientRect;
+
+export enum FakeCaretPosition {
+  Before = 'before',
+  After = 'after'
+}
+
+export interface FakeCaretInfo {
+  node: Node;
+  position: FakeCaretPosition;
+}
+
+type DistanceFn = <T extends GeomClientRect>(rect: T, x: number, y: number) => number;
+
+const distanceToRectLeft = (clientRect: GeomClientRect, clientX: number) => Math.abs(clientRect.left - clientX);
+const distanceToRectRight = (clientRect: GeomClientRect, clientX: number) => Math.abs(clientRect.right - clientX);
+const isInsideY = <T extends GeomClientRect>(clientY: number, clientRect: T): boolean => clientY >= clientRect.top && clientY <= clientRect.bottom;
+const collidesY = <T extends GeomClientRect>(r1: T, r2: T): boolean => r1.top < r2.bottom && r1.bottom > r2.top;
+
+const isOverlapping = <T extends GeomClientRect>(r1: T, r2: T) => {
+  // Rectangles might overlap a bit so this checks if the overlap is more than 50% then we count that as on the same line
+  const overlap = ClientRect.overlapY(r1, r2) / Math.min(r1.height, r2.height);
+  return collidesY(r1, r2) && overlap > 0.5;
+};
+
+const splitRectsPerAxis = <T extends GeomClientRect>(rects: T[], y: number): [T[], T[]] => {
+  const intersectingRects = Arr.filter(rects, (rect) => isInsideY(y, rect));
+
+  return ClientRect.boundingClientRectFromRects(intersectingRects).fold(
+    () => ([[], rects ]),
+    (boundingRect) => {
+      const { pass: horizontal, fail: vertical } = Arr.partition(rects, (rect) => isOverlapping(rect, boundingRect));
+      return [ horizontal, vertical ];
+    }
+  );
+};
+
+const clientInfo = (rect: NodeClientRect, clientX: number): FakeCaretInfo => {
+  return {
+    node: rect.node,
+    position: distanceToRectLeft(rect, clientX) < distanceToRectRight(rect, clientX) ? FakeCaretPosition.Before : FakeCaretPosition.After
+  };
+};
+
+// Measure the distance between the x and the closest edge of the rect.
+// If the x is inside the rect then always return 0.
+const horizontalDistance: DistanceFn = (rect, x, _y) =>
+  x > rect.left && x < rect.right ? 0 : Math.min(Math.abs(rect.left - x), Math.abs(rect.right - x));
+
+const closestChildCaretCandidateNodeRect = (children: ChildNode[], clientX: number, clientY: number, findCloserTextNode: boolean) => {
+  const caretCandidateRect = (rect: NodeClientRect) => {
+    if (CaretCandidate.isCaretCandidate(rect.node)) {
+      return Optional.some(rect);
+    } else if (NodeType.isElement(rect.node)) {
+      return closestChildCaretCandidateNodeRect(Arr.from(rect.node.childNodes), clientX, clientY, false);
+    } else {
+      return Optional.none();
+    }
+  };
+
+  // If an element and a text node has nearly equal distance then favor the text node over the element to make it easier to select text
+  // since setting the selection range will cancel any text select operation.
+  const tryFindSecondBestTextNode = (closest: NodeClientRect, sndClosest: NodeClientRect, distance: DistanceFn) => {
+    return caretCandidateRect(sndClosest).filter((rect) => {
+      const deltaDistance = Math.abs(distance(closest, clientX, clientY) - distance(rect, clientX, clientY));
+      return deltaDistance < 2 && NodeType.isText(rect.node);
+    });
+  };
+
+  const findClosestCaretCandidateNodeRect = (rects: NodeClientRect[], distance: DistanceFn): Optional<NodeClientRect> => {
+    const sortedRects = Arr.sort(rects, (r1, r2) => distance(r1, clientX, clientY) - distance(r2, clientX, clientY));
+    return Arr.findMap(sortedRects, caretCandidateRect).map((closest) => {
+      // If the closest rect is not a text node then lets try to see if the second rect has a text node that is close enough
+      if (findCloserTextNode && !NodeType.isText(closest.node) && sortedRects.length > 1) {
+        return tryFindSecondBestTextNode(closest, sortedRects[1], distance).getOr(closest);
+      } else {
+        return closest;
+      }
+    });
+  };
+
+  const [ horizontalRects, verticalRects ] = splitRectsPerAxis(getClientRects(children), clientY);
+  const { pass: above, fail: below } = Arr.partition(verticalRects, (rect) => rect.top < clientY);
+
+  return findClosestCaretCandidateNodeRect(horizontalRects, horizontalDistance)
+    .orThunk(() => findClosestCaretCandidateNodeRect(below, ClientRect.distanceToRectEdgeFromXY))
+    .orThunk(() => findClosestCaretCandidateNodeRect(above, ClientRect.distanceToRectEdgeFromXY));
+};
+
+const traverseUp = (rootElm: SugarElement<Node>, scope: SugarElement<Element>, clientX: number, clientY: number): Optional<NodeClientRect> => {
+  const helper = (scope: SugarElement<Element>, prevScope: Optional<SugarElement<Element>>): Optional<NodeClientRect> => {
+    const isDragGhostContainer = (node: ChildNode) => NodeType.isElement(node) && node.classList.contains('mce-drag-container');
+    const childNodesWithoutGhost = Arr.filter(scope.dom.childNodes, Fun.not(isDragGhostContainer));
+
+    return prevScope.fold(
+      () => closestChildCaretCandidateNodeRect(childNodesWithoutGhost, clientX, clientY, true),
+      (prevScope) => {
+        const uncheckedChildren = Arr.filter(childNodesWithoutGhost, (node) => node !== prevScope.dom);
+        return closestChildCaretCandidateNodeRect(uncheckedChildren, clientX, clientY, true);
+      }
+    ).orThunk(() => {
+      const parent = Compare.eq(scope, rootElm) ? Optional.none() : Traverse.parentElement(scope);
+      return parent.bind((newScope) => helper(newScope, Optional.some(scope)));
+    });
+  };
+
+  return helper(scope, Optional.none());
+};
+
+// Rough description of how this algorithm works:
+// 1. It starts by finding the element at the specified X, Y coordinate.
+// 2. Then it checks its children for the closest one and traverses down into those repeating step 2, 3 until it finds a caret candidate.
+// 3. If no caret candidate is found in the closest child node then it checks the second closest and so on until all decendants have been checked.
+// 4. If no caret candidate is found, it traverses up skips the element it already checked and checks its siblings using steps 2, 3.
+// 5. If no caret candidate is found, it continues step 4 until it finds the root. Then we have checked all the nodes in the document.
+//
+// This is less accurate but more performant, since for the common case you are likely to find a caret candidate close to where you are clicking.
+// The more accurate algorithm would be to read all caret candidates rects in the whole document in and in one big step to find the closest one, but that is just too slow for bigger documents.
+const closestCaretCandidateNodeRect = (root: HTMLElement, clientX: number, clientY: number): Optional<NodeClientRect> => {
+  const rootElm = SugarElement.fromDom(root);
+  const ownerDoc = Traverse.documentOrOwner(rootElm);
+  const elementAtPoint = SugarElement.fromPoint(ownerDoc, clientX, clientY).filter((elm) => Compare.contains(rootElm, elm));
+  const element = elementAtPoint.getOr(rootElm);
+
+  return traverseUp(rootElm, element, clientX, clientY);
+};
+
+const closestFakeCaretCandidate = (root: HTMLElement, clientX: number, clientY: number): Optional<FakeCaretInfo> =>
+  closestCaretCandidateNodeRect(root, clientX, clientY)
+    .filter((rect) => isFakeCaretTarget(rect.node))
+    .map((rect) => clientInfo(rect, clientX));
+
+export {
+  closestCaretCandidateNodeRect,
+  closestFakeCaretCandidate
+};

package/src/core/main/ts/caret/FakeCaret.ts

@@ -0,0 +1,230 @@
+import { Singleton } from '@ephox/katamari';
+import { ContentEditable, SelectorFilter, SugarElement, Traverse } from '@ephox/sugar';
+
+import Editor from '../api/Editor';
+import Env from '../api/Env';
+import * as Options from '../api/Options';
+import * as NodeType from '../dom/NodeType';
+import * as ClientRect from '../geom/ClientRect';
+import * as CaretContainer from './CaretContainer';
+import * as CaretContainerRemove from './CaretContainerRemove';
+
+type GeomClientRect = ClientRect.ClientRect;
+
+export interface FakeCaret {
+  show: (before: boolean, element: Element) => Range | null;
+  hide: () => void;
+  getCss: () => string;
+  reposition: () => void;
+  destroy: () => void;
+}
+
+interface CaretState {
+  caret: HTMLElement;
+  element: HTMLElement;
+  before: boolean;
+}
+
+const isContentEditableFalse = NodeType.isContentEditableFalse;
+const isMedia = NodeType.isMedia;
+const isTableCell = NodeType.isTableCell;
+const inlineFakeCaretSelector = '*[contentEditable=false],video,audio,embed,object';
+
+const getAbsoluteClientRect = (root: HTMLElement, element: HTMLElement, before: boolean): GeomClientRect => {
+  const clientRect = ClientRect.collapse(element.getBoundingClientRect(), before);
+  let scrollX: number;
+  let scrollY: number;
+
+  if (root.tagName === 'BODY') {
+    const docElm = root.ownerDocument.documentElement;
+    scrollX = root.scrollLeft || docElm.scrollLeft;
+    scrollY = root.scrollTop || docElm.scrollTop;
+  } else {
+    const rootRect = root.getBoundingClientRect();
+    scrollX = root.scrollLeft - rootRect.left;
+    scrollY = root.scrollTop - rootRect.top;
+  }
+
+  clientRect.left += scrollX;
+  clientRect.right += scrollX;
+  clientRect.top += scrollY;
+  clientRect.bottom += scrollY;
+  clientRect.width = 1;
+
+  let margin = element.offsetWidth - element.clientWidth;
+
+  if (margin > 0) {
+    if (before) {
+      margin *= -1;
+    }
+
+    clientRect.left += margin;
+    clientRect.right += margin;
+  }
+
+  return clientRect;
+};
+
+const trimInlineCaretContainers = (root: HTMLElement): void => {
+  const fakeCaretTargetNodes = SelectorFilter.descendants(SugarElement.fromDom(root), inlineFakeCaretSelector);
+  for (let i = 0; i < fakeCaretTargetNodes.length; i++) {
+    const node = fakeCaretTargetNodes[i].dom;
+
+    let sibling = node.previousSibling;
+    if (CaretContainer.endsWithCaretContainer(sibling)) {
+      const data = sibling.data;
+
+      if (data.length === 1) {
+        sibling.parentNode?.removeChild(sibling);
+      } else {
+        sibling.deleteData(data.length - 1, 1);
+      }
+    }
+
+    sibling = node.nextSibling;
+    if (CaretContainer.startsWithCaretContainer(sibling)) {
+      const data = sibling.data;
+
+      if (data.length === 1) {
+        sibling.parentNode?.removeChild(sibling);
+      } else {
+        sibling.deleteData(0, 1);
+      }
+    }
+  }
+};
+
+export const FakeCaret = (editor: Editor, root: HTMLElement, isBlock: (node: Node) => node is HTMLElement, hasFocus: () => boolean): FakeCaret => {
+  const lastVisualCaret = Singleton.value<CaretState>();
+  let cursorInterval: number | undefined;
+  let caretContainerNode: Node | null;
+  const caretBlock = Options.getForcedRootBlock(editor);
+  const dom = editor.dom;
+
+  const show = (before: boolean, element: Element): Range | null => {
+    let rng: Range;
+
+    hide();
+
+    if (isTableCell(element)) {
+      return null;
+    }
+
+    if (isBlock(element)) {
+      const caretContainer = CaretContainer.insertBlock(caretBlock, element, before);
+      const clientRect = getAbsoluteClientRect(root, element, before);
+      dom.setStyle(caretContainer, 'top', clientRect.top);
+      dom.setStyle(caretContainer, 'caret-color', 'transparent');
+      caretContainerNode = caretContainer;
+
+      const caret = dom.create('div', { 'class': 'mce-visual-caret', 'data-mce-bogus': 'all' });
+      dom.setStyles(caret, { ...clientRect });
+      dom.add(root, caret);
+      lastVisualCaret.set({ caret, element, before });
+
+      if (before) {
+        dom.addClass(caret, 'mce-visual-caret-before');
+      }
+      startBlink();
+
+      rng = element.ownerDocument.createRange();
+      rng.setStart(caretContainer, 0);
+      rng.setEnd(caretContainer, 0);
+    } else {
+      caretContainerNode = CaretContainer.insertInline(element, before);
+      rng = element.ownerDocument.createRange();
+
+      if (isInlineFakeCaretTarget(caretContainerNode.nextSibling)) {
+        rng.setStart(caretContainerNode, 0);
+        rng.setEnd(caretContainerNode, 0);
+      } else {
+        rng.setStart(caretContainerNode, 1);
+        rng.setEnd(caretContainerNode, 1);
+      }
+
+      return rng;
+    }
+
+    return rng;
+  };
+
+  const hide = () => {
+    // TODO: TINY-6015 - Ensure cleaning up the fake caret preserves the selection, as currently
+    //  the CaretContainerRemove.remove below will change the selection in some cases
+    trimInlineCaretContainers(root);
+
+    if (caretContainerNode) {
+      CaretContainerRemove.remove(caretContainerNode);
+      caretContainerNode = null;
+    }
+
+    lastVisualCaret.on((caretState) => {
+      dom.remove(caretState.caret);
+      lastVisualCaret.clear();
+    });
+
+    if (cursorInterval) {
+      clearInterval(cursorInterval);
+      cursorInterval = undefined;
+    }
+  };
+
+  const startBlink = () => {
+    cursorInterval = setInterval(() => {
+      lastVisualCaret.on((caretState) => {
+        if (hasFocus()) {
+          dom.toggleClass(caretState.caret, 'mce-visual-caret-hidden');
+        } else {
+          dom.addClass(caretState.caret, 'mce-visual-caret-hidden');
+        }
+      });
+    }, 500);
+  };
+
+  const reposition = () => {
+    lastVisualCaret.on((caretState) => {
+      const clientRect = getAbsoluteClientRect(root, caretState.element, caretState.before);
+      dom.setStyles(caretState.caret, { ...clientRect });
+    });
+  };
+
+  const destroy = () => clearInterval(cursorInterval);
+
+  const getCss = () => (
+    '.mce-visual-caret {' +
+      'position: absolute;' +
+      'background-color: black;' +
+      'background-color: currentcolor;' +
+      // 'background-color: red;' +
+      '}' +
+      '.mce-visual-caret-hidden {' +
+      'display: none;' +
+      '}' +
+      '*[data-mce-caret] {' +
+      'position: absolute;' +
+      'left: -1000px;' +
+      'right: auto;' +
+      'top: 0;' +
+      'margin: 0;' +
+      'padding: 0;' +
+      '}'
+  );
+
+  return {
+    show,
+    hide,
+    getCss,
+    reposition,
+    destroy
+  };
+};
+
+export const isFakeCaretTableBrowser = (): boolean => Env.browser.isFirefox();
+
+export const isInlineFakeCaretTarget = (node: Node | undefined | null): node is HTMLElement =>
+  isContentEditableFalse(node) || isMedia(node);
+
+export const isFakeCaretTarget = (node: Node | undefined | null): node is HTMLElement => {
+  const isTarget = isInlineFakeCaretTarget(node) || (NodeType.isTable(node) && isFakeCaretTableBrowser());
+  return isTarget && Traverse.parentElement(SugarElement.fromDom(node)).exists(ContentEditable.isEditable);
+};

package/src/core/main/ts/caret/FakeCaretUtils.ts

@@ -0,0 +1,60 @@
+import { Optional } from '@ephox/katamari';
+
+import Editor from '../api/Editor';
+import * as CefUtils from '../dom/CefUtils';
+import CaretPosition from './CaretPosition';
+import * as CaretUtils from './CaretUtils';
+import { isInlineFakeCaretTarget } from './FakeCaret';
+
+const showCaret = (direction: number, editor: Editor, node: HTMLElement, before: boolean, scrollIntoView: boolean): Optional<Range> =>
+  // TODO: Figure out a better way to handle this dependency
+  Optional.from(editor._selectionOverrides.showCaret(direction, node, before, scrollIntoView));
+
+const getNodeRange = (node: Element): Range => {
+  const rng = node.ownerDocument.createRange();
+  rng.selectNode(node);
+  return rng;
+};
+
+const selectNode = (editor: Editor, node: Element): Optional<Range> => {
+  const e = editor.dispatch('BeforeObjectSelected', { target: node });
+  if (e.isDefaultPrevented()) {
+    return Optional.none();
+  }
+
+  return Optional.some(getNodeRange(node));
+};
+
+const renderCaretAtRange = (editor: Editor, range: Range, scrollIntoView: boolean): Optional<Range> => {
+  const normalizedRange = CaretUtils.normalizeRange(1, editor.getBody(), range);
+  const caretPosition = CaretPosition.fromRangeStart(normalizedRange);
+
+  const caretPositionNode = caretPosition.getNode();
+
+  if (isInlineFakeCaretTarget(caretPositionNode)) {
+    return showCaret(1, editor, caretPositionNode, !caretPosition.isAtEnd(), false);
+  }
+
+  const caretPositionBeforeNode = caretPosition.getNode(true);
+  if (isInlineFakeCaretTarget(caretPositionBeforeNode)) {
+    return showCaret(1, editor, caretPositionBeforeNode, false, false);
+  }
+
+  // TODO: Should render caret before/after depending on where you click on the page forces after now
+  const ceRoot = CefUtils.getContentEditableRoot(editor.dom.getRoot(), caretPosition.getNode());
+  if (isInlineFakeCaretTarget(ceRoot)) {
+    return showCaret(1, editor, ceRoot, false, scrollIntoView);
+  }
+
+  return Optional.none();
+};
+
+const renderRangeCaret = (editor: Editor, range: Range, scrollIntoView: boolean): Range =>
+  range.collapsed ? renderCaretAtRange(editor, range, scrollIntoView).getOr(range) : range;
+
+export {
+  showCaret,
+  selectNode,
+  renderCaretAtRange,
+  renderRangeCaret
+};

package/src/core/main/ts/caret/InsertText.ts

@@ -0,0 +1,37 @@
+import { Fun, Optional, Unicode } from '@ephox/katamari';
+import { Insert, SugarElement } from '@ephox/sugar';
+
+import * as NodeType from '../dom/NodeType';
+import { CaretPosition } from './CaretPosition';
+import { getElementFromPosition } from './CaretUtils';
+
+const insertTextAtPosition = (text: string, pos: CaretPosition): Optional<CaretPosition> => {
+  const container = pos.container();
+  const offset = pos.offset();
+
+  if (NodeType.isText(container)) {
+    container.insertData(offset, text);
+    return Optional.some(CaretPosition(container, offset + text.length));
+  } else {
+    return getElementFromPosition(pos).map((elm) => {
+      const textNode = SugarElement.fromText(text);
+
+      if (pos.isAtEnd()) {
+        Insert.after(elm, textNode);
+      } else {
+        Insert.before(elm, textNode);
+      }
+
+      return CaretPosition(textNode.dom, text.length);
+    });
+  }
+};
+
+const insertNbspAtPosition = Fun.curry(insertTextAtPosition, Unicode.nbsp);
+const insertSpaceAtPosition = Fun.curry(insertTextAtPosition, ' ');
+
+export {
+  insertTextAtPosition,
+  insertNbspAtPosition,
+  insertSpaceAtPosition
+};

package/src/core/main/ts/caret/LineReader.ts

@@ -0,0 +1,133 @@
+import { Arr, Fun, Optional, Optionals } from '@ephox/katamari';
+
+import * as NodeType from '../dom/NodeType';
+import * as CaretFinder from './CaretFinder';
+import { CaretPosition } from './CaretPosition';
+import { isInSameBlock } from './CaretUtils';
+import { CaretWalker, HDirection } from './CaretWalker';
+
+export enum BreakType {
+  Br,
+  Block,
+  Wrap,
+  Eol
+}
+
+export interface LineInfo {
+  positions: CaretPosition[];
+  breakType: BreakType;
+  breakAt: Optional<CaretPosition>;
+}
+
+type CheckerPredicate = typeof CaretPosition.isAbove | typeof CaretPosition.isBelow;
+type LineInfoFinder = (scope: HTMLElement, start: CaretPosition) => LineInfo;
+
+const flip = (direction: HDirection, positions: CaretPosition[]): CaretPosition[] =>
+  direction === HDirection.Backwards ? Arr.reverse(positions) : positions;
+
+const walk = (direction: HDirection, caretWalker: CaretWalker, pos: CaretPosition): CaretPosition | null =>
+  direction === HDirection.Forwards ? caretWalker.next(pos) : caretWalker.prev(pos);
+
+const getBreakType = (scope: HTMLElement, direction: HDirection, currentPos: CaretPosition, nextPos: CaretPosition): BreakType => {
+  if (NodeType.isBr(nextPos.getNode(direction === HDirection.Forwards))) {
+    return BreakType.Br;
+  } else if (isInSameBlock(currentPos, nextPos) === false) {
+    return BreakType.Block;
+  } else {
+    return BreakType.Wrap;
+  }
+};
+
+const getPositionsUntil = (predicate: CheckerPredicate, direction: HDirection, scope: HTMLElement, start: CaretPosition): LineInfo => {
+  const caretWalker = CaretWalker(scope);
+  let currentPos = start;
+  const positions: CaretPosition[] = [];
+
+  while (currentPos) {
+    const nextPos = walk(direction, caretWalker, currentPos);
+
+    if (!nextPos) {
+      break;
+    }
+
+    if (NodeType.isBr(nextPos.getNode(false))) {
+      if (direction === HDirection.Forwards) {
+        return { positions: flip(direction, positions).concat([ nextPos ]), breakType: BreakType.Br, breakAt: Optional.some(nextPos) };
+      } else {
+        return { positions: flip(direction, positions), breakType: BreakType.Br, breakAt: Optional.some(nextPos) };
+      }
+    }
+
+    if (!nextPos.isVisible()) {
+      currentPos = nextPos;
+      continue;
+    }
+
+    if (predicate(currentPos, nextPos)) {
+      const breakType = getBreakType(scope, direction, currentPos, nextPos);
+      return { positions: flip(direction, positions), breakType, breakAt: Optional.some(nextPos) };
+    }
+
+    positions.push(nextPos);
+    currentPos = nextPos;
+  }
+
+  return { positions: flip(direction, positions), breakType: BreakType.Eol, breakAt: Optional.none() };
+};
+
+const getAdjacentLinePositions = (direction: HDirection, getPositionsUntilBreak: LineInfoFinder, scope: HTMLElement, start: CaretPosition): CaretPosition[] =>
+  getPositionsUntilBreak(scope, start).breakAt.map((pos) => {
+    const positions = getPositionsUntilBreak(scope, pos).positions;
+    return direction === HDirection.Backwards ? positions.concat(pos) : [ pos ].concat(positions);
+  }).getOr([]);
+
+const findClosestHorizontalPositionFromPoint = (positions: CaretPosition[], x: number): Optional<CaretPosition> =>
+  Arr.foldl(positions, (acc, newPos) => acc.fold(
+    () => Optional.some(newPos),
+    (lastPos) => Optionals.lift2(Arr.head(lastPos.getClientRects()), Arr.head(newPos.getClientRects()), (lastRect, newRect) => {
+      const lastDist = Math.abs(x - lastRect.left);
+      const newDist = Math.abs(x - newRect.left);
+      return newDist <= lastDist ? newPos : lastPos;
+    }).or(acc)
+  ), Optional.none());
+
+const findClosestHorizontalPosition = (positions: CaretPosition[], pos: CaretPosition): Optional<CaretPosition> =>
+  Arr.head(pos.getClientRects()).bind((targetRect) => findClosestHorizontalPositionFromPoint(positions, targetRect.left));
+
+const getPositionsUntilPreviousLine = Fun.curry(getPositionsUntil, CaretPosition.isAbove, -1);
+const getPositionsUntilNextLine = Fun.curry(getPositionsUntil, CaretPosition.isBelow, 1);
+const getPositionsAbove = Fun.curry(getAdjacentLinePositions, -1, getPositionsUntilPreviousLine);
+const getPositionsBelow = Fun.curry(getAdjacentLinePositions, 1, getPositionsUntilNextLine);
+
+const isAtFirstLine = (scope: HTMLElement, pos: CaretPosition): boolean =>
+  getPositionsUntilPreviousLine(scope, pos).breakAt.isNone();
+
+const isAtLastLine = (scope: HTMLElement, pos: CaretPosition): boolean =>
+  getPositionsUntilNextLine(scope, pos).breakAt.isNone();
+
+const getFirstLinePositions = (scope: HTMLElement): CaretPosition[] =>
+  CaretFinder.firstPositionIn(scope).map((pos) => [ pos ].concat(getPositionsUntilNextLine(scope, pos).positions)).getOr([]);
+
+const getLastLinePositions = (scope: HTMLElement): CaretPosition[] =>
+  CaretFinder.lastPositionIn(scope).map((pos) => getPositionsUntilPreviousLine(scope, pos).positions.concat(pos)).getOr([]);
+
+const getClosestPositionAbove = (scope: HTMLElement, pos: CaretPosition): Optional<CaretPosition> =>
+  findClosestHorizontalPosition(getPositionsAbove(scope, pos), pos);
+
+const getClosestPositionBelow = (scope: HTMLElement, pos: CaretPosition): Optional<CaretPosition> =>
+  findClosestHorizontalPosition(getPositionsBelow(scope, pos), pos);
+
+export {
+  getPositionsUntilPreviousLine,
+  getPositionsUntilNextLine,
+  isAtFirstLine,
+  isAtLastLine,
+  getPositionsAbove,
+  getPositionsBelow,
+  findClosestHorizontalPosition,
+  findClosestHorizontalPositionFromPoint,
+  getFirstLinePositions,
+  getLastLinePositions,
+  getClosestPositionAbove,
+  getClosestPositionBelow
+};

package/src/core/main/ts/caret/LineUtils.ts

@@ -0,0 +1,34 @@
+import { Obj } from '@ephox/katamari';
+
+import { NodeClientRect } from '../dom/Dimensions';
+import * as NodeType from '../dom/NodeType';
+import * as ClientRect from '../geom/ClientRect';
+import * as ArrUtils from '../util/ArrUtils';
+
+type GeomClientRect = ClientRect.ClientRect;
+
+const isContentEditableFalse = NodeType.isContentEditableFalse;
+const distanceToRectLeft = (clientRect: GeomClientRect, clientX: number) => Math.abs(clientRect.left - clientX);
+const distanceToRectRight = (clientRect: GeomClientRect, clientX: number) => Math.abs(clientRect.right - clientX);
+const isNodeClientRect = (rect: GeomClientRect): rect is NodeClientRect => Obj.hasNonNullableKey((rect as any), 'node');
+
+const findClosestClientRect = <T extends GeomClientRect>(clientRects: T[], clientX: number): T =>
+  ArrUtils.reduce(clientRects, (oldClientRect, clientRect) => {
+    const oldDistance = Math.min(distanceToRectLeft(oldClientRect, clientX), distanceToRectRight(oldClientRect, clientX));
+    const newDistance = Math.min(distanceToRectLeft(clientRect, clientX), distanceToRectRight(clientRect, clientX));
+
+    // cE=false has higher priority
+    if (newDistance === oldDistance && isNodeClientRect(clientRect) && isContentEditableFalse(clientRect.node)) {
+      return clientRect;
+    }
+
+    if (newDistance < oldDistance) {
+      return clientRect;
+    }
+
+    return oldClientRect;
+  });
+
+export {
+  findClosestClientRect
+};