@modusoperandi/licit 0.1.10 → 0.13.3

package/src/toggleList.js

@@ -1,450 +0,0 @@
-// @flow
-
-import consolidateListNodes from './consolidateListNodes';
-import compareNumber from './compareNumber';
-import nullthrows from 'nullthrows';
-import { Fragment, Node, NodeType, Schema } from 'prosemirror-model';
-import { TextSelection } from 'prosemirror-state';
-import { Transform } from 'prosemirror-transform';
-import { findParentNodeOfType } from 'prosemirror-utils';
-
-import { HEADING, LIST_ITEM, PARAGRAPH } from './NodeNames';
-import isListNode from './isListNode';
-import transformAndPreserveTextSelection from './transformAndPreserveTextSelection';
-
-import type { SelectionMemo } from './transformAndPreserveTextSelection';
-
-export default function toggleList(
-  tr: Transform,
-  schema: Schema,
-  listNodeType: NodeType,
-  listStyleType: string
-): Transform {
-  const { selection, doc } = tr;
-  if (!selection || !doc) {
-    return tr;
-  }
-
-  // [FS][04-AUG-2020][IRAD-955]
-  // Fix Unable to apply list using Ctrl+A selection
-  let { from } = selection;
-  let { to } = selection;
-  let newselection = selection;
-
-  if (0 === from && 0 != to) {
-    // In here when Ctrl+A is pressed.
-    let startPos = -1;
-    let endPos = -1;
-
-    tr.doc.descendants((node, pos) => {
-      if (-1 === startPos) {
-        startPos = pos;
-      } else {
-        endPos = pos + 1;
-      }
-    });
-
-    // validate endPos. Both start & end pos can't be -ve.
-    endPos = -1 == endPos ? to : endPos;
-
-    // Actual starting position similar when manually selecting
-    startPos = 0 < to - endPos ? to - endPos : 0;
-
-    from = startPos;
-    to = 0 < endPos ? endPos : 0;
-
-    newselection = TextSelection.create(doc, from, to);
-    tr = tr.setSelection(newselection);
-  }
-
-  const fromSelection = TextSelection.create(doc, from, from);
-  const paragraph = schema.nodes[PARAGRAPH];
-  const heading = schema.nodes[HEADING];
-  const result = findParentNodeOfType(listNodeType)(fromSelection);
-  const p = findParentNodeOfType(paragraph)(fromSelection);
-  const h = findParentNodeOfType(heading)(fromSelection);
-
-  if (result) {
-    tr = unwrapNodesFromList(tr, schema, result.pos);
-  } else if (paragraph && p) {
-    tr = wrapNodesWithList(
-      tr,
-      schema,
-      listNodeType,
-      listStyleType,
-      newselection
-    );
-  } else if (heading && h) {
-    tr = wrapNodesWithList(
-      tr,
-      schema,
-      listNodeType,
-      listStyleType,
-      newselection
-    );
-  }
-  return tr;
-}
-
-export function unwrapNodesFromList(
-  tr: Transform,
-  schema: Schema,
-  listNodePos: number,
-  unwrapParagraphNode?: ?(Node) => Node
-): Transform {
-  return transformAndPreserveTextSelection(tr, schema, (memo) => {
-    return consolidateListNodes(
-      unwrapNodesFromListInternal(memo, listNodePos, unwrapParagraphNode)
-    );
-  });
-}
-
-function wrapNodesWithList(
-  tr: Transform,
-  schema: Schema,
-  listNodeType: NodeType,
-  listStyleType: string,
-  newselection = null
-): Transform {
-  return transformAndPreserveTextSelection(tr, schema, (memo) => {
-    // [FS][04-AUG-2020][IRAD-955]
-    // Fix Unable to apply list using Ctrl+A selection
-    return consolidateListNodes(
-      wrapNodesWithListInternal(memo, listNodeType, listStyleType, newselection)
-    );
-  });
-}
-
-function wrapNodesWithListInternal(
-  memo: SelectionMemo,
-  listNodeType: NodeType,
-  listStyleType: string,
-  newselection = null
-): Transform {
-  const { schema } = memo;
-  let { tr } = memo;
-  const { doc, selection } = tr;
-  let { from, to } = selection;
-  if (!tr || !selection) {
-    return tr;
-  }
-  if (newselection) {
-    from = newselection.from;
-    to = newselection.to;
-  }
-
-  const paragraph = schema.nodes[PARAGRAPH];
-  const heading = schema.nodes[HEADING];
-
-  let items = null;
-  let lists = [];
-  doc.nodesBetween(from, to, (node, pos) => {
-    const nodeType = node.type;
-    const nodeName = nodeType.name;
-    if (isListNode(node)) {
-      if (node.type !== listNodeType) {
-        const listNodeAttrs = {
-          ...node.attrs,
-          listNodeType: null,
-        };
-        tr = tr.setNodeMarkup(pos, listNodeType, listNodeAttrs, node.marks);
-      }
-      items && lists.push(items);
-      items = null;
-      return false;
-    }
-
-    if (/table/.test(nodeName)) {
-      items && lists.push(items);
-      items = null;
-      return true;
-    }
-
-    if (nodeType === heading || nodeType === paragraph) {
-      items = items || [];
-      items.push({ node, pos });
-    } else {
-      items && items.length && lists.push(items);
-      items = null;
-    }
-    return true;
-  });
-  items && items.length && lists.push(items);
-
-  lists = lists.filter((items) => items.length > 0);
-  if (!lists.length) {
-    return tr;
-  }
-
-  lists.sort((a, b) => {
-    const pa = nullthrows(a[0]).pos;
-    const pb = nullthrows(b[0]).pos;
-    return pa >= pb ? 1 : -1;
-  });
-
-  lists.reverse();
-
-  lists.forEach((items) => {
-    tr = wrapItemsWithListInternal(
-      tr,
-      schema,
-      listNodeType,
-      items,
-      listStyleType
-    );
-  });
-
-  return tr;
-}
-
-function wrapItemsWithListInternal(
-  tr: Transform,
-  schema: Schema,
-  listNodeType: NodeType,
-  items: Array<{ node: Node, pos: number }>,
-  listStyleType: string
-): Transform {
-  const initialTr = tr;
-  const paragraph = schema.nodes[PARAGRAPH];
-  const listItem = schema.nodes[LIST_ITEM];
-
-  if (!paragraph || !listItem) {
-    return tr;
-  }
-
-  const paragraphNodes = [];
-  items.forEach((item) => {
-    const { node, pos } = item;
-    // Temporarily annotate each node with an unique ID.
-    const uniqueID = {};
-    const nodeAttrs = { ...node.attrs, id: uniqueID };
-    // Replace the original node with the node annotated by the uniqueID.
-    tr = tr.setNodeMarkup(pos, paragraph, nodeAttrs, node.marks);
-    paragraphNodes.push(tr.doc.nodeAt(pos));
-  });
-
-  const firstNode = paragraphNodes[0];
-  const lastNode = paragraphNodes[paragraphNodes.length - 1];
-  if (!firstNode || !lastNode) {
-    return initialTr;
-  }
-
-  const firstNodeID = firstNode.attrs.id;
-  const lastNodeID = lastNode.attrs.id;
-  if (!firstNodeID || !lastNodeID) {
-    return initialTr;
-  }
-
-  let fromPos = null;
-  let toPos = null;
-  tr.doc.descendants((node, pos) => {
-    const nodeID = node.attrs.id;
-    if (nodeID === firstNodeID) {
-      fromPos = pos;
-    }
-    if (nodeID === lastNodeID) {
-      toPos = pos + node.nodeSize;
-    }
-    return fromPos === null || toPos === null;
-  });
-
-  if (fromPos === null || toPos === null) {
-    return initialTr;
-  }
-
-  const listItemNodes = [];
-  items.forEach((item) => {
-    const { node } = item;
-    // Restore the annotated nodes with the copy of the original ones.
-    const paragraphNode = paragraph.create(
-      node.attrs,
-      node.content,
-      node.marks
-    );
-    const listItemNode = listItem.create(
-      node.attrs,
-      Fragment.from(paragraphNode)
-    );
-    listItemNodes.push(listItemNode);
-  });
-
-  const listNodeAttrs = { indent: 0, start: 1, type: listStyleType };
-
-  const $fromPos = tr.doc.resolve(fromPos);
-  const $toPos = tr.doc.resolve(toPos);
-
-  const hasSameListNodeBefore =
-    $fromPos.nodeBefore &&
-    $fromPos.nodeBefore.type === listNodeType &&
-    $fromPos.nodeBefore.attrs.indent === 0;
-
-  const hasSameListNodeAfter =
-    $toPos.nodeAfter &&
-    $toPos.nodeAfter.type === listNodeType &&
-    $toPos.nodeAfter.attrs.indent === 0;
-
-  if (hasSameListNodeBefore) {
-    tr = tr.delete(fromPos, toPos);
-    tr = tr.insert(fromPos - 1, Fragment.from(listItemNodes));
-    if (hasSameListNodeAfter) {
-      tr = tr.delete(toPos + 1, toPos + 3);
-    }
-  } else if (hasSameListNodeAfter) {
-    tr = tr.delete(fromPos, toPos);
-    tr = tr.insert(fromPos + 1, Fragment.from(listItemNodes));
-  } else {
-    const listNode = listNodeType.create(
-      listNodeAttrs,
-      Fragment.from(listItemNodes)
-    );
-    tr = tr.delete(fromPos, toPos);
-    tr = tr.insert(fromPos, Fragment.from(listNode));
-  }
-
-  return tr;
-}
-
-// [FS] IRAD-966 2020-05-20
-// Fix: Toggling issue for Multi-level list.
-
-function unwrapNodesFromSelection(
-  tr: Transform,
-  listNodePos: number,
-  nodes: Node,
-  unwrapParagraphNode?: Node,
-  from: number,
-  to: number
-): Transform {
-  const contentBlocksBefore = [];
-  const contentBlocksSelected = [];
-  const contentBlocksAfter = [];
-  const paragraph = nodes[PARAGRAPH];
-  const listItem = nodes[LIST_ITEM];
-  const listNode = tr.doc.nodeAt(listNodePos);
-
-  tr.doc.nodesBetween(
-    listNodePos,
-    listNodePos + listNode.nodeSize,
-    (node, pos, parentNode, index) => {
-      if (node.type !== paragraph) {
-        return true;
-      }
-      const block = {
-        node,
-        pos,
-        parentNode,
-        index,
-      };
-
-      if (pos + node.nodeSize <= from) {
-        contentBlocksBefore.push(block);
-      } else if (pos > to) {
-        contentBlocksAfter.push(block);
-      } else {
-        contentBlocksSelected.push(block);
-      }
-      return false;
-    }
-  );
-
-  if (!contentBlocksSelected.length) {
-    return tr;
-  }
-
-  tr = tr.delete(listNodePos, listNodePos + listNode.nodeSize);
-
-  const listNodeType = listNode.type;
-  const attrs = { indent: listNode.attrs.indent, start: 1 };
-
-  if (contentBlocksAfter.length) {
-    const nodes = contentBlocksAfter.map((block) => {
-      return listItem.create({}, Fragment.from(block.node));
-    });
-    const frag = Fragment.from(
-      listNodeType.create(attrs, Fragment.from(nodes))
-    );
-    tr = tr.insert(listNodePos, frag);
-  }
-
-  if (contentBlocksSelected.length) {
-    const nodes = contentBlocksSelected.map((block) => {
-      if (unwrapParagraphNode) {
-        return unwrapParagraphNode(block.node);
-      } else {
-        return block.node;
-      }
-    });
-    const frag = Fragment.from(nodes);
-    tr = tr.insert(listNodePos, frag);
-  }
-
-  if (contentBlocksBefore.length) {
-    const nodes = contentBlocksBefore.map((block) => {
-      return listItem.create({}, Fragment.from(block.node));
-    });
-    const frag = Fragment.from(
-      listNodeType.create(attrs, Fragment.from(nodes))
-    );
-    tr = tr.insert(listNodePos, frag);
-  }
-
-  return tr;
-}
-
-function unwrapNodesFromListInternal(
-  memo: SelectionMemo,
-  listNodePos: number,
-  unwrapParagraphNode?: ?(Node) => Node
-): Transform {
-  const { schema } = memo;
-  let { tr } = memo;
-
-  if (!tr.doc || !tr.selection) {
-    return tr;
-  }
-
-  const { nodes } = schema;
-  const paragraph = nodes[PARAGRAPH];
-  const listItem = nodes[LIST_ITEM];
-
-  if (!listItem || !paragraph) {
-    return tr;
-  }
-
-  const listNode = tr.doc.nodeAt(listNodePos);
-  if (!isListNode(listNode)) {
-    return tr;
-  }
-
-  const initialSelection = tr.selection;
-  const { from, to } = initialSelection;
-
-  const listNodePoses = [];
-
-  // keep all list type nodes starting position
-  tr.doc.nodesBetween(from, to, (node, pos) => {
-    if (isListNode(node)) {
-      listNodePoses.push(pos);
-    }
-  });
-
-  if (from === to && from < 1) {
-    return tr;
-  }
-  // Unwraps all selected list
-  listNodePoses
-    .sort(compareNumber)
-    .reverse()
-    .forEach((pos) => {
-      tr = unwrapNodesFromSelection(
-        tr,
-        pos,
-        nodes,
-        unwrapParagraphNode,
-        from,
-        to
-      );
-    });
-
-  return tr;
-}

package/src/transformAndPreserveTextSelection.js

@@ -1,151 +0,0 @@
-import { Fragment, Schema } from 'prosemirror-model';
-import { TextSelection } from 'prosemirror-state';
-import { Transform } from 'prosemirror-transform';
-
-import { MARK_TEXT_SELECTION } from './MarkNames';
-import { PARAGRAPH, TEXT } from './NodeNames';
-import applyMark from './applyMark';
-import uuid from './ui/uuid';
-
-export type SelectionMemo = {
-  schema: Schema,
-  tr: Transform,
-};
-
-// Text used to create temporary selection.
-// This assumes that no user could enter such string manually.
-const PLACEHOLDER_TEXT = `[\u200b\u2800PLACEHOLDER_TEXT_${uuid()}\u2800\u200b]`;
-
-// Perform the transform without losing the perceived text selection.
-// The way it works is that this will annotate teh current selection with
-// temporary marks and restores the selection with those marks after performing
-// the transform.
-export default function transformAndPreserveTextSelection(
-  tr: Transform,
-  schema: Schema,
-  fn: (memo: SelectionMemo) => Transform
-): Transform {
-  if (tr.getMeta('dryrun')) {
-    // There's no need to preserve the selection in dryrun mode.
-    return fn({ tr, schema });
-  }
-
-  const { selection, doc } = tr;
-  const markType = schema.marks[MARK_TEXT_SELECTION];
-  if (!markType || !selection || !doc) {
-    return tr;
-  }
-
-  if (!(selection instanceof TextSelection)) {
-    return tr;
-  }
-
-  const { from, to } = selection;
-
-  // Mark current selection so that we could resume the selection later
-  // after changing the whole list.
-  let fromOffset = 0;
-  let toOffset = 0;
-  let placeholderTextNode;
-
-  if (from === to) {
-    if (from === 0) {
-      return tr;
-    }
-    // Selection is collapsed, create a temporary selection that the marks can
-    // be applied to.
-    const currentNode = tr.doc.nodeAt(from);
-    const prevNode = tr.doc.nodeAt(from - 1);
-    const nextNode = tr.doc.nodeAt(from + 1);
-
-    if (
-      !currentNode &&
-      prevNode &&
-      prevNode.type.name === PARAGRAPH &&
-      !prevNode.firstChild
-    ) {
-      // The selection is at a paragraph node which has no content.
-      // Create a temporary text and move selection into that text.
-      placeholderTextNode = schema.text(PLACEHOLDER_TEXT);
-      tr = tr.insert(from, Fragment.from(placeholderTextNode));
-      toOffset = 1;
-    } else if (!currentNode && prevNode && prevNode.type.name === TEXT) {
-      // The selection is at the end of the text node. Select the last
-      // character instead.
-      fromOffset = -1;
-    } else if (prevNode && currentNode && currentNode.type === prevNode.type) {
-      // Ensure that the mark is applied to the same type of node.
-      fromOffset = -1;
-    } else if (nextNode && currentNode && currentNode.type === nextNode.type) {
-      toOffset = 1;
-    } else if (nextNode) {
-      // Could not find the same type of node, assume the next node is safe to use.
-      toOffset = 1;
-    } else if (prevNode) {
-      // Could not find the same type of node, assume the next node is safe to use.
-      fromOffset = -1;
-    } else {
-      // Selection can't be safely preserved.
-      return tr;
-    }
-    tr = tr.setSelection(
-      // [FS] IRAD-1005 2020-07-29
-      // Upgrade outdated packages.
-      // reset selection using the latest doc.
-      // This fixes IRAD-1023
-      TextSelection.create(tr.doc, from + fromOffset, to + toOffset)
-    );
-  }
-
-  // This is an unique ID (by reference).
-  const id = {};
-  const findMark = (mark) => mark.attrs.id === id;
-
-  const findMarkRange = () => {
-    let markFrom = 0;
-    let markTo = 0;
-    tr.doc.descendants((node, pos) => {
-      if (node.marks && node.marks.find(findMark)) {
-        markFrom = markFrom === 0 ? pos : markFrom;
-        markTo = pos + node.nodeSize;
-      }
-      return true;
-    });
-    return {
-      from: markFrom,
-      to: markTo,
-    };
-  };
-
-  // TODO: This has side-effect. It will cause `tr.docChanged` to be `true`.
-  // No matter whether `fn({tr, schema})` did change the doc or not.
-  tr = applyMark(tr, schema, markType, { id });
-  tr = fn({ tr, schema });
-
-  const markRange = findMarkRange();
-  const selectionRange = {
-    from: Math.max(0, markRange.from - fromOffset),
-    to: Math.max(0, markRange.to - toOffset),
-  };
-
-  selectionRange.to = Math.max(0, selectionRange.from, selectionRange.to);
-
-  tr = tr.removeMark(markRange.from, markRange.to, markType);
-
-  if (placeholderTextNode) {
-    tr.doc.descendants((node, pos) => {
-      if (node.type.name === TEXT && node.text === PLACEHOLDER_TEXT) {
-        tr = tr.delete(pos, pos + PLACEHOLDER_TEXT.length);
-        placeholderTextNode = null;
-        return false;
-      }
-      return true;
-    });
-  }
-
-  tr = tr.setSelection(
-    TextSelection.create(tr.doc, selectionRange.from, selectionRange.to)
-  );
-
-  return tr;
-}

package/src/ui/ColorEditor.js

@@ -1,101 +0,0 @@
-// @flow
-
-import Color from 'color';
-import * as React from 'react';
-
-import CustomButton from './CustomButton';
-import clamp from './clamp';
-
-import './czi-color-editor.css';
-
-function generateGreyColors(count: number): Array<Color> {
-  let cc = 255;
-  const interval = cc / count;
-  const colors = [];
-  while (cc > 0) {
-    const color = Color({ r: cc, g: cc, b: cc });
-    cc -= interval;
-    cc = Math.floor(cc);
-    colors.unshift(color);
-  }
-  return colors;
-}
-
-function generateRainbowColors(
-  count: number,
-  saturation: number,
-  lightness: number
-): Array<Color> {
-  const colors = [];
-  const interval = 360 / count;
-  const ss = clamp(0, saturation, 100);
-  const ll = clamp(0, lightness, 100);
-  let hue = 0;
-  while (hue < 360) {
-    const hsl = `hsl(${hue},${ss}%,${ll}%)`;
-    const color = Color(hsl);
-    colors.unshift(color);
-    hue += interval;
-  }
-  return colors;
-}
-
-class ColorEditor extends React.PureComponent<any, any> {
-  props: {
-    close: (?string) => void,
-    hex?: ?string,
-  };
-
-  render(): React.Element<any> {
-    const renderColor = this._renderColor;
-    const selectedColor = this.props.hex;
-    return (
-      <div className="czi-color-editor">
-        <div className="czi-color-editor-section">
-          <CustomButton
-            active={!selectedColor}
-            className="czi-color-editor-color-transparent"
-            label="Transparent"
-            onClick={this._onSelectColor}
-            value="rgba(0,0,0,0)"
-          />
-        </div>
-        <div className="czi-color-editor-section">
-          {generateGreyColors(10).map(renderColor)}
-        </div>
-        <div className="czi-color-editor-section">
-          {generateRainbowColors(10, 90, 50).map(renderColor)}
-        </div>
-        <div className="czi-color-editor-section">
-          {generateRainbowColors(30, 70, 70).map(renderColor)}
-        </div>
-        <div className="czi-color-editor-section">
-          {generateRainbowColors(30, 90, 30).map(renderColor)}
-        </div>
-      </div>
-    );
-  }
-
-  _renderColor = (color: Color, index: number): React.Element<any> => {
-    const selectedColor = this.props.hex;
-    const hex = color.hex().toLowerCase();
-    const style = { backgroundColor: hex };
-    const active = selectedColor && selectedColor.toLowerCase() === hex;
-    return (
-      <CustomButton
-        active={active}
-        className="czi-color-editor-cell"
-        key={`${hex}-${index}`}
-        label=""
-        onClick={this._onSelectColor}
-        style={style}
-        value={hex}
-      />
-    );
-  };
-
-  _onSelectColor = (hex: string): void => {
-    this.props.close(hex);
-  };
-}
-export default ColorEditor;