@modusoperandi/licit 0.13.1 → 0.13.2

package/src/consolidateListNodes.js

@@ -1,281 +0,0 @@
-// @flow
-
-import isOrderedListNode from './isOrderedListNode';
-import isListNode from './isListNode';
-import { Fragment } from 'prosemirror-model';
-import { Node } from 'prosemirror-model';
-import { Transform } from 'prosemirror-transform';
-
-type JointInfo = {
-  content: Fragment,
-  deleteFrom: number,
-  deleteTo: number,
-  firstListNodePos: number,
-  insertAt: number,
-};
-
-// This function consolidates list nodes among the same "Lists Island".
-//
-// ## Definition of a "Lists Island"
-//   Separate list that are adjacent to each other are grouped as
-//   a "Lists Island".
-//   For example, the following HTML snippets contains two "Lists Island":
-//
-//     <h1>text</h1>
-//     <!-- Lists Island Starts -->
-//     <ul><li>text</li><li>text</li></ul>
-//     <ol><li>text</li><li>text</li></ul>
-//     <!-- Lists Island Ends -->
-//     <p>text</p>
-//     <!-- Lists Island Starts -->
-//     <ul><li>text</li><li>text</li></ul>
-//     <ol><li>text</li><li>text</li></ul>
-//     <!-- Lists Island Ends -->
-//     <p>text</p>
-//
-// List nodes with the same list type and indent level among the same Lists
-// Island will be joined into one list node.
-// Note that this transform may change the current user selection.
-export default function consolidateListNodes(tr: Transform): Transform {
-  if (tr.getMeta('dryrun')) {
-    // This transform is potentially expensive to perform, so skip it if
-    // the transform is performed as "dryrun".
-    return tr;
-  }
-
-  let prevJointInfo;
-
-  // Keep the loop running until there's no more list nodes that can be joined.
-  while (true) {
-    const jointInfo = traverseDocAndFindJointInfo(tr.doc, prevJointInfo);
-    if (jointInfo) {
-      const { deleteFrom, deleteTo, insertAt, content } = jointInfo;
-      tr = tr.delete(deleteFrom, deleteTo);
-      tr = tr.insert(insertAt, content);
-      prevJointInfo = jointInfo;
-    } else {
-      tr = linkOrderedListCounters(tr);
-      break;
-    }
-  }
-  return tr;
-}
-
-/**
- * This ensures that ordered lists with the same indent level among the same
- * Lists Island share the same counter.
- *
- * For example, the following three lists:
- *   --------
- *   1. AAA
- *   2. BBB
- *   --------
- *     a. CCC
- *     d. DDD
- *   --------
- *   1. EEE
- *   2. FFF
- *   --------
- * Will transform into
- *   --------
- *   1. AAA
- *   2. BBB
- *   --------
- *     a. CCC
- *     d. DDD
- *   --------
- *   3. EEE
- *   4. FFF
- *   --------
- * This means that the 1st and the 3rd lists are linked.
- */
-function linkOrderedListCounters(tr: Transform): Transform {
-  const from = 1;
-  const to = tr.doc.nodeSize - 2;
-  if (from >= to) {
-    return tr;
-  }
-
-  const namedLists = new Set();
-
-  let listsBefore = null;
-  tr.doc.nodesBetween(from, to, (node, pos, parentNode) => {
-    let willTraverseNodeChildren = true;
-    if (isListNode(node)) {
-      // List Node can't be nested, no need to traverse its children.
-      willTraverseNodeChildren = false;
-      const indent = node.attrs.indent || 0;
-      const start = node.attrs.start || 1;
-      const { name, following } = node.attrs;
-      if (name) {
-        namedLists.add(name);
-      }
-
-      if (listsBefore) {
-        if (start === 1 && isOrderedListNode(node)) {
-          // Look backward until we could find another ordered list node to
-          // link with.
-          let counterIsLinked;
-          listsBefore.some((list, index) => {
-            if (list.node.type !== node.type && list.indent === indent) {
-              // This encounters different type of list node (e.g a bullet
-              // list node), we need to restart the counter.
-              // ------
-              // 1. AAA
-              // 2. BBB
-              // ------
-              // -. CCC
-              // -. DDD
-              // ------
-              // 1. DDD <- Counter restarts here.
-              // 2. EEE
-              // ------
-              counterIsLinked = false;
-              return true;
-            } else if (list.indent < indent) {
-              // This encounters an ordered list node that has less indent.
-              // we need to restart the counter.
-              // ------
-              // 1. AAA
-              // 2. BBB
-              // ------
-              //   1. DDD <- Counter restarts here.
-              //   2. EEE
-              // ------
-              counterIsLinked = false;
-              return true;
-            } else if (list.indent === indent) {
-              // This encounters an ordered list node that has same indent.
-              // Do not Restart the counter.
-              // ------
-              // 1. AAA
-              // 2. BBB
-              // ------
-              // 3. DDD <- Counter continues here.
-              // 4. EEE
-              // ------
-              counterIsLinked = true;
-              return true;
-            }
-            return false;
-          });
-
-          if (counterIsLinked !== undefined) {
-            tr = setCounterLinked(tr, pos, counterIsLinked);
-          }
-        }
-      } else {
-        // Found the first list among a new Lists Island.
-        // ------
-        // 1. AAA <- Counter restarts here.
-        // 2. BBB
-        listsBefore = [];
-        if (isOrderedListNode(node)) {
-          // The list may follow a previous list that is among another Lists
-          // Island. If so, do not reset the list counter.
-          const counterIsLinked = namedLists.has(following);
-          tr = setCounterLinked(tr, pos, counterIsLinked);
-        }
-      }
-      listsBefore.unshift({ parentNode, indent, node });
-    } else {
-      // Not traversing within any list node. No lists need to be updated.
-      listsBefore = null;
-    }
-    return willTraverseNodeChildren;
-  });
-  return tr;
-}
-
-function setCounterLinked(
-  tr: Transform,
-  pos: number,
-  linked: boolean
-): Transform {
-  const node = tr.doc.nodeAt(pos);
-  const currentValue = node.attrs.counterReset || null;
-  const nextValue = linked ? 'none' : null;
-  if (nextValue !== currentValue) {
-    const nodeAttrs = { ...node.attrs, counterReset: nextValue };
-    tr = tr.setNodeMarkup(pos, node.type, nodeAttrs, node.marks);
-  }
-  return tr;
-}
-
-function traverseDocAndFindJointInfo(
-  doc: Node,
-  prevJointInfo: ?JointInfo
-): ?JointInfo {
-  const minFrom = 1;
-
-  const from = prevJointInfo
-    ? Math.max(minFrom, prevJointInfo.firstListNodePos)
-    : minFrom;
-
-  const to = doc.nodeSize - 2;
-
-  if (to <= from) {
-    return null;
-  }
-
-  let prevNode = null;
-  let jointInfo = null;
-  let firstListNodePos = 0;
-
-  // Perform the breadth-first traversal.
-  doc.nodesBetween(from, to, (node, pos) => {
-    if (jointInfo) {
-      // We've found the list to merge. Stop traversing deeper.
-      return false;
-    } else if (isListNode(node)) {
-      firstListNodePos = firstListNodePos === 0 ? pos : firstListNodePos;
-      jointInfo = resolveJointInfo(node, pos, prevNode, firstListNodePos);
-      prevNode = node;
-      // Stop the traversing recursively inside the this list node because
-      // its content only contains inline nodes.
-      return false;
-    } else {
-      prevNode = node;
-      // This is not a list node, will keep traversing deeper until we've found
-      // a list node or reach the leaf node.
-      return true;
-    }
-  });
-
-  if (jointInfo) {
-    // Reduce the range of the next traversal so it could run faster.
-    jointInfo.firstListNodePos = firstListNodePos;
-  }
-
-  return jointInfo;
-}
-
-// If two siblings nodes that can be joined as single list, returns
-// the information of how to join them.
-function resolveJointInfo(
-  node: Node,
-  pos: number,
-  prevNode: ?Node,
-  firstListNodePos: number
-): ?JointInfo {
-  if (!prevNode || !canJoinListNodes(node, prevNode)) {
-    return null;
-  }
-
-  return {
-    deleteFrom: pos,
-    deleteTo: pos + node.nodeSize,
-    insertAt: pos - 1,
-    content: node.content,
-    firstListNodePos,
-  };
-}
-
-function canJoinListNodes(one: Node, two: Node): boolean {
-  return !!(
-    one.type === two.type &&
-    one.attrs.indent === two.attrs.indent &&
-    isListNode(one) &&
-    isListNode(two)
-  );
-}

package/src/findNodesWithSameMark.js

@@ -1,89 +0,0 @@
-// @flow
-
-import { Mark, MarkType, Node } from 'prosemirror-model';
-
-type Result = {
-  mark: Mark,
-  from: {
-    node: Node,
-    pos: number,
-  },
-  to: {
-    node: Node,
-    pos: number,
-  },
-};
-
-// If nodes within the same range have the same mark, returns
-// the first node.
-export default function findNodesWithSameMark(
-  doc: Node,
-  from: number,
-  to: number,
-  markType: MarkType
-): ?Result {
-  let ii = from;
-  const finder = (mark) => mark.type === markType;
-  let firstMark = null;
-  let fromNode = null;
-  let toNode = null;
-
-  while (ii <= to) {
-    const node = doc.nodeAt(ii);
-    if (!node || !node.marks) {
-      return null;
-    }
-    const mark = node.marks.find(finder);
-    if (!mark) {
-      return null;
-    }
-    if (firstMark && mark !== firstMark) {
-      return null;
-    }
-    fromNode = fromNode || node;
-    firstMark = firstMark || mark;
-    toNode = node;
-    ii++;
-  }
-
-  let fromPos = from;
-  let toPos = to;
-
-  let jj = 0;
-  ii = from - 1;
-  while (ii > jj) {
-    const node = doc.nodeAt(ii);
-    const mark = node && node.marks.find(finder);
-    if (!mark || mark !== firstMark) {
-      break;
-    }
-    fromPos = ii;
-    fromNode = node;
-    ii--;
-  }
-
-  ii = to + 1;
-  jj = doc.nodeSize - 2;
-  while (ii < jj) {
-    const node = doc.nodeAt(ii);
-    const mark = node && node.marks.find(finder);
-    if (!mark || mark !== firstMark) {
-      break;
-    }
-    toPos = ii;
-    toNode = node;
-    ii++;
-  }
-
-  return {
-    mark: firstMark,
-    from: {
-      node: fromNode,
-      pos: fromPos,
-    },
-    to: {
-      node: toNode,
-      pos: toPos,
-    },
-  };
-}

package/src/isBulletListNode.js

@@ -1,9 +0,0 @@
-// @flow
-
-import { Node } from 'prosemirror-model';
-
-import { BULLET_LIST } from './NodeNames';
-
-export default function isBulletListNode(node: Node): boolean {
-  return node.type.name === BULLET_LIST;
-}

package/src/isInsideListItem.js

@@ -1,13 +0,0 @@
-// @flow
-
-import { Node } from 'prosemirror-model';
-
-import { LIST_ITEM } from './NodeNames';
-
-export default function isInsideListItem(doc: Node, pos: number): boolean {
-  if (doc.nodeSize < 2 || pos < 2) {
-    return false;
-  }
-  const prevNode = doc.nodeAt(pos - 1);
-  return prevNode && prevNode.type.name === LIST_ITEM;
-}

package/src/isListNode.js

@@ -1,13 +0,0 @@
-// @flow
-
-import { Node } from 'prosemirror-model';
-
-import isBulletListNode from './isBulletListNode';
-import isOrderedListNode from './isOrderedListNode';
-
-export default function isListNode(node: Node): boolean {
-  if (node instanceof Node) {
-    return isBulletListNode(node) || isOrderedListNode(node);
-  }
-  return false;
-}

package/src/isNodeSelectionForNodeType.js

@@ -1,15 +0,0 @@
-// @flow
-
-import { Selection, NodeSelection } from 'prosemirror-state';
-import { NodeType } from 'prosemirror-model';
-
-// Whether the selection is a node for the node type provided.
-export default function isNodeSelectionForNodeType(
-  selection: Selection,
-  nodeType: NodeType
-): boolean {
-  if (selection instanceof NodeSelection) {
-    return selection.node.type === nodeType;
-  }
-  return false;
-}

package/src/isOrderedListNode.js

@@ -1,9 +0,0 @@
-// @flow
-
-import { Node } from 'prosemirror-model';
-
-import { ORDERED_LIST } from './NodeNames';
-
-export default function isOrderedListNode(node: Node): boolean {
-  return node.type.name === ORDERED_LIST;
-}

package/src/isTextStyleMarkCommandEnabled.js

@@ -1,49 +0,0 @@
-// @flow
-
-import isNodeSelectionForNodeType from './isNodeSelectionForNodeType';
-import { EditorState } from 'prosemirror-state';
-import { MATH } from './NodeNames';
-import { AllSelection, TextSelection } from 'prosemirror-state';
-import { MARK_FONT_SIZE, MARK_TEXT_COLOR } from './MarkNames';
-
-const VALID_MATH_MARK_NAMES = new Set([MARK_FONT_SIZE, MARK_TEXT_COLOR]);
-
-// Whether the command for apply specific text style mark is enabled.
-export default function isTextStyleMarkCommandEnabled(
-  state: EditorState,
-  markName: string
-): boolean {
-  const { selection, schema, tr } = state;
-  const markType = schema.marks[markName];
-  if (!markType) {
-    return false;
-  }
-  const mathNodeType = schema.nodes[MATH];
-  if (
-    mathNodeType &&
-    VALID_MATH_MARK_NAMES.has(markName) &&
-    isNodeSelectionForNodeType(selection, mathNodeType)
-  ) {
-    // A math node is selected.
-    return true;
-  }
-
-  if (
-    !(selection instanceof TextSelection || selection instanceof AllSelection)
-  ) {
-    // Could be a NodeSelection or CellSelection.
-    return false;
-  }
-
-  const { from, to } = state.selection;
-
-  if (to === from + 1) {
-    const node = tr.doc.nodeAt(from);
-    if (node.isAtom && !node.isText && node.isLeaf) {
-      // An atomic node (e.g. Image) is selected.
-      return false;
-    }
-  }
-
-  return true;
-}

package/src/noop.js

@@ -1,5 +0,0 @@
-// @flow
-
-const noop: any = function () {};
-
-export default noop;

package/src/toggleHeading.js

@@ -1,113 +0,0 @@
-// @flow
-
-import { Schema } from 'prosemirror-model';
-import { Transform } from 'prosemirror-transform';
-
-import { BLOCKQUOTE, HEADING, LIST_ITEM, PARAGRAPH } from './NodeNames';
-import compareNumber from './compareNumber';
-import isInsideListItem from './isInsideListItem';
-import isListNode from './isListNode';
-import { clearMarks } from './clearMarks';
-import { unwrapNodesFromList } from './toggleList';
-
-export default function toggleHeading(
-  tr: Transform,
-  schema: Schema,
-  level: number
-): Transform {
-  const { nodes } = schema;
-  const { selection, doc } = tr;
-
-  const blockquote = nodes[BLOCKQUOTE];
-  const heading = nodes[HEADING];
-  const listItem = nodes[LIST_ITEM];
-  const paragraph = nodes[PARAGRAPH];
-
-  if (
-    !selection ||
-    !doc ||
-    !heading ||
-    !paragraph ||
-    !listItem ||
-    !blockquote
-  ) {
-    return tr;
-  }
-
-  const { from, to } = tr.selection;
-  let startWithHeadingBlock = null;
-  const poses = [];
-  doc.nodesBetween(from, to, (node, pos, parentNode) => {
-    const nodeType = node.type;
-    const parentNodeType = parentNode.type;
-
-    if (startWithHeadingBlock === null) {
-      startWithHeadingBlock =
-        nodeType === heading && node.attrs.level === level;
-    }
-
-    if (parentNodeType !== listItem) {
-      poses.push(pos);
-    }
-    return !isListNode(node);
-  });
-  // Update from the bottom to avoid disruptive changes in pos.
-  poses
-    .sort(compareNumber)
-    .reverse()
-    .forEach((pos) => {
-      tr = setHeadingNode(
-        tr,
-        schema,
-        pos,
-        startWithHeadingBlock ? null : level
-      );
-    });
-  return tr;
-}
-
-function setHeadingNode(
-  tr: Transform,
-  schema: Schema,
-  pos: number,
-  level: ?number
-): Transform {
-  const { nodes } = schema;
-  const heading = nodes[HEADING];
-  const paragraph = nodes[PARAGRAPH];
-  const blockquote = nodes[BLOCKQUOTE];
-  if (pos >= tr.doc.content.size) {
-    // Workaround to handle the edge case that pos was shifted caused by `toggleList`.
-    return tr;
-  }
-  const node = tr.doc.nodeAt(pos);
-  if (!node || !heading || !paragraph || !blockquote) {
-    return tr;
-  }
-  const nodeType = node.type;
-  if (isInsideListItem(tr.doc, pos)) {
-    return tr;
-  } else if (isListNode(node)) {
-    // Toggle list
-    if (level !== null) {
-      tr = unwrapNodesFromList(tr, schema, pos, (paragraphNode) => {
-        const { content, marks, attrs } = paragraphNode;
-        const headingAttrs = { ...attrs, level };
-        return heading.create(headingAttrs, content, marks);
-      });
-    }
-  } else if (nodeType === heading) {
-    // Toggle heading
-    if (level === null) {
-      tr = tr.setNodeMarkup(pos, paragraph, node.attrs, node.marks);
-    } else {
-      tr = tr.setNodeMarkup(pos, heading, { ...node.attrs, level }, node.marks);
-    }
-  } else if ((level && nodeType === paragraph) || nodeType === blockquote) {
-    // [FS] IRAD-948 2020-05-22
-    // Clear Header formatting
-    tr = clearMarks(tr, schema);
-    tr = tr.setNodeMarkup(pos, heading, { ...node.attrs, level }, node.marks);
-  }
-  return tr;
-}