TypeScript Remove.remove方法代码示例

const removeEmpty = (text: Element): Option<Element> => {
  if (text.dom().length === 0) {
    Remove.remove(text);
    return Option.none();
  }
  return Option.some(text);
};

const replaceWithCaretFormat = function (targetNode, formatNodes) {
  const caretContainer = createCaretContainer(false);
  const innerMost = insertFormatNodesIntoCaretContainer(formatNodes, caretContainer.dom());
  Insert.before(Element.fromDom(targetNode), caretContainer);
  Remove.remove(Element.fromDom(targetNode));

  return CaretPosition(innerMost, 0);
};

 table.filter(Fun.not(isRoot)).each(function (table) {
   const cursor = Element.fromText('');
   Insert.after(table, cursor);
   Remove.remove(table);
   const rng = editor.dom.createRng();
   rng.setStart(cursor.dom(), 0);
   rng.setEnd(cursor.dom(), 0);
   editor.selection.setRng(rng);
 });

 Arr.each(entrySets, (entrySet) => {
   indentSelectedEntries(entrySet.entries, indentation);
   const composedLists = composeEntries(editor, entrySet.entries);
   Arr.each(composedLists, (composedList) => {
     fireListEvent(editor, indentation === Indentation.Indent ? ListAction.IndentList : ListAction.OutdentList, composedList.dom());
   });
   InsertAll.before(entrySet.sourceList, composedLists);
   Remove.remove(entrySet.sourceList);
 });

  return Options.liftN([Traverse.prevSibling(elm), Traverse.nextSibling(elm), afterDeletePosOpt], function (prev, next, afterDeletePos) {
    let offset;
    const prevNode = prev.dom();
    const nextNode = next.dom();

    if (NodeType.isText(prevNode) && NodeType.isText(nextNode)) {
      offset = prevNode.data.length;
      prevNode.appendData(nextNode.data);
      Remove.remove(next);
      Remove.remove(elm);
      if (afterDeletePos.container() === nextNode) {
        return new CaretPosition(prevNode, offset);
      } else {
        return afterDeletePos;
      }
    } else {
      Remove.remove(elm);
      return afterDeletePos;
    }
  }).orThunk(function () {

const mergeTextNodes = (prevNode: Text, nextNode: Text, normalizeWhitespace?: boolean): Text => {
  const whitespaceOffset = Strings.rTrim(prevNode.data).length;
  // Merge the elements
  prevNode.appendData(nextNode.data);
  Remove.remove(Element.fromDom(nextNode));

  // Normalize the whitespace around the merged elements, to ensure it doesn't get lost
  if (normalizeWhitespace) {
    normalizeWhitespaceAfter(prevNode, whitespaceOffset);
  }

  return prevNode;
};

const input = function (parent, operation) {
  // to capture focus allowing the keyboard to remain open with no 'real' selection
  const input = Element.fromTag('input');
  Css.setAll(input, {
    opacity: '0',
    position: 'absolute',
    top: '-1000px',
    left: '-1000px'
  });
  Insert.append(parent, input);

  Focus.focus(input);
  operation(input);
  Remove.remove(input);
};

const sidelongBlockMerge = (rootNode: Element, fromBlock: Element, toBlock: Element): Option<CaretPosition> => {
  if (Empty.isEmpty(toBlock)) {
    Remove.remove(toBlock);
    if (Empty.isEmpty(fromBlock)) {
      PaddingBr.fillWithPaddingBr(fromBlock);
    }
    return CaretFinder.firstPositionIn(fromBlock.dom());
  }

  const position = CaretFinder.lastPositionIn(toBlock.dom());
  Arr.each(extractChildren(fromBlock), (child) => {
    Insert.append(toBlock, child);
  });
  removeEmptyRoot(rootNode, fromBlock);
  return position;
};

        tableOpt.filter(Fun.not(isRoot)).each((table) => {
          const cursor = Element.fromText('');
          Insert.after(table, cursor);
          Remove.remove(table);

          if (editor.dom.isEmpty(editor.getBody())) {
            editor.setContent('');
            editor.selection.setCursorLocation();
          } else {
            const rng = editor.dom.createRng();
            rng.setStart(cursor.dom(), 0);
            rng.setEnd(cursor.dom(), 0);
            editor.selection.setRng(rng);
            editor.nodeChanged();
          }
        });

const mergeBlockInto = function (rootNode, fromBlock, toBlock) {
  if (Empty.isEmpty(toBlock)) {
    Remove.remove(toBlock);

    if (Empty.isEmpty(fromBlock)) {
      PaddingBr.fillWithPaddingBr(fromBlock);
    }

    return CaretFinder.firstPositionIn(fromBlock.dom());
  } else {
    trimBr(true, fromBlock);
    trimBr(false, toBlock);

    const children = extractChildren(fromBlock);

    return getInsertionPoint(fromBlock, toBlock).fold(
      function () {
        removeEmptyRoot(rootNode, fromBlock);

        const position = CaretFinder.lastPositionIn(toBlock.dom());

        Arr.each(children, function (node) {
          Insert.append(toBlock, node);
        });

        return position;
      },
      function (target) {
        const position = CaretFinder.prevPosition(toBlock.dom(), CaretPosition.before(target.dom()));

        Arr.each(children, function (node) {
          Insert.before(target, node);
        });

        removeEmptyRoot(rootNode, fromBlock);

        return position;
      }
    );
  }
};