opentiny 6.9.0 → 6.9.2

package/src/core/main/ts/selection/RangeWalk.ts

@@ -1,107 +0,0 @@
-import DOMUtils from '../api/dom/DOMUtils';
-import * as NodeType from '../dom/NodeType';
-import * as RangeNodes from './RangeNodes';
-import { RangeLikeObject } from './RangeTypes';
-
-const walk = (dom: DOMUtils, rng: RangeLikeObject, callback: (nodes: Node[]) => void): void => {
-  const startOffset = rng.startOffset;
-  const startContainer = RangeNodes.getNode(rng.startContainer, startOffset);
-  const endOffset = rng.endOffset;
-  const endContainer = RangeNodes.getNode(rng.endContainer, endOffset - 1);
-
-  /**
-   * Excludes start/end text node if they are out side the range
-   *
-   * @private
-   * @param {Array} nodes Nodes to exclude items from.
-   * @return {Array} Array with nodes excluding the start/end container if needed.
-   */
-  const exclude = (nodes: Node[]) => {
-    // First node is excluded
-    const firstNode = nodes[0];
-    if (NodeType.isText(firstNode) && firstNode === startContainer && startOffset >= firstNode.data.length) {
-      nodes.splice(0, 1);
-    }
-
-    // Last node is excluded
-    const lastNode = nodes[nodes.length - 1];
-    if (endOffset === 0 && nodes.length > 0 && lastNode === endContainer && NodeType.isText(lastNode)) {
-      nodes.splice(nodes.length - 1, 1);
-    }
-
-    return nodes;
-  };
-
-  const collectSiblings = (node: Node | null, name: 'nextSibling' | 'previousSibling', endNode?: Node | null) => {
-    const siblings = [];
-
-    for (; node && node !== endNode; node = node[name]) {
-      siblings.push(node);
-    }
-
-    return siblings;
-  };
-
-  const findEndPoint = (node: Node, root: Node) =>
-    dom.getParent(node, (node) => node.parentNode === root, root);
-
-  const walkBoundary = (startNode: Node, endNode: Node, next?: boolean) => {
-    const siblingName = next ? 'nextSibling' : 'previousSibling';
-
-    for (let node: Node | null = startNode, parent = node.parentNode; node && node !== endNode; node = parent) {
-      parent = node.parentNode;
-      const siblings = collectSiblings(node === startNode ? node : node[siblingName], siblingName);
-
-      if (siblings.length) {
-        if (!next) {
-          siblings.reverse();
-        }
-
-        callback(exclude(siblings));
-      }
-    }
-  };
-
-  // Same container
-  if (startContainer === endContainer) {
-    return callback(exclude([ startContainer ]));
-  }
-
-  // Find common ancestor and end points
-  const ancestor = dom.findCommonAncestor(startContainer, endContainer) ?? dom.getRoot();
-
-  // Process left side
-  if (dom.isChildOf(startContainer, endContainer)) {
-    return walkBoundary(startContainer, ancestor, true);
-  }
-
-  // Process right side
-  if (dom.isChildOf(endContainer, startContainer)) {
-    return walkBoundary(endContainer, ancestor);
-  }
-
-  // Find start/end point
-  const startPoint = findEndPoint(startContainer, ancestor) || startContainer;
-  const endPoint = findEndPoint(endContainer, ancestor) || endContainer;
-
-  // Walk left leaf
-  walkBoundary(startContainer, startPoint, true);
-
-  // Walk the middle from start to end point
-  const siblings = collectSiblings(
-    startPoint === startContainer ? startPoint : startPoint.nextSibling,
-    'nextSibling',
-    endPoint === endContainer ? endPoint.nextSibling : endPoint
-  );
-
-  if (siblings.length) {
-    callback(exclude(siblings));
-  }
-
-  // Walk right leaf
-  walkBoundary(endContainer, endPoint);
-};
-
-export {
-  walk
-};

package/src/core/main/ts/selection/SelectionBookmark.ts

@@ -1,107 +0,0 @@
-import { Optional } from '@ephox/katamari';
-import { Compare, SimRange, SimSelection, SugarElement, SugarNode, SugarText, Traverse } from '@ephox/sugar';
-
-import Editor from '../api/Editor';
-import Env from '../api/Env';
-import * as NodeType from '../dom/NodeType';
-
-const clamp = (offset: number, element: SugarElement<Node>): number => {
-  const max = SugarNode.isText(element) ? SugarText.get(element).length : Traverse.children(element).length + 1;
-
-  if (offset > max) {
-    return max;
-  } else if (offset < 0) {
-    return 0;
-  }
-
-  return offset;
-};
-
-const normalizeRng = (rng: SimRange): SimRange =>
-  SimSelection.range(
-    rng.start,
-    clamp(rng.soffset, rng.start),
-    rng.finish,
-    clamp(rng.foffset, rng.finish)
-  );
-
-const isOrContains = (root: SugarElement<Node>, elm: SugarElement<Node>): boolean =>
-  !NodeType.isRestrictedNode(elm.dom) && (Compare.contains(root, elm) || Compare.eq(root, elm));
-
-const isRngInRoot = (root: SugarElement<Node>) => (rng: SimRange): boolean =>
-  isOrContains(root, rng.start) && isOrContains(root, rng.finish);
-
-// TINY-9259: We need to store the selection on Firefox since if the editor is hidden the selection.getRng() api will not work as expected.
-const shouldStore = (editor: Editor) => editor.inline || Env.browser.isFirefox();
-
-const nativeRangeToSelectionRange = (r: Range): SimRange =>
-  SimSelection.range(SugarElement.fromDom(r.startContainer), r.startOffset, SugarElement.fromDom(r.endContainer), r.endOffset);
-
-const readRange = (win: Window): Optional<SimRange> => {
-  const selection = win.getSelection();
-  const rng = !selection || selection.rangeCount === 0 ? Optional.none() : Optional.from(selection.getRangeAt(0));
-  return rng.map(nativeRangeToSelectionRange);
-};
-
-const getBookmark = (root: SugarElement<Node>): Optional<SimRange> => {
-  const win = Traverse.defaultView(root);
-
-  return readRange(win.dom)
-    .filter(isRngInRoot(root));
-};
-
-const validate = (root: SugarElement<Node>, bookmark: SimRange): Optional<SimRange> =>
-  Optional.from(bookmark)
-    .filter(isRngInRoot(root))
-    .map(normalizeRng);
-
-const bookmarkToNativeRng = (bookmark: SimRange): Optional<Range> => {
-  const rng = document.createRange();
-
-  try {
-    // Might throw IndexSizeError
-    rng.setStart(bookmark.start.dom, bookmark.soffset);
-    rng.setEnd(bookmark.finish.dom, bookmark.foffset);
-    return Optional.some(rng);
-  } catch (_) {
-    return Optional.none();
-  }
-};
-
-const store = (editor: Editor): void => {
-  const newBookmark = shouldStore(editor) ? getBookmark(SugarElement.fromDom(editor.getBody())) : Optional.none<SimRange>();
-
-  editor.bookmark = newBookmark.isSome() ? newBookmark : editor.bookmark;
-};
-
-const storeNative = (editor: Editor, rng: Range): void => {
-  const root = SugarElement.fromDom(editor.getBody());
-  const range = shouldStore(editor) ? Optional.from(rng) : Optional.none<Range>();
-
-  const newBookmark = range.map(nativeRangeToSelectionRange)
-    .filter(isRngInRoot(root));
-
-  editor.bookmark = newBookmark.isSome() ? newBookmark : editor.bookmark;
-};
-
-const getRng = (editor: Editor): Optional<Range> => {
-  const bookmark: Optional<SimRange> = editor.bookmark ? editor.bookmark : Optional.none();
-
-  return bookmark
-    .bind((x) => validate(SugarElement.fromDom(editor.getBody()), x))
-    .bind(bookmarkToNativeRng);
-};
-
-const restore = (editor: Editor): void => {
-  getRng(editor).each((rng) => editor.selection.setRng(rng));
-};
-
-export {
-  store,
-  storeNative,
-  readRange,
-  restore,
-  getRng,
-  getBookmark,
-  validate
-};

package/src/core/main/ts/selection/SelectionRestore.ts

@@ -1,63 +0,0 @@
-import { Throttler } from '@ephox/katamari';
-
-import DOMUtils from '../api/dom/DOMUtils';
-import Editor from '../api/Editor';
-import { NodeChangeEvent, SetSelectionRangeEvent } from '../api/EventTypes';
-import { EditorEvent } from '../api/util/EventDispatcher';
-import * as SelectionBookmark from './SelectionBookmark';
-
-type StoreThrottler = Throttler.Throttler<[]>;
-
-const isManualNodeChange = (e: EditorEvent<NodeChangeEvent | KeyboardEvent | SetSelectionRangeEvent>) => {
-  return e.type === 'nodechange' && (e as NodeChangeEvent).selectionChange;
-};
-
-const registerPageMouseUp = (editor: Editor, throttledStore: StoreThrottler) => {
-  const mouseUpPage = () => {
-    throttledStore.throttle();
-  };
-
-  DOMUtils.DOM.bind(document, 'mouseup', mouseUpPage);
-
-  editor.on('remove', () => {
-    DOMUtils.DOM.unbind(document, 'mouseup', mouseUpPage);
-  });
-};
-
-const registerMouseUp = (editor: Editor, throttledStore: StoreThrottler) => {
-  editor.on('mouseup touchend', (_e) => {
-    throttledStore.throttle();
-  });
-};
-
-const registerEditorEvents = (editor: Editor, throttledStore: StoreThrottler) => {
-  registerMouseUp(editor, throttledStore);
-
-  editor.on('keyup NodeChange AfterSetSelectionRange', (e) => {
-    if (!isManualNodeChange(e)) {
-      SelectionBookmark.store(editor);
-    }
-  });
-};
-
-const register = (editor: Editor): void => {
-  const throttledStore = Throttler.first(() => {
-    SelectionBookmark.store(editor);
-  }, 0);
-
-  editor.on('init', () => {
-    if (editor.inline) {
-      registerPageMouseUp(editor, throttledStore);
-    }
-
-    registerEditorEvents(editor, throttledStore);
-  });
-
-  editor.on('remove', () => {
-    throttledStore.cancel();
-  });
-};
-
-export {
-  register
-};

package/src/core/main/ts/selection/SelectionUtils.ts

@@ -1,144 +0,0 @@
-import { Arr, Fun, Obj, Optional, Optionals, Type } from '@ephox/katamari';
-import { Compare, SugarElement, SugarNode, Traverse } from '@ephox/sugar';
-
-import DOMUtils from '../api/dom/DOMUtils';
-import EditorSelection from '../api/dom/Selection';
-import DomTreeWalker from '../api/dom/TreeWalker';
-import Editor from '../api/Editor';
-import Tools from '../api/util/Tools';
-import { IdBookmark, IndexBookmark } from '../bookmark/BookmarkTypes';
-import * as GetBookmark from '../bookmark/GetBookmark';
-import * as NodeType from '../dom/NodeType';
-import * as TableCellSelection from './TableCellSelection';
-
-const getStartNode = (rng: Range) => {
-  const sc = rng.startContainer, so = rng.startOffset;
-  if (NodeType.isText(sc)) {
-    return so === 0 ? Optional.some(SugarElement.fromDom(sc)) : Optional.none();
-  } else {
-    return Optional.from(sc.childNodes[so]).map(SugarElement.fromDom);
-  }
-};
-
-const getEndNode = (rng: Range) => {
-  const ec = rng.endContainer, eo = rng.endOffset;
-  if (NodeType.isText(ec)) {
-    return eo === ec.data.length ? Optional.some(SugarElement.fromDom(ec)) : Optional.none();
-  } else {
-    return Optional.from(ec.childNodes[eo - 1]).map(SugarElement.fromDom);
-  }
-};
-
-const getFirstChildren = (node: SugarElement<Node>): SugarElement<Node>[] => {
-  return Traverse.firstChild(node).fold(
-    Fun.constant([ node ]),
-    (child) => {
-      return [ node ].concat(getFirstChildren(child));
-    }
-  );
-};
-
-const getLastChildren = (node: SugarElement<Node>): SugarElement<Node>[] => {
-  return Traverse.lastChild(node).fold(
-    Fun.constant([ node ]),
-    (child) => {
-      if (SugarNode.name(child) === 'br') {
-        return Traverse.prevSibling(child).map((sibling) => {
-          return [ node ].concat(getLastChildren(sibling));
-        }).getOr([]);
-      } else {
-        return [ node ].concat(getLastChildren(child));
-      }
-    }
-  );
-};
-
-const hasAllContentsSelected = (elm: SugarElement<Node>, rng: Range): boolean => {
-  return Optionals.lift2(getStartNode(rng), getEndNode(rng), (startNode, endNode) => {
-    const start = Arr.find(getFirstChildren(elm), Fun.curry(Compare.eq, startNode));
-    const end = Arr.find(getLastChildren(elm), Fun.curry(Compare.eq, endNode));
-    return start.isSome() && end.isSome();
-  }).getOr(false);
-};
-
-const moveEndPoint = (dom: DOMUtils, rng: Range, node: Node, start: boolean): void => {
-  const root = node;
-  const walker = new DomTreeWalker(node, root);
-  const moveCaretBeforeOnEnterElementsMap = Obj.filter(dom.schema.getMoveCaretBeforeOnEnterElements(), (_, name) =>
-    !Arr.contains([ 'td', 'th', 'table' ], name.toLowerCase())
-  );
-
-  let currentNode: Node | null | undefined = node;
-  do {
-    if (NodeType.isText(currentNode) && Tools.trim(currentNode.data).length !== 0) {
-      if (start) {
-        rng.setStart(currentNode, 0);
-      } else {
-        rng.setEnd(currentNode, currentNode.data.length);
-      }
-
-      return;
-    }
-
-    // BR/IMG/INPUT elements but not table cells
-    if (moveCaretBeforeOnEnterElementsMap[currentNode.nodeName]) {
-      if (start) {
-        rng.setStartBefore(currentNode);
-      } else {
-        if (currentNode.nodeName === 'BR') {
-          rng.setEndBefore(currentNode);
-        } else {
-          rng.setEndAfter(currentNode);
-        }
-      }
-
-      return;
-    }
-  } while ((currentNode = (start ? walker.next() : walker.prev())));
-
-  // Failed to find any text node or other suitable location then move to the root of body
-  if (root.nodeName === 'BODY') {
-    if (start) {
-      rng.setStart(root, 0);
-    } else {
-      rng.setEnd(root, root.childNodes.length);
-    }
-  }
-};
-
-const hasAnyRanges = (editor: Editor): boolean => {
-  const sel = editor.selection.getSel();
-  return Type.isNonNullable(sel) && sel.rangeCount > 0;
-};
-
-const runOnRanges = (editor: Editor, executor: (rng: Range, fake: boolean) => void): void => {
-  // Check to see if a fake selection is active. If so then we are simulating a multi range
-  // selection so we should return a range for each selected node.
-  // Note: Currently tables are the only thing supported for fake selections.
-  const fakeSelectionNodes = TableCellSelection.getCellsFromEditor(editor);
-  if (fakeSelectionNodes.length > 0) {
-    Arr.each(fakeSelectionNodes, (elem) => {
-      const node = elem.dom;
-      const fakeNodeRng = editor.dom.createRng();
-      fakeNodeRng.setStartBefore(node);
-      fakeNodeRng.setEndAfter(node);
-      executor(fakeNodeRng, true);
-    });
-  } else {
-    executor(editor.selection.getRng(), false);
-  }
-};
-
-const preserve = (selection: EditorSelection, fillBookmark: boolean, executor: (bookmark: IdBookmark | IndexBookmark) => void): void => {
-  const bookmark = GetBookmark.getPersistentBookmark(selection, fillBookmark);
-  executor(bookmark);
-  selection.moveToBookmark(bookmark);
-};
-
-export {
-  hasAllContentsSelected,
-  moveEndPoint,
-  hasAnyRanges,
-  runOnRanges,
-  preserve
-};

package/src/core/main/ts/selection/SetSelectionContent.ts

@@ -1,124 +0,0 @@
-import { Optional } from '@ephox/katamari';
-import { Remove, SugarElement, SugarNode, Traverse } from '@ephox/sugar';
-
-import BookmarkManager from '../api/dom/BookmarkManager';
-import Editor from '../api/Editor';
-import Schema from '../api/html/Schema';
-import HtmlSerializer from '../api/html/Serializer';
-import CaretPosition from '../caret/CaretPosition';
-import { SetSelectionContentArgs } from '../content/ContentTypes';
-import { postProcessSetContent, preProcessSetContent } from '../content/PrePostProcess';
-import * as MergeText from '../delete/MergeText';
-import * as ScrollIntoView from '../dom/ScrollIntoView';
-import { needsToBeNbspLeft, needsToBeNbspRight } from '../keyboard/Nbsps';
-
-const removeEmpty = (text: SugarElement<Text>): Optional<SugarElement<Text>> => {
-  if (text.dom.length === 0) {
-    Remove.remove(text);
-    return Optional.none();
-  } else {
-    return Optional.some(text);
-  }
-};
-
-const walkPastBookmark = (node: Optional<SugarElement<Node>>, start: boolean): Optional<SugarElement<Node>> =>
-  node.filter((elm) => BookmarkManager.isBookmarkNode(elm.dom))
-    .bind(start ? Traverse.nextSibling : Traverse.prevSibling);
-
-const merge = (outer: SugarElement<Text>, inner: SugarElement<Text>, rng: Range, start: boolean, schema: Schema) => {
-  const outerElm = outer.dom;
-  const innerElm = inner.dom;
-  const oldLength = start ? outerElm.length : innerElm.length;
-  if (start) {
-    MergeText.mergeTextNodes(outerElm, innerElm, schema, false, !start);
-    rng.setStart(innerElm, oldLength);
-  } else {
-    MergeText.mergeTextNodes(innerElm, outerElm, schema, false, !start);
-    rng.setEnd(innerElm, oldLength);
-  }
-};
-
-const normalizeTextIfRequired = (inner: SugarElement<Text>, start: boolean, schema: Schema) => {
-  Traverse.parent(inner).each((root) => {
-    const text = inner.dom;
-    if (start && needsToBeNbspLeft(root, CaretPosition(text, 0), schema)) {
-      MergeText.normalizeWhitespaceAfter(text, 0, schema);
-    } else if (!start && needsToBeNbspRight(root, CaretPosition(text, text.length), schema)) {
-      MergeText.normalizeWhitespaceBefore(text, text.length, schema);
-    }
-  });
-};
-
-const mergeAndNormalizeText = (outerNode: Optional<SugarElement<Text>>, innerNode: Optional<SugarElement<Node>>, rng: Range, start: boolean, schema: Schema) => {
-  outerNode.bind((outer) => {
-    // Normalize the text outside the inserted content
-    const normalizer = start ? MergeText.normalizeWhitespaceBefore : MergeText.normalizeWhitespaceAfter;
-    normalizer(outer.dom, start ? outer.dom.length : 0, schema);
-
-    // Merge the inserted content with other text nodes
-    return innerNode.filter(SugarNode.isText).map((inner) => merge(outer, inner, rng, start, schema));
-  }).orThunk(() => {
-    // Note: Attempt to leave the inserted/inner content as is and only adjust if absolutely required
-    const innerTextNode = walkPastBookmark(innerNode, start).or(innerNode).filter(SugarNode.isText);
-    return innerTextNode.map((inner) => normalizeTextIfRequired(inner, start, schema));
-  });
-};
-
-const rngSetContent = (rng: Range, fragment: DocumentFragment, schema: Schema): void => {
-  const firstChild = Optional.from(fragment.firstChild).map(SugarElement.fromDom);
-  const lastChild = Optional.from(fragment.lastChild).map(SugarElement.fromDom);
-
-  rng.deleteContents();
-  rng.insertNode(fragment);
-
-  const prevText = firstChild.bind(Traverse.prevSibling).filter(SugarNode.isText).bind(removeEmpty);
-  const nextText = lastChild.bind(Traverse.nextSibling).filter(SugarNode.isText).bind(removeEmpty);
-
-  // Join and normalize text
-  mergeAndNormalizeText(prevText, firstChild, rng, true, schema);
-  mergeAndNormalizeText(nextText, lastChild, rng, false, schema);
-
-  rng.collapse(false);
-};
-
-const setupArgs = (args: Partial<SetSelectionContentArgs>, content: string): SetSelectionContentArgs => ({
-  format: 'html',
-  ...args,
-  set: true,
-  selection: true,
-  content
-});
-
-const cleanContent = (editor: Editor, args: SetSelectionContentArgs) => {
-  if (args.format !== 'raw') {
-    // Find which context to parse the content in
-    const rng = editor.selection.getRng();
-    const contextBlock = editor.dom.getParent(rng.commonAncestorContainer, editor.dom.isBlock);
-    const contextArgs = contextBlock ? { context: contextBlock.nodeName.toLowerCase() } : { };
-
-    const node = editor.parser.parse(args.content, { forced_root_block: false, ...contextArgs, ...args });
-    return HtmlSerializer({ validate: false }, editor.schema).serialize(node);
-  } else {
-    return args.content;
-  }
-};
-
-const setContent = (editor: Editor, content: string, args: Partial<SetSelectionContentArgs> = {}): void => {
-  const defaultedArgs = setupArgs(args, content);
-  preProcessSetContent(editor, defaultedArgs).each((updatedArgs) => {
-    // Sanitize the content
-    const cleanedContent = cleanContent(editor, updatedArgs);
-
-    const rng = editor.selection.getRng();
-    rngSetContent(rng, rng.createContextualFragment(cleanedContent), editor.schema);
-    editor.selection.setRng(rng);
-
-    ScrollIntoView.scrollRangeIntoView(editor, rng);
-
-    postProcessSetContent(editor, cleanedContent, updatedArgs);
-  });
-};
-
-export {
-  setContent
-};