opentiny 6.9.0 → 6.9.1

package/src/plugins/lists/main/ts/core/Bookmark.ts

@@ -1,126 +0,0 @@
-import DOMUtils from 'tinymce/core/api/dom/DOMUtils';
-
-import * as NodeType from './NodeType';
-import * as Range from './RangeUtils';
-
-const DOM = DOMUtils.DOM;
-
-interface Bookmark {
-  startContainer: Node;
-  startOffset: number;
-  endContainer?: Node;
-  endOffset?: number;
-}
-
-/**
- * Returns a range bookmark. This will convert indexed bookmarks into temporary span elements with
- * index 0 so that they can be restored properly after the DOM has been modified. Text bookmarks will not have spans
- * added to them since they can be restored after a dom operation.
- *
- * So this: <p><b>|</b><b>|</b></p>
- * becomes: <p><b><span data-mce-type="bookmark">|</span></b><b data-mce-type="bookmark">|</span></b></p>
- *
- * @param  {DOMRange} rng DOM Range to get bookmark on.
- * @return {Object} Bookmark object.
- */
-const createBookmark = (rng: Range): Bookmark => {
-  const bookmark: Partial<Bookmark> = {};
-
-  const setupEndPoint = (start?: boolean) => {
-    let container = rng[start ? 'startContainer' : 'endContainer'];
-    let offset = rng[start ? 'startOffset' : 'endOffset'];
-
-    if (NodeType.isElement(container)) {
-      const offsetNode = DOM.create('span', { 'data-mce-type': 'bookmark' });
-
-      if (container.hasChildNodes()) {
-        offset = Math.min(offset, container.childNodes.length - 1);
-
-        if (start) {
-          container.insertBefore(offsetNode, container.childNodes[offset]);
-        } else {
-          DOM.insertAfter(offsetNode, container.childNodes[offset]);
-        }
-      } else {
-        container.appendChild(offsetNode);
-      }
-
-      container = offsetNode;
-      offset = 0;
-    }
-
-    bookmark[start ? 'startContainer' : 'endContainer'] = container;
-    bookmark[start ? 'startOffset' : 'endOffset'] = offset;
-  };
-
-  setupEndPoint(true);
-
-  if (!rng.collapsed) {
-    setupEndPoint();
-  }
-
-  return bookmark as Bookmark;
-};
-
-const resolveBookmark = (bookmark: Bookmark): Range => {
-  const restoreEndPoint = (start?: boolean) => {
-    const nodeIndex = (container: Node): number => {
-      let node = container.parentNode?.firstChild;
-      let idx = 0;
-
-      while (node) {
-        if (node === container) {
-          return idx;
-        }
-
-        // Skip data-mce-type=bookmark nodes
-        if (!NodeType.isElement(node) || node.getAttribute('data-mce-type') !== 'bookmark') {
-          idx++;
-        }
-
-        node = node.nextSibling;
-      }
-
-      return -1;
-    };
-
-    let container: Node | null | undefined = bookmark[start ? 'startContainer' : 'endContainer'];
-    let offset = bookmark[start ? 'startOffset' : 'endOffset'];
-
-    if (!container) {
-      return;
-    }
-
-    if (NodeType.isElement(container) && container.parentNode) {
-      const node = container;
-      offset = nodeIndex(container);
-      container = container.parentNode;
-      DOM.remove(node);
-
-      if (!container.hasChildNodes() && DOM.isBlock(container)) {
-        container.appendChild(DOM.create('br'));
-      }
-    }
-
-    bookmark[start ? 'startContainer' : 'endContainer'] = container;
-    bookmark[start ? 'startOffset' : 'endOffset'] = offset as number;
-  };
-
-  restoreEndPoint(true);
-  restoreEndPoint();
-
-  const rng = DOM.createRng();
-
-  rng.setStart(bookmark.startContainer, bookmark.startOffset);
-
-  if (bookmark.endContainer) {
-    rng.setEnd(bookmark.endContainer, bookmark.endOffset as number);
-  }
-
-  return Range.normalizeRange(rng);
-};
-
-export {
-  createBookmark,
-  resolveBookmark
-};

package/src/plugins/lists/main/ts/core/Delete.ts

@@ -1,317 +0,0 @@
-import { Arr, Optional, Optionals } from '@ephox/katamari';
-import { Compare, ContentEditable, PredicateFind, Remove, SugarElement, SugarNode } from '@ephox/sugar';
-
-import DOMUtils from 'tinymce/core/api/dom/DOMUtils';
-import RangeUtils from 'tinymce/core/api/dom/RangeUtils';
-import DomTreeWalker from 'tinymce/core/api/dom/TreeWalker';
-import Editor from 'tinymce/core/api/Editor';
-import VK from 'tinymce/core/api/util/VK';
-
-import { flattenListSelection, outdentListSelection } from '../actions/Indendation';
-import * as ToggleList from '../actions/ToggleList';
-import * as Bookmark from './Bookmark';
-import * as NodeType from './NodeType';
-import * as NormalizeLists from './NormalizeLists';
-import * as ListRangeUtils from './RangeUtils';
-import * as Selection from './Selection';
-import { isWithinNonEditableList } from './Util';
-
-const findNextCaretContainer = (editor: Editor, rng: Range, isForward: boolean, root: Node): Node | null => {
-  let node: Node | null | undefined = rng.startContainer;
-  const offset = rng.startOffset;
-
-  if (NodeType.isTextNode(node) && (isForward ? offset < node.data.length : offset > 0)) {
-    return node;
-  }
-
-  const nonEmptyBlocks = editor.schema.getNonEmptyElements();
-  if (NodeType.isElement(node)) {
-    node = RangeUtils.getNode(node, offset);
-  }
-
-  const walker = new DomTreeWalker(node, root);
-
-  // Delete at <li>|<br></li> then jump over the bogus br
-  if (isForward) {
-    if (NodeType.isBogusBr(editor.dom, node)) {
-      walker.next();
-    }
-  }
-
-  const walkFn = isForward ? walker.next.bind(walker) : walker.prev2.bind(walker);
-  while ((node = walkFn())) {
-    if (node.nodeName === 'LI' && !node.hasChildNodes()) {
-      return node;
-    }
-
-    if (nonEmptyBlocks[node.nodeName]) {
-      return node;
-    }
-
-    if (NodeType.isTextNode(node) && node.data.length > 0) {
-      return node;
-    }
-  }
-
-  return null;
-};
-
-const hasOnlyOneBlockChild = (dom: DOMUtils, elm: Element): boolean => {
-  const childNodes = elm.childNodes;
-  return childNodes.length === 1 && !NodeType.isListNode(childNodes[0]) && dom.isBlock(childNodes[0]);
-};
-
-const isUnwrappable = (node: Node | null): node is HTMLElement =>
-  Optional.from(node)
-    .map(SugarElement.fromDom)
-    .filter(SugarNode.isHTMLElement)
-    .exists((el) => ContentEditable.isEditable(el) && !Arr.contains([ 'details' ], SugarNode.name(el)));
-
-const unwrapSingleBlockChild = (dom: DOMUtils, elm: Element): void => {
-  if (hasOnlyOneBlockChild(dom, elm) && isUnwrappable(elm.firstChild)) {
-    dom.remove(elm.firstChild, true);
-  }
-};
-
-const moveChildren = (dom: DOMUtils, fromElm: Element, toElm: Element): void => {
-  let node;
-
-  const targetElm = hasOnlyOneBlockChild(dom, toElm) ? toElm.firstChild as HTMLElement : toElm;
-  unwrapSingleBlockChild(dom, fromElm);
-
-  if (!NodeType.isEmpty(dom, fromElm, true)) {
-    while ((node = fromElm.firstChild)) {
-      targetElm.appendChild(node);
-    }
-  }
-};
-
-const mergeLiElements = (dom: DOMUtils, fromElm: Element, toElm: Element): void => {
-  let listNode: HTMLElement | undefined;
-  const ul = fromElm.parentNode as Node;
-
-  if (!NodeType.isChildOfBody(dom, fromElm) || !NodeType.isChildOfBody(dom, toElm)) {
-    return;
-  }
-
-  if (NodeType.isListNode(toElm.lastChild)) {
-    listNode = toElm.lastChild;
-  }
-
-  if (ul === toElm.lastChild) {
-    if (NodeType.isBr(ul.previousSibling)) {
-      dom.remove(ul.previousSibling);
-    }
-  }
-
-  const node = toElm.lastChild;
-  if (node && NodeType.isBr(node) && fromElm.hasChildNodes()) {
-    dom.remove(node);
-  }
-
-  if (NodeType.isEmpty(dom, toElm, true)) {
-    Remove.empty(SugarElement.fromDom(toElm));
-  }
-
-  moveChildren(dom, fromElm, toElm);
-
-  if (listNode) {
-    toElm.appendChild(listNode);
-  }
-
-  const contains = Compare.contains(SugarElement.fromDom(toElm), SugarElement.fromDom(fromElm));
-
-  const nestedLists = contains ? dom.getParents(fromElm, NodeType.isListNode, toElm) : [];
-
-  dom.remove(fromElm);
-
-  Arr.each(nestedLists, (list) => {
-    if (NodeType.isEmpty(dom, list) && list !== dom.getRoot()) {
-      dom.remove(list);
-    }
-  });
-};
-
-const mergeIntoEmptyLi = (editor: Editor, fromLi: HTMLLIElement, toLi: HTMLLIElement): void => {
-  Remove.empty(SugarElement.fromDom(toLi));
-  mergeLiElements(editor.dom, fromLi, toLi);
-  editor.selection.setCursorLocation(toLi, 0);
-};
-
-const mergeForward = (editor: Editor, rng: Range, fromLi: HTMLLIElement, toLi: HTMLLIElement): void => {
-  const dom = editor.dom;
-
-  if (dom.isEmpty(toLi)) {
-    mergeIntoEmptyLi(editor, fromLi, toLi);
-  } else {
-    const bookmark = Bookmark.createBookmark(rng);
-    mergeLiElements(dom, fromLi, toLi);
-    editor.selection.setRng(Bookmark.resolveBookmark(bookmark));
-  }
-};
-
-const mergeBackward = (editor: Editor, rng: Range, fromLi: HTMLLIElement, toLi: HTMLLIElement): void => {
-  const bookmark = Bookmark.createBookmark(rng);
-  mergeLiElements(editor.dom, fromLi, toLi);
-  const resolvedBookmark = Bookmark.resolveBookmark(bookmark);
-  editor.selection.setRng(resolvedBookmark);
-};
-
-const backspaceDeleteFromListToListCaret = (editor: Editor, isForward: boolean): boolean => {
-  const dom = editor.dom, selection = editor.selection;
-  const selectionStartElm = selection.getStart();
-  const root = Selection.getClosestEditingHost(editor, selectionStartElm);
-  const li = dom.getParent(selection.getStart(), 'LI', root) as HTMLLIElement;
-
-  if (li) {
-    const ul = li.parentElement;
-    if (ul === editor.getBody() && NodeType.isEmpty(dom, ul)) {
-      return true;
-    }
-
-    const rng = ListRangeUtils.normalizeRange(selection.getRng());
-    const otherLi = dom.getParent(findNextCaretContainer(editor, rng, isForward, root), 'LI', root) as HTMLLIElement;
-    const willMergeParentIntoChild = otherLi && (isForward ? dom.isChildOf(li, otherLi) : dom.isChildOf(otherLi, li));
-
-    if (otherLi && otherLi !== li && !willMergeParentIntoChild) {
-      editor.undoManager.transact(() => {
-        if (isForward) {
-          mergeForward(editor, rng, otherLi, li);
-        } else {
-          if (NodeType.isFirstChild(li)) {
-            outdentListSelection(editor);
-          } else {
-            mergeBackward(editor, rng, li, otherLi);
-          }
-        }
-      });
-
-      return true;
-    } else if (willMergeParentIntoChild && !isForward && otherLi !== li) {
-      editor.undoManager.transact(() => {
-        if (rng.commonAncestorContainer.parentElement) {
-          const bookmark = Bookmark.createBookmark(rng);
-          const oldParentElRef = rng.commonAncestorContainer.parentElement;
-          moveChildren(dom, rng.commonAncestorContainer.parentElement, otherLi);
-          oldParentElRef.remove();
-          const resolvedBookmark = Bookmark.resolveBookmark(bookmark);
-          editor.selection.setRng(resolvedBookmark);
-        }
-      });
-
-      return true;
-    } else if (!otherLi) {
-      if (!isForward && rng.startOffset === 0 && rng.endOffset === 0) {
-        editor.undoManager.transact(() => {
-          flattenListSelection(editor);
-        });
-
-        return true;
-      }
-    }
-  }
-
-  return false;
-};
-
-const removeBlock = (dom: DOMUtils, block: Element, root: Node): void => {
-  const parentBlock = dom.getParent(block.parentNode, dom.isBlock, root);
-
-  dom.remove(block);
-  if (parentBlock && dom.isEmpty(parentBlock)) {
-    dom.remove(parentBlock);
-  }
-};
-
-const backspaceDeleteIntoListCaret = (editor: Editor, isForward: boolean): boolean => {
-  const dom = editor.dom;
-  const selectionStartElm = editor.selection.getStart();
-  const root = Selection.getClosestEditingHost(editor, selectionStartElm);
-  const block = dom.getParent(selectionStartElm, dom.isBlock, root);
-
-  if (block && dom.isEmpty(block, undefined, { checkRootAsContent: true })) {
-    const rng = ListRangeUtils.normalizeRange(editor.selection.getRng());
-    const otherLi = dom.getParent(findNextCaretContainer(editor, rng, isForward, root), 'LI', root);
-
-    if (otherLi) {
-      const findValidElement = (element: SugarElement<Node>) => Arr.contains([ 'td', 'th', 'caption' ], SugarNode.name(element));
-      const findRoot = (node: SugarElement<Node>) => node.dom === root;
-      const otherLiCell = PredicateFind.closest(SugarElement.fromDom(otherLi), findValidElement, findRoot);
-      const caretCell = PredicateFind.closest(SugarElement.fromDom(rng.startContainer), findValidElement, findRoot);
-
-      if (!Optionals.equals(otherLiCell, caretCell, Compare.eq)) {
-        return false;
-      }
-
-      editor.undoManager.transact(() => {
-        const parentNode = otherLi.parentNode as HTMLElement;
-        removeBlock(dom, block, root);
-        ToggleList.mergeWithAdjacentLists(dom, parentNode);
-        editor.selection.select(otherLi, true);
-        editor.selection.collapse(isForward);
-      });
-
-      return true;
-    }
-  }
-
-  return false;
-};
-
-const backspaceDeleteCaret = (editor: Editor, isForward: boolean): boolean => {
-  return backspaceDeleteFromListToListCaret(editor, isForward) || backspaceDeleteIntoListCaret(editor, isForward);
-};
-
-const hasListSelection = (editor: Editor) => {
-  const selectionStartElm = editor.selection.getStart();
-  const root = Selection.getClosestEditingHost(editor, selectionStartElm);
-  const startListParent = editor.dom.getParent(selectionStartElm, 'LI,DT,DD', root);
-
-  return startListParent || Selection.getSelectedListItems(editor).length > 0;
-};
-
-const backspaceDeleteRange = (editor: Editor): boolean => {
-  if (hasListSelection(editor)) {
-    editor.undoManager.transact(() => {
-      editor.execCommand('Delete');
-      NormalizeLists.normalizeLists(editor.dom, editor.getBody());
-    });
-
-    return true;
-  }
-
-  return false;
-};
-
-const backspaceDelete = (editor: Editor, isForward: boolean): boolean => {
-  const selection = editor.selection;
-  return !isWithinNonEditableList(editor, selection.getNode()) && (selection.isCollapsed() ?
-    backspaceDeleteCaret(editor, isForward) : backspaceDeleteRange(editor)
-  );
-};
-
-const setup = (editor: Editor): void => {
-  editor.on('ExecCommand', (e) => {
-    const cmd = e.command.toLowerCase();
-    if ((cmd === 'delete' || cmd === 'forwarddelete') && hasListSelection(editor)) {
-      NormalizeLists.normalizeLists(editor.dom, editor.getBody());
-    }
-  });
-
-  editor.on('keydown', (e) => {
-    if (e.keyCode === VK.BACKSPACE) {
-      if (backspaceDelete(editor, false)) {
-        e.preventDefault();
-      }
-    } else if (e.keyCode === VK.DELETE) {
-      if (backspaceDelete(editor, true)) {
-        e.preventDefault();
-      }
-    }
-  });
-};
-
-export {
-  setup,
-  backspaceDelete
-};

package/src/plugins/lists/main/ts/core/DlIndentation.ts

@@ -1,36 +0,0 @@
-import { Arr } from '@ephox/katamari';
-import { Replication, SugarElement, SugarNode, Traverse } from '@ephox/sugar';
-
-import Editor from 'tinymce/core/api/Editor';
-
-import { Indentation } from '../listmodel/Indentation';
-import * as SplitList from './SplitList';
-
-const isDescriptionDetail = SugarNode.isTag('dd');
-const isDescriptionTerm = SugarNode.isTag('dt');
-
-const outdentDlItem = (editor: Editor, item: SugarElement<Node>): void => {
-  if (isDescriptionDetail(item)) {
-    Replication.mutate(item, 'dt');
-  } else if (isDescriptionTerm(item)) {
-    Traverse.parentElement(item).each((dl) => SplitList.splitList(editor, dl.dom, item.dom));
-  }
-};
-
-const indentDlItem = (item: SugarElement<Node>): void => {
-  if (isDescriptionTerm(item)) {
-    Replication.mutate(item, 'dd');
-  }
-};
-
-const dlIndentation = (editor: Editor, indentation: Indentation, dlItems: SugarElement<Node>[]): void => {
-  if (indentation === Indentation.Indent) {
-    Arr.each(dlItems, indentDlItem);
-  } else {
-    Arr.each(dlItems, (item) => outdentDlItem(editor, item));
-  }
-};
-
-export {
-  dlIndentation
-};

package/src/plugins/lists/main/ts/core/FilterContent.ts

@@ -1,46 +0,0 @@
-import { Arr } from '@ephox/katamari';
-
-import Editor from 'tinymce/core/api/Editor';
-import AstNode from 'tinymce/core/api/html/Node';
-
-const isTextNode = (node: AstNode) => node.type === 3;
-const isEmpty = (nodeBuffer: AstNode[]) => nodeBuffer.length === 0;
-
-const wrapInvalidChildren = (list: AstNode) => {
-  const insertListItem = (buffer: AstNode[], refNode?: AstNode) => {
-    const li = AstNode.create('li');
-    Arr.each(buffer, (node) => li.append(node));
-    if (refNode) {
-      list.insert(li, refNode, true);
-    } else {
-      list.append(li);
-    }
-  };
-
-  const reducer = (buffer: AstNode[], node: AstNode): AstNode[] => {
-    if (isTextNode(node)) {
-      return [ ...buffer, node ];
-    } else if (!isEmpty(buffer) && !isTextNode(node)) {
-      insertListItem(buffer, node);
-      return [];
-    } else {
-      return buffer;
-    }
-  };
-
-  const restBuffer = Arr.foldl(list.children(), reducer, []);
-  if (!isEmpty(restBuffer)) {
-    insertListItem(restBuffer);
-  }
-};
-
-const setup = (editor: Editor): void => {
-  editor.on('PreInit', () => {
-    const { parser } = editor;
-    parser.addNodeFilter('ul,ol', (nodes) => Arr.each(nodes, wrapInvalidChildren));
-  });
-};
-
-export {
-  setup
-};

package/src/plugins/lists/main/ts/core/Keyboard.ts

@@ -1,33 +0,0 @@
-import Editor from 'tinymce/core/api/Editor';
-import VK from 'tinymce/core/api/util/VK';
-
-import { indentListSelection, outdentListSelection } from '../actions/Indendation';
-import * as Options from '../api/Options';
-import * as Delete from './Delete';
-
-const setupTabKey = (editor: Editor): void => {
-  editor.on('keydown', (e) => {
-    // Check for tab but not ctrl/cmd+tab since it switches browser tabs
-    if (e.keyCode !== VK.TAB || VK.metaKeyPressed(e)) {
-      return;
-    }
-
-    editor.undoManager.transact(() => {
-      if (e.shiftKey ? outdentListSelection(editor) : indentListSelection(editor)) {
-        e.preventDefault();
-      }
-    });
-  });
-};
-
-const setup = (editor: Editor): void => {
-  if (Options.shouldIndentOnTab(editor)) {
-    setupTabKey(editor);
-  }
-
-  Delete.setup(editor);
-};
-
-export {
-  setup
-};

package/src/plugins/lists/main/ts/core/ListAction.ts

@@ -1,15 +0,0 @@
-export const enum ListAction {
-  ToggleUlList = 'ToggleUlList',
-  ToggleOlList = 'ToggleOlList',
-  ToggleDLList = 'ToggleDLList',
-  IndentList = 'IndentList',
-  OutdentList = 'OutdentList'
-}
-
-export const listToggleActionFromListName = (listName: 'UL' | 'OL' | 'DL'): ListAction => {
-  switch (listName) {
-    case 'UL': return ListAction.ToggleUlList;
-    case 'OL': return ListAction.ToggleOlList;
-    case 'DL': return ListAction.ToggleDLList;
-  }
-};

package/src/plugins/lists/main/ts/core/ListNumbering.ts

@@ -1,108 +0,0 @@
-import { Arr, Optional, Optionals, Strings } from '@ephox/katamari';
-
-export interface ListDetail {
-  readonly start: string;
-  readonly listStyleType: Optional<string>;
-}
-
-const enum ListType {
-  UpperAlpha,
-  LowerAlpha,
-  Numeric,
-  None,
-  Unknown
-}
-
-// Example: 'AB' -> 28
-const parseAlphabeticBase26 = (str: string): number => {
-  const chars = Arr.reverse(Strings.trim(str).split(''));
-  const values = Arr.map(chars, (char, i) => {
-    const charValue = char.toUpperCase().charCodeAt(0) - 'A'.charCodeAt(0) + 1;
-    return Math.pow(26, i) * charValue;
-  });
-  return Arr.foldl(values, (sum, v) => sum + v, 0);
-};
-
-// Example: 28 -> 'AB'
-const composeAlphabeticBase26 = (value: number): string => {
-  value--;
-  if (value < 0) {
-    return '';
-  } else {
-    const remainder = value % 26;
-    const quotient = Math.floor(value / 26);
-
-    const rest = composeAlphabeticBase26(quotient);
-    const char = String.fromCharCode('A'.charCodeAt(0) + remainder);
-
-    return rest + char;
-  }
-};
-
-const isUppercase = (str: string): boolean => /^[A-Z]+$/.test(str);
-
-const isLowercase = (str: string): boolean => /^[a-z]+$/.test(str);
-
-const isNumeric = (str: string): boolean => /^[0-9]+$/.test(str);
-
-const deduceListType = (start: string): ListType => {
-  if (isNumeric(start)) {
-    return ListType.Numeric;
-  } else if (isUppercase(start)) {
-    return ListType.UpperAlpha;
-  } else if (isLowercase(start)) {
-    return ListType.LowerAlpha;
-  } else if (Strings.isEmpty(start)) {
-    return ListType.None;
-  } else {
-    return ListType.Unknown;
-  }
-};
-
-const parseStartValue = (start: string): Optional<ListDetail> => {
-  switch (deduceListType(start)) {
-    case ListType.Numeric:
-      return Optional.some({
-        listStyleType: Optional.none(),
-        start
-      });
-
-    case ListType.UpperAlpha:
-      return Optional.some({
-        listStyleType: Optional.some('upper-alpha'),
-        start: parseAlphabeticBase26(start).toString()
-      });
-
-    case ListType.LowerAlpha:
-      return Optional.some({
-        listStyleType: Optional.some('lower-alpha'),
-        start: parseAlphabeticBase26(start).toString()
-      });
-
-    case ListType.None:
-      return Optional.some({
-        listStyleType: Optional.none(),
-        start: ''
-      });
-
-    case ListType.Unknown:
-      return Optional.none();
-  }
-};
-
-const parseDetail = (detail: ListDetail): string => {
-  const start = parseInt(detail.start, 10);
-
-  if (Optionals.is(detail.listStyleType, 'upper-alpha')) {
-    return composeAlphabeticBase26(start);
-  } else if (Optionals.is(detail.listStyleType, 'lower-alpha')) {
-    return composeAlphabeticBase26(start).toLowerCase();
-  } else {
-    return detail.start;
-  }
-};
-
-export {
-  parseStartValue,
-  parseDetail
-};