TypeScript sugar.Compare类代码示例

const outdentDlItem = (editor: Editor, item: Element): void => {
  if (Compare.is(item, 'DD')) {
    Replication.mutate(item, 'DT');
  } else if (Compare.is(item, 'DT')) {
    Traverse.parent(item).each((dl) => SplitList.splitList(editor, dl.dom(), item.dom()));
  }
};

 Focus.active().each(function (active) {
   // INVESTIGATE: This predicate may not be required. The purpose of it is to ensure
   // that the content window's frame element is not unnecessarily blurred before giving
   // it focus.
   if (! Compare.eq(active, frame)) {
     Focus.blur(active);
   }
 });

const getInsertionPoint = function (fromBlock, toBlock) {
  if (Compare.contains(toBlock, fromBlock)) {
    return Traverse.parent(fromBlock).bind(function (parent) {
      return Compare.eq(parent, toBlock) ? Option.some(fromBlock) : findParentInsertPoint(toBlock, fromBlock);
    });
  } else {
    return Option.none();
  }
};

const parentsUntil = (start: Element, root: Element, predicate: (elm: Element) => boolean): Element[] => {
  if (Compare.contains(root, start)) {
    return dropLast(Traverse.parents(start, function (elm) {
      return predicate(elm) || Compare.eq(elm, root);
    }));
  } else {
    return [];
  }
};

 return getCollapsedNode(rng).bind(function (node) {
   if (ElementType.isTableSection(node)) {
     return Option.some(node);
   } else if (Compare.contains(root, node) === false) {
     return Option.some(root);
   } else {
     return Option.none();
   }
 });

const parentsUntil = function (startNode, rootElm, predicate) {
  if (Compare.contains(rootElm, startNode)) {
    return dropLast(Traverse.parents(startNode, function (elm) {
      return predicate(elm) || Compare.eq(elm, rootElm);
    }));
  } else {
    return [];
  }
};

 SelectorFind.closest(se.event().target(), '.' + MenuButtonClasses.Button).each((hoveredButton) => {
   if (! Compare.eq(activeButton, hoveredButton)) {
     // Now, find the components, and expand the hovered one, and close the active one
     comp.getSystem().getByDom(activeButton).each((activeComp) => {
       comp.getSystem().getByDom(hoveredButton).each((hoveredComp) => {
         Dropdown.expand(hoveredComp);
         Dropdown.close(activeComp);
         Focusing.focus(hoveredComp);
       });
     });
   }
 });

  ], function (block1, block2) {
    if (Compare.eq(block1, block2) === false) {
      rng.deleteContents();

      MergeBlocks.mergeBlocks(rootNode, true, block1, block2).each(function (pos) {
        selection.setRng(pos.toRange());
      });

      return true;
    } else {
      return false;
    }
  }).getOr(false);

const findElementPos = function (table, element) {
  const rows = table.rows();
  for (let y = 0; y < rows.length; y++) {
    const cells = rows[y].cells();
    for (let x = 0; x < cells.length; x++) {
      if (Compare.eq(cells[x], element)) {
        return Option.some(cellPosition(x, y));
      }
    }
  }

  return Option.none();
};

const mergeLiElements = function (dom, fromElm, toElm) {
  let node, listNode;
  const ul = fromElm.parentNode;

  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);
    }
  }

  node = toElm.lastChild;
  if (node && NodeType.isBr(node) && fromElm.hasChildNodes()) {
    dom.remove(node);
  }

  if (NodeType.isEmpty(dom, toElm, true)) {
    dom.$(toElm).empty();
  }

  moveChildren(dom, fromElm, toElm);

  if (listNode) {
    toElm.appendChild(listNode);
  }

  const contains = Compare.contains(Element.fromDom(toElm), Element.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);
    }
  });
};