opentiny 6.9.0 → 6.9.2

package/src/core/main/ts/delete/InlineFormatDelete.ts

@@ -1,169 +0,0 @@
-import { Arr, Fun, Optional, Type } from '@ephox/katamari';
-import { PredicateExists, SugarElement, SugarNode, Traverse } from '@ephox/sugar';
-
-import Editor from '../api/Editor';
-import Schema from '../api/html/Schema';
-import CaretPosition from '../caret/CaretPosition';
-import * as NodeType from '../dom/NodeType';
-import * as Parents from '../dom/Parents';
-import * as CaretFormat from '../fmt/CaretFormat';
-import * as FormatContainer from '../fmt/FormatContainer';
-import * as FormatUtils from '../fmt/FormatUtils';
-import * as DeleteElement from './DeleteElement';
-import * as DeleteUtils from './DeleteUtils';
-
-const hasMultipleChildren = (elm: SugarElement<Node>): boolean =>
-  Traverse.childNodesCount(elm) > 1;
-
-const getParentsUntil = (editor: Editor, pred: (elm: SugarElement<Node>) => boolean): SugarElement<Node>[] => {
-  const rootElm = SugarElement.fromDom(editor.getBody());
-  const startElm = SugarElement.fromDom(editor.selection.getStart());
-  const parents = Parents.parentsAndSelf(startElm, rootElm);
-  return Arr.findIndex(parents, pred).fold(
-    Fun.constant(parents),
-    (index) => parents.slice(0, index)
-  );
-};
-
-const hasOnlyOneChild = (elm: SugarElement<Node>): boolean =>
-  Traverse.childNodesCount(elm) === 1;
-
-const getParentInlinesUntilMultichildInline = (editor: Editor): SugarElement<Node>[] =>
-  getParentsUntil(editor, (elm) => editor.schema.isBlock(SugarNode.name(elm)) || hasMultipleChildren(elm));
-
-const getParentInlines = (editor: Editor): SugarElement<Node>[] =>
-  getParentsUntil(editor, (el) => editor.schema.isBlock(SugarNode.name(el)));
-
-const getFormatNodes = (editor: Editor, parentInlines: SugarElement<Node>[]): Node[] => {
-  const isFormatElement = Fun.curry(CaretFormat.isFormatElement, editor);
-  return Arr.bind(parentInlines, (elm) => isFormatElement(elm) ? [ elm.dom ] : [ ]);
-};
-
-const getFormatNodesAtStart = (editor: Editor) => {
-  const parentInlines = getParentInlines(editor);
-  return getFormatNodes(editor, parentInlines);
-};
-
-const deleteLastPosition = (forward: boolean, editor: Editor, target: SugarElement<Node>, parentInlines: SugarElement<Node>[]): void => {
-  const formatNodes = getFormatNodes(editor, parentInlines);
-
-  if (formatNodes.length === 0) {
-    DeleteElement.deleteElement(editor, forward, target);
-  } else {
-    const pos = CaretFormat.replaceWithCaretFormat(target.dom, formatNodes);
-    editor.selection.setRng(pos.toRange());
-  }
-};
-
-const deleteCaret = (editor: Editor, forward: boolean): Optional<() => void> => {
-  const parentInlines = Arr.filter(getParentInlinesUntilMultichildInline(editor), hasOnlyOneChild);
-  return Arr.last(parentInlines).bind((target) => {
-    const fromPos = CaretPosition.fromRangeStart(editor.selection.getRng());
-    if (DeleteUtils.willDeleteLastPositionInElement(forward, fromPos, target.dom) && !FormatUtils.isEmptyCaretFormatElement(target)) {
-      return Optional.some(() => deleteLastPosition(forward, editor, target, parentInlines));
-    } else {
-      return Optional.none();
-    }
-  });
-};
-
-const isBrInEmptyElement = (editor: Editor, elm: Element): boolean => {
-  const parentElm = elm.parentElement;
-  return NodeType.isBr(elm) && !Type.isNull(parentElm) && editor.dom.isEmpty(parentElm);
-};
-
-const isEmptyCaret = (elm: Element): boolean =>
-  FormatUtils.isEmptyCaretFormatElement(SugarElement.fromDom(elm));
-
-const createCaretFormatAtStart = (editor: Editor, formatNodes: Node[]): void => {
-  const startElm = editor.selection.getStart();
-  // replace <br> in empty node or existing caret at start if applicable
-  // otherwise create new caret format at start
-  const pos = isBrInEmptyElement(editor, startElm) || isEmptyCaret(startElm)
-    ? CaretFormat.replaceWithCaretFormat(startElm, formatNodes)
-    : CaretFormat.createCaretFormatAtStart(editor.selection.getRng(), formatNodes);
-  editor.selection.setRng(pos.toRange());
-};
-
-const updateCaretFormat = (editor: Editor, updateFormats: Node[]): void => {
-  // Create a caret format at cursor containing missing formats to ensure all formats
-  // that are supposed to be retained are retained
-  const missingFormats = Arr.difference(updateFormats, getFormatNodesAtStart(editor));
-  if (missingFormats.length > 0) {
-    createCaretFormatAtStart(editor, missingFormats);
-  }
-};
-
-const rangeStartsAtTextContainer = (rng: Range): boolean =>
-  NodeType.isText(rng.startContainer);
-
-const rangeStartsAtStartOfTextContainer = (rng: Range): boolean =>
-  rng.startOffset === 0 && rangeStartsAtTextContainer(rng);
-
-const rangeStartParentIsFormatElement = (editor: Editor, rng: Range): boolean => {
-  const startParent = rng.startContainer.parentElement;
-  return !Type.isNull(startParent) && CaretFormat.isFormatElement(editor, SugarElement.fromDom(startParent));
-};
-
-const rangeStartAndEndHaveSameParent = (rng: Range): boolean => {
-  const startParent = rng.startContainer.parentNode;
-  const endParent = rng.endContainer.parentNode;
-  return !Type.isNull(startParent) && !Type.isNull(endParent) && startParent.isEqualNode(endParent);
-};
-
-const rangeEndsAtEndOfEndContainer = (rng: Range): boolean => {
-  const endContainer = rng.endContainer;
-  return rng.endOffset === (NodeType.isText(endContainer) ? endContainer.length : endContainer.childNodes.length);
-};
-
-const rangeEndsAtEndOfStartContainer = (rng: Range): boolean =>
-  rangeStartAndEndHaveSameParent(rng) && rangeEndsAtEndOfEndContainer(rng);
-
-const rangeEndsAfterEndOfStartContainer = (rng: Range): boolean =>
-  !rng.endContainer.isEqualNode(rng.commonAncestorContainer);
-
-const rangeEndsAtOrAfterEndOfStartContainer = (rng: Range): boolean =>
-  rangeEndsAtEndOfStartContainer(rng) || rangeEndsAfterEndOfStartContainer(rng);
-
-const requiresDeleteRangeOverride = (editor: Editor): boolean => {
-  const rng = editor.selection.getRng();
-  return rangeStartsAtStartOfTextContainer(rng) && rangeStartParentIsFormatElement(editor, rng) && rangeEndsAtOrAfterEndOfStartContainer(rng);
-};
-
-const deleteRange = (editor: Editor): Optional<() => void> => {
-  if (requiresDeleteRangeOverride(editor)) {
-    const formatNodes = getFormatNodesAtStart(editor);
-    return Optional.some(() => {
-      DeleteUtils.execNativeDeleteCommand(editor);
-      updateCaretFormat(editor, formatNodes);
-    });
-  } else {
-    return Optional.none();
-  }
-};
-
-const backspaceDelete = (editor: Editor, forward: boolean): Optional<() => void> =>
-  editor.selection.isCollapsed() ? deleteCaret(editor, forward) : deleteRange(editor);
-
-const hasAncestorInlineCaret = (elm: SugarElement<Node>, schema: Schema): boolean =>
-  PredicateExists.ancestor(elm, (node) => FormatContainer.isCaretNode(node.dom), (el) => schema.isBlock(SugarNode.name(el)));
-
-const hasAncestorInlineCaretAtStart = (editor: Editor): boolean =>
-  hasAncestorInlineCaret(SugarElement.fromDom(editor.selection.getStart()), editor.schema);
-
-const requiresRefreshCaretOverride = (editor: Editor): boolean => {
-  const rng = editor.selection.getRng();
-  return rng.collapsed && (rangeStartsAtTextContainer(rng) || editor.dom.isEmpty(rng.startContainer)) && !hasAncestorInlineCaretAtStart(editor);
-};
-
-const refreshCaret = (editor: Editor): boolean => {
-  if (requiresRefreshCaretOverride(editor)) {
-    createCaretFormatAtStart(editor, []);
-  }
-  return true;
-};
-
-export {
-  backspaceDelete,
-  refreshCaret
-};

package/src/core/main/ts/delete/MediaDelete.ts

@@ -1,47 +0,0 @@
-import { Optional, Type } from '@ephox/katamari';
-import { SugarElement } from '@ephox/sugar';
-
-import Editor from '../api/Editor';
-import { isAfterMedia, isBeforeMedia } from '../caret/CaretPositionPredicates';
-import * as CaretUtils from '../caret/CaretUtils';
-import { HDirection } from '../caret/CaretWalker';
-import * as NodeType from '../dom/NodeType';
-import * as InlineUtils from '../keyboard/InlineUtils';
-import * as DeleteElement from './DeleteElement';
-
-const deleteElement = (editor: Editor, forward: boolean, element: Node | undefined): Optional<() => void> => {
-  if (Type.isNonNullable(element)) {
-    return Optional.some(() => {
-      editor._selectionOverrides.hideFakeCaret();
-      DeleteElement.deleteElement(editor, forward, SugarElement.fromDom(element));
-    });
-  } else {
-    return Optional.none();
-  }
-};
-
-const deleteCaret = (editor: Editor, forward: boolean): Optional<() => void> => {
-  const isNearMedia = forward ? isBeforeMedia : isAfterMedia;
-  const direction = forward ? HDirection.Forwards : HDirection.Backwards;
-  const fromPos = CaretUtils.getNormalizedRangeEndPoint(direction, editor.getBody(), editor.selection.getRng());
-
-  if (isNearMedia(fromPos)) {
-    return deleteElement(editor, forward, fromPos.getNode(!forward));
-  } else {
-    return Optional.from(InlineUtils.normalizePosition(forward, fromPos))
-      .filter((pos) => isNearMedia(pos) && CaretUtils.isMoveInsideSameBlock(fromPos, pos))
-      .bind((pos) => deleteElement(editor, forward, pos.getNode(!forward)));
-  }
-};
-
-const deleteRange = (editor: Editor, forward: boolean): Optional<() => void> => {
-  const selectedNode = editor.selection.getNode();
-  return NodeType.isMedia(selectedNode) ? deleteElement(editor, forward, selectedNode) : Optional.none();
-};
-
-const backspaceDelete = (editor: Editor, forward: boolean): Optional<() => void> =>
-  editor.selection.isCollapsed() ? deleteCaret(editor, forward) : deleteRange(editor, forward);
-
-export {
-  backspaceDelete
-};

package/src/core/main/ts/delete/MergeBlocks.ts

@@ -1,128 +0,0 @@
-import { Arr, Fun, Optional } from '@ephox/katamari';
-import { Compare, Insert, Remove, Replication, SugarElement, SugarNode, Traverse } from '@ephox/sugar';
-
-import Schema from '../api/html/Schema';
-import * as CaretFinder from '../caret/CaretFinder';
-import CaretPosition from '../caret/CaretPosition';
-import * as ElementType from '../dom/ElementType';
-import * as Empty from '../dom/Empty';
-import * as PaddingBr from '../dom/PaddingBr';
-import * as Parents from '../dom/Parents';
-
-const getChildrenUntilBlockBoundary = (block: SugarElement<Element>, schema: Schema): SugarElement<Node>[] => {
-  const children = Traverse.children(block);
-  return Arr.findIndex(children, (el) => schema.isBlock(SugarNode.name(el))).fold(
-    Fun.constant(children),
-    (index) => children.slice(0, index)
-  );
-};
-
-const extractChildren = (block: SugarElement<Element>, schema: Schema): SugarElement<Node>[] => {
-  const children = getChildrenUntilBlockBoundary(block, schema);
-  Arr.each(children, Remove.remove);
-  return children;
-};
-
-const removeEmptyRoot = (schema: Schema, rootNode: SugarElement<Node>, block: SugarElement<Element>) => {
-  const parents = Parents.parentsAndSelf(block, rootNode);
-  return Arr.find(parents.reverse(), (element) => Empty.isEmpty(schema, element)).each(Remove.remove);
-};
-
-const isEmptyBefore = (schema: Schema, el: SugarElement<Node>): boolean =>
-  Arr.filter(Traverse.prevSiblings(el), (el) => !Empty.isEmpty(schema, el)).length === 0;
-
-const nestedBlockMerge = (
-  rootNode: SugarElement<Node>,
-  fromBlock: SugarElement<Element>,
-  toBlock: SugarElement<Element>,
-  schema: Schema,
-  insertionPoint: SugarElement<Node>
-): Optional<CaretPosition> => {
-  if (Empty.isEmpty(schema, toBlock)) {
-    PaddingBr.fillWithPaddingBr(toBlock);
-    return CaretFinder.firstPositionIn(toBlock.dom);
-  }
-
-  if (isEmptyBefore(schema, insertionPoint) && Empty.isEmpty(schema, fromBlock)) {
-    Insert.before(insertionPoint, SugarElement.fromTag('br'));
-  }
-
-  const position = CaretFinder.prevPosition(toBlock.dom, CaretPosition.before(insertionPoint.dom));
-  Arr.each(extractChildren(fromBlock, schema), (child) => {
-    Insert.before(insertionPoint, child);
-  });
-  removeEmptyRoot(schema, rootNode, fromBlock);
-  return position;
-};
-
-const isInline = (schema: Schema, node: SugarElement<Node>): node is SugarElement<HTMLElement> => schema.isInline(SugarNode.name(node));
-
-const sidelongBlockMerge = (rootNode: SugarElement<Node>, fromBlock: SugarElement<Element>, toBlock: SugarElement<Element>, schema: Schema): Optional<CaretPosition> => {
-  if (Empty.isEmpty(schema, toBlock)) {
-    if (Empty.isEmpty(schema, fromBlock)) {
-      const getInlineToBlockDescendants = (el: SugarElement<Element>) => {
-        const helper = (node: SugarElement<Element>, elements: SugarElement<Element>[]): SugarElement<Element>[] =>
-          Traverse.firstChild(node).fold(
-            () => elements,
-            (child) => isInline(schema, child) ? helper(child, elements.concat(Replication.shallow(child))) : elements
-          );
-        return helper(el, []);
-      };
-
-      const newFromBlockDescendants = Arr.foldr(
-        getInlineToBlockDescendants(toBlock),
-        (element: SugarElement<Element>, descendant) => {
-          Insert.wrap(element, descendant);
-          return descendant;
-        },
-        PaddingBr.createPaddingBr()
-      );
-
-      Remove.empty(fromBlock);
-      Insert.append(fromBlock, newFromBlockDescendants);
-    }
-
-    Remove.remove(toBlock);
-    return CaretFinder.firstPositionIn(fromBlock.dom);
-  }
-
-  const position = CaretFinder.lastPositionIn(toBlock.dom);
-  Arr.each(extractChildren(fromBlock, schema), (child) => {
-    Insert.append(toBlock, child);
-  });
-  removeEmptyRoot(schema, rootNode, fromBlock);
-  return position;
-};
-
-const findInsertionPoint = (toBlock: SugarElement<Element>, block: SugarElement<Element>) => {
-  const parentsAndSelf = Parents.parentsAndSelf(block, toBlock);
-  return Optional.from(parentsAndSelf[parentsAndSelf.length - 1]);
-};
-
-const getInsertionPoint = (fromBlock: SugarElement<Element>, toBlock: SugarElement<Element>): Optional<SugarElement> =>
-  Compare.contains(toBlock, fromBlock) ? findInsertionPoint(toBlock, fromBlock) : Optional.none();
-
-const trimBr = (first: boolean, block: SugarElement<Element>) => {
-  CaretFinder.positionIn(first, block.dom)
-    .bind((position) => Optional.from(position.getNode()))
-    .map(SugarElement.fromDom)
-    .filter(ElementType.isBr)
-    .each(Remove.remove);
-};
-
-const mergeBlockInto = (rootNode: SugarElement<Node>, fromBlock: SugarElement<Element>, toBlock: SugarElement<Element>, schema: Schema): Optional<CaretPosition> => {
-  trimBr(true, fromBlock);
-  trimBr(false, toBlock);
-
-  return getInsertionPoint(fromBlock, toBlock).fold(
-    Fun.curry(sidelongBlockMerge, rootNode, fromBlock, toBlock, schema),
-    Fun.curry(nestedBlockMerge, rootNode, fromBlock, toBlock, schema)
-  );
-};
-
-const mergeBlocks = (rootNode: SugarElement<Node>, forward: boolean, block1: SugarElement<Element>, block2: SugarElement<Element>, schema: Schema): Optional<CaretPosition> =>
-  forward ? mergeBlockInto(rootNode, block2, block1, schema) : mergeBlockInto(rootNode, block1, block2, schema);
-
-export {
-  mergeBlocks
-};

package/src/core/main/ts/delete/MergeText.ts

@@ -1,66 +0,0 @@
-import { Strings } from '@ephox/katamari';
-import { PredicateFind, Remove, SugarElement, SugarNode } from '@ephox/sugar';
-
-import Schema from '../api/html/Schema';
-import CaretPosition from '../caret/CaretPosition';
-import * as Nbsps from '../keyboard/Nbsps';
-import * as Whitespace from '../text/Whitespace';
-
-const normalize = (node: Text, offset: number, count: number, schema: Schema): void => {
-  if (count === 0) {
-    return;
-  }
-  const elm = SugarElement.fromDom(node);
-  const root = PredicateFind.ancestor(elm, (el) => schema.isBlock(SugarNode.name(el))).getOr(elm);
-
-  // Get the whitespace
-  const whitespace = node.data.slice(offset, offset + count);
-
-  // Determine if we're at the end or start of the content
-  const isEndOfContent = offset + count >= node.data.length && Nbsps.needsToBeNbspRight(root, CaretPosition(node, node.data.length), schema);
-  const isStartOfContent = offset === 0 && Nbsps.needsToBeNbspLeft(root, CaretPosition(node, 0), schema);
-
-  // Replace the original whitespace with the normalized whitespace content
-  node.replaceData(offset, count, Whitespace.normalize(whitespace, 4, isStartOfContent, isEndOfContent));
-};
-
-const normalizeWhitespaceAfter = (node: Text, offset: number, schema: Schema): void => {
-  const content = node.data.slice(offset);
-  const whitespaceCount = content.length - Strings.lTrim(content).length;
-
-  normalize(node, offset, whitespaceCount, schema);
-};
-
-const normalizeWhitespaceBefore = (node: Text, offset: number, schema: Schema): void => {
-  const content = node.data.slice(0, offset);
-  const whitespaceCount = content.length - Strings.rTrim(content).length;
-
-  normalize(node, offset - whitespaceCount, whitespaceCount, schema);
-};
-
-const mergeTextNodes = (prevNode: Text, nextNode: Text, schema: Schema, normalizeWhitespace?: boolean, mergeToPrev: boolean = true): Text => {
-  const whitespaceOffset = Strings.rTrim(prevNode.data).length;
-  const newNode = mergeToPrev ? prevNode : nextNode;
-  const removeNode = mergeToPrev ? nextNode : prevNode;
-
-  // Merge the elements
-  if (mergeToPrev) {
-    newNode.appendData(removeNode.data);
-  } else {
-    newNode.insertData(0, removeNode.data);
-  }
-  Remove.remove(SugarElement.fromDom(removeNode));
-
-  // Normalize the whitespace around the merged elements, to ensure it doesn't get lost
-  if (normalizeWhitespace) {
-    normalizeWhitespaceAfter(newNode, whitespaceOffset, schema);
-  }
-
-  return newNode;
-};
-
-export {
-  normalizeWhitespaceAfter,
-  normalizeWhitespaceBefore,
-  mergeTextNodes
-};

package/src/core/main/ts/delete/Outdent.ts

@@ -1,25 +0,0 @@
-import { Optional } from '@ephox/katamari';
-import { SugarElement } from '@ephox/sugar';
-
-import Editor from '../api/Editor';
-import * as BlockBoundary from '../caret/BlockBoundary';
-import CaretPosition from '../caret/CaretPosition';
-import * as IndentOutdent from '../commands/IndentOutdent';
-
-const backspaceDelete = (editor: Editor): Optional<() => void> => {
-  if (editor.selection.isCollapsed() && IndentOutdent.canOutdent(editor)) {
-    const dom = editor.dom;
-    const rng = editor.selection.getRng();
-    const pos = CaretPosition.fromRangeStart(rng);
-    const block = dom.getParent(rng.startContainer, dom.isBlock);
-    if (block !== null && BlockBoundary.isAtStartOfBlock(SugarElement.fromDom(block), pos, editor.schema)) {
-      return Optional.some(() => IndentOutdent.outdent(editor));
-    }
-  }
-
-  return Optional.none();
-};
-
-export {
-  backspaceDelete
-};