@modusoperandi/licit 0.1.9 → 0.13.2

package/node_modules/prosemirror-utils/dist/selection.js

@@ -0,0 +1,168 @@
+import { Selection } from 'prosemirror-state';
+import { equalNodeType, isNodeSelection } from './helpers';
+
+// :: (predicate: (node: ProseMirrorNode) → boolean) → (selection: Selection) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}
+// Iterates over parent nodes, returning the closest node and its start position `predicate` returns truthy for. `start` points to the start position of the node, `pos` points directly before the node.
+//
+// ```javascript
+// const predicate = node => node.type === schema.nodes.blockquote;
+// const parent = findParentNode(predicate)(selection);
+// ```
+export const findParentNode = predicate => ({ $from }) =>
+  findParentNodeClosestToPos($from, predicate);
+
+// :: ($pos: ResolvedPos, predicate: (node: ProseMirrorNode) → boolean) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}
+// Iterates over parent nodes starting from the given `$pos`, returning the closest node and its start position `predicate` returns truthy for. `start` points to the start position of the node, `pos` points directly before the node.
+//
+// ```javascript
+// const predicate = node => node.type === schema.nodes.blockquote;
+// const parent = findParentNodeClosestToPos(state.doc.resolve(5), predicate);
+// ```
+export const findParentNodeClosestToPos = ($pos, predicate) => {
+  for (let i = $pos.depth; i > 0; i--) {
+    const node = $pos.node(i);
+    if (predicate(node)) {
+      return {
+        pos: i > 0 ? $pos.before(i) : 0,
+        start: $pos.start(i),
+        depth: i,
+        node
+      };
+    }
+  }
+};
+
+// :: (predicate: (node: ProseMirrorNode) → boolean, domAtPos: (pos: number) → {node: dom.Node, offset: number}) → (selection: Selection) → ?dom.Node
+// Iterates over parent nodes, returning DOM reference of the closest node `predicate` returns truthy for.
+//
+// ```javascript
+// const domAtPos = view.domAtPos.bind(view);
+// const predicate = node => node.type === schema.nodes.table;
+// const parent = findParentDomRef(predicate, domAtPos)(selection); // <table>
+// ```
+export const findParentDomRef = (predicate, domAtPos) => selection => {
+  const parent = findParentNode(predicate)(selection);
+  if (parent) {
+    return findDomRefAtPos(parent.pos, domAtPos);
+  }
+};
+
+// :: (predicate: (node: ProseMirrorNode) → boolean) → (selection: Selection) → boolean
+// Checks if there's a parent node `predicate` returns truthy for.
+//
+// ```javascript
+// if (hasParentNode(node => node.type === schema.nodes.table)(selection)) {
+//   // ....
+// }
+// ```
+export const hasParentNode = predicate => selection => {
+  return !!findParentNode(predicate)(selection);
+};
+
+// :: (nodeType: union<NodeType, [NodeType]>) → (selection: Selection) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}
+// Iterates over parent nodes, returning closest node of a given `nodeType`. `start` points to the start position of the node, `pos` points directly before the node.
+//
+// ```javascript
+// const parent = findParentNodeOfType(schema.nodes.paragraph)(selection);
+// ```
+export const findParentNodeOfType = nodeType => selection => {
+  return findParentNode(node => equalNodeType(nodeType, node))(selection);
+};
+
+// :: ($pos: ResolvedPos, nodeType: union<NodeType, [NodeType]>) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}
+// Iterates over parent nodes starting from the given `$pos`, returning closest node of a given `nodeType`. `start` points to the start position of the node, `pos` points directly before the node.
+//
+// ```javascript
+// const parent = findParentNodeOfTypeClosestToPos(state.doc.resolve(10), schema.nodes.paragraph);
+// ```
+export const findParentNodeOfTypeClosestToPos = ($pos, nodeType) => {
+  return findParentNodeClosestToPos($pos, node =>
+    equalNodeType(nodeType, node)
+  );
+};
+
+// :: (nodeType: union<NodeType, [NodeType]>) → (selection: Selection) → boolean
+// Checks if there's a parent node of a given `nodeType`.
+//
+// ```javascript
+// if (hasParentNodeOfType(schema.nodes.table)(selection)) {
+//   // ....
+// }
+// ```
+export const hasParentNodeOfType = nodeType => selection => {
+  return hasParentNode(node => equalNodeType(nodeType, node))(selection);
+};
+
+// :: (nodeType: union<NodeType, [NodeType]>, domAtPos: (pos: number) → {node: dom.Node, offset: number}) → (selection: Selection) → ?dom.Node
+// Iterates over parent nodes, returning DOM reference of the closest node of a given `nodeType`.
+//
+// ```javascript
+// const domAtPos = view.domAtPos.bind(view);
+// const parent = findParentDomRefOfType(schema.nodes.codeBlock, domAtPos)(selection); // <pre>
+// ```
+export const findParentDomRefOfType = (nodeType, domAtPos) => selection => {
+  return findParentDomRef(node => equalNodeType(nodeType, node), domAtPos)(
+    selection
+  );
+};
+
+// :: (nodeType: union<NodeType, [NodeType]>) → (selection: Selection) → ?{pos: number, start: number, depth: number, node: ProseMirrorNode}
+// Returns a node of a given `nodeType` if it is selected. `start` points to the start position of the node, `pos` points directly before the node.
+//
+// ```javascript
+// const { extension, inlineExtension, bodiedExtension } = schema.nodes;
+// const selectedNode = findSelectedNodeOfType([
+//   extension,
+//   inlineExtension,
+//   bodiedExtension,
+// ])(selection);
+// ```
+export const findSelectedNodeOfType = nodeType => selection => {
+  if (isNodeSelection(selection)) {
+    const { node, $from } = selection;
+    if (equalNodeType(nodeType, node)) {
+      return { node, pos: $from.pos, depth: $from.depth };
+    }
+  }
+};
+
+// :: (selection: Selection) → ?number
+// Returns position of the previous node.
+//
+// ```javascript
+// const pos = findPositionOfNodeBefore(tr.selection);
+// ```
+export const findPositionOfNodeBefore = selection => {
+  const { nodeBefore } = selection.$from;
+  const maybeSelection = Selection.findFrom(selection.$from, -1);
+  if (maybeSelection && nodeBefore) {
+    // leaf node
+    const parent = findParentNodeOfType(nodeBefore.type)(maybeSelection);
+    if (parent) {
+      return parent.pos;
+    }
+    return maybeSelection.$from.pos;
+  }
+};
+
+// :: (position: number, domAtPos: (pos: number) → {node: dom.Node, offset: number}) → dom.Node
+// Returns DOM reference of a node at a given `position`. If the node type is of type `TEXT_NODE` it will return the reference of the parent node.
+//
+// ```javascript
+// const domAtPos = view.domAtPos.bind(view);
+// const ref = findDomRefAtPos($from.pos, domAtPos);
+// ```
+export const findDomRefAtPos = (position, domAtPos) => {
+  const dom = domAtPos(position);
+  const node = dom.node.childNodes[dom.offset];
+
+  if (dom.node.nodeType === Node.TEXT_NODE) {
+    return dom.node.parentNode;
+  }
+
+  if (!node || node.nodeType === Node.TEXT_NODE) {
+    return dom.node;
+  }
+
+  return node;
+};

package/node_modules/prosemirror-utils/dist/transforms.js

@@ -0,0 +1,257 @@
+import { NodeSelection, Selection } from 'prosemirror-state';
+import { Fragment } from 'prosemirror-model';
+import { findParentNodeOfType, findPositionOfNodeBefore } from './selection';
+import {
+  cloneTr,
+  isNodeSelection,
+  replaceNodeAtPos,
+  removeNodeAtPos,
+  canInsert,
+  isEmptyParagraph
+} from './helpers';
+
+// :: (nodeType: union<NodeType, [NodeType]>) → (tr: Transaction) → Transaction
+// Returns a new transaction that removes a node of a given `nodeType`. It will return an original transaction if parent node hasn't been found.
+//
+// ```javascript
+// dispatch(
+//   removeParentNodeOfType(schema.nodes.table)(tr)
+// );
+// ```
+export const removeParentNodeOfType = nodeType => tr => {
+  const parent = findParentNodeOfType(nodeType)(tr.selection);
+  if (parent) {
+    return removeNodeAtPos(parent.pos)(tr);
+  }
+  return tr;
+};
+
+// :: (nodeType: union<NodeType, [NodeType]>, content: union<ProseMirrorNode, Fragment>) → (tr: Transaction) → Transaction
+// Returns a new transaction that replaces parent node of a given `nodeType` with the given `content`. It will return an original transaction if either parent node hasn't been found or replacing is not possible.
+//
+// ```javascript
+// const node = schema.nodes.paragraph.createChecked({}, schema.text('new'));
+//
+// dispatch(
+//  replaceParentNodeOfType(schema.nodes.table, node)(tr)
+// );
+// ```
+export const replaceParentNodeOfType = (nodeType, content) => tr => {
+  if (!Array.isArray(nodeType)) {
+    nodeType = [nodeType];
+  }
+  for (let i = 0, count = nodeType.length; i < count; i++) {
+    const parent = findParentNodeOfType(nodeType[i])(tr.selection);
+    if (parent) {
+      const newTr = replaceNodeAtPos(parent.pos, content)(tr);
+      if (newTr !== tr) {
+        return newTr;
+      }
+    }
+  }
+  return tr;
+};
+
+// :: (tr: Transaction) → Transaction
+// Returns a new transaction that removes selected node. It will return an original transaction if current selection is not a `NodeSelection`.
+//
+// ```javascript
+// dispatch(
+//   removeSelectedNode(tr)
+// );
+// ```
+export const removeSelectedNode = tr => {
+  if (isNodeSelection(tr.selection)) {
+    const from = tr.selection.$from.pos;
+    const to = tr.selection.$to.pos;
+    return cloneTr(tr.delete(from, to));
+  }
+  return tr;
+};
+
+// :: (content: union<ProseMirrorNode, ProseMirrorFragment>) → (tr: Transaction) → Transaction
+// Returns a new transaction that replaces selected node with a given `node`, keeping NodeSelection on the new `node`.
+// It will return the original transaction if either current selection is not a NodeSelection or replacing is not possible.
+//
+// ```javascript
+// const node = schema.nodes.paragraph.createChecked({}, schema.text('new'));
+// dispatch(
+//   replaceSelectedNode(node)(tr)
+// );
+// ```
+export const replaceSelectedNode = content => tr => {
+  if (isNodeSelection(tr.selection)) {
+    const { $from, $to } = tr.selection;
+    if (
+      (content instanceof Fragment &&
+        $from.parent.canReplace($from.index(), $from.indexAfter(), content)) ||
+      $from.parent.canReplaceWith(
+        $from.index(),
+        $from.indexAfter(),
+        content.type
+      )
+    ) {
+      return cloneTr(
+        tr
+          .replaceWith($from.pos, $to.pos, content)
+          // restore node selection
+          .setSelection(new NodeSelection(tr.doc.resolve($from.pos)))
+      );
+    }
+  }
+  return tr;
+};
+
+// :: (position: number, dir: ?number) → (tr: Transaction) → Transaction
+// Returns a new transaction that tries to find a valid cursor selection starting at the given `position`
+// and searching back if `dir` is negative, and forward if positive.
+// If a valid cursor position hasn't been found, it will return the original transaction.
+//
+// ```javascript
+// dispatch(
+//   setTextSelection(5)(tr)
+// );
+// ```
+export const setTextSelection = (position, dir = 1) => tr => {
+  const nextSelection = Selection.findFrom(tr.doc.resolve(position), dir, true);
+  if (nextSelection) {
+    return tr.setSelection(nextSelection);
+  }
+  return tr;
+};
+
+const isSelectableNode = node => node.type && node.type.spec.selectable;
+const shouldSelectNode = node => isSelectableNode(node) && node.type.isLeaf;
+
+const setSelection = (node, pos, tr) => {
+  if (shouldSelectNode(node)) {
+    return tr.setSelection(new NodeSelection(tr.doc.resolve(pos)));
+  }
+  return setTextSelection(pos)(tr);
+};
+
+// :: (content: union<ProseMirrorNode, Fragment>, position: ?number, tryToReplace?: boolean) → (tr: Transaction) → Transaction
+// Returns a new transaction that inserts a given `content` at the current cursor position, or at a given `position`, if it is allowed by schema. If schema restricts such nesting, it will try to find an appropriate place for a given node in the document, looping through parent nodes up until the root document node.
+// If `tryToReplace` is true and current selection is a NodeSelection, it will replace selected node with inserted content if its allowed by schema.
+// If cursor is inside of an empty paragraph, it will try to replace that paragraph with the given content. If insertion is successful and inserted node has content, it will set cursor inside of that content.
+// It will return an original transaction if the place for insertion hasn't been found.
+//
+// ```javascript
+// const node = schema.nodes.extension.createChecked({});
+// dispatch(
+//   safeInsert(node)(tr)
+// );
+// ```
+export const safeInsert = (content, position, tryToReplace) => tr => {
+  const hasPosition = typeof position === 'number';
+  const { $from } = tr.selection;
+  const $insertPos = hasPosition
+    ? tr.doc.resolve(position)
+    : isNodeSelection(tr.selection)
+    ? tr.doc.resolve($from.pos + 1)
+    : $from;
+  const { parent } = $insertPos;
+
+  // try to replace selected node
+  if (isNodeSelection(tr.selection) && tryToReplace) {
+    const oldTr = tr;
+    tr = replaceSelectedNode(content)(tr);
+    if (oldTr !== tr) {
+      return tr;
+    }
+  }
+
+  // try to replace an empty paragraph
+  if (isEmptyParagraph(parent)) {
+    const oldTr = tr;
+    tr = replaceParentNodeOfType(parent.type, content)(tr);
+    if (oldTr !== tr) {
+      const pos = isSelectableNode(content)
+        ? // for selectable node, selection position would be the position of the replaced parent
+          $insertPos.before($insertPos.depth)
+        : $insertPos.pos;
+      return setSelection(content, pos, tr);
+    }
+  }
+
+  // given node is allowed at the current cursor position
+  if (canInsert($insertPos, content)) {
+    tr.insert($insertPos.pos, content);
+    const pos = hasPosition
+      ? $insertPos.pos
+      : isSelectableNode(content)
+      ? // for atom nodes selection position after insertion is the previous pos
+        tr.selection.$anchor.pos - 1
+      : tr.selection.$anchor.pos;
+    return cloneTr(setSelection(content, pos, tr));
+  }
+
+  // looking for a place in the doc where the node is allowed
+  for (let i = $insertPos.depth; i > 0; i--) {
+    const pos = $insertPos.after(i);
+    const $pos = tr.doc.resolve(pos);
+    if (canInsert($pos, content)) {
+      tr.insert(pos, content);
+      return cloneTr(setSelection(content, pos, tr));
+    }
+  }
+  return tr;
+};
+
+// :: (nodeType: union<NodeType, [NodeType]>, type: ?union<NodeType, null>, attrs: ?union<Object, null>, marks?: [Mark]) → (tr: Transaction) → Transaction
+// Returns a transaction that changes the type, attributes, and/or marks of the parent node of a given `nodeType`.
+//
+// ```javascript
+// const node = schema.nodes.extension.createChecked({});
+// dispatch(
+//   setParentNodeMarkup(schema.nodes.panel, null, { panelType })(tr);
+// );
+// ```
+export const setParentNodeMarkup = (nodeType, type, attrs, marks) => tr => {
+  const parent = findParentNodeOfType(nodeType)(tr.selection);
+  if (parent) {
+    return cloneTr(
+      tr.setNodeMarkup(
+        parent.pos,
+        type,
+        Object.assign({}, parent.node.attrs, attrs),
+        marks
+      )
+    );
+  }
+  return tr;
+};
+
+// :: (nodeType: union<NodeType, [NodeType]>) → (tr: Transaction) → Transaction
+// Returns a new transaction that sets a `NodeSelection` on a parent node of a `given nodeType`.
+//
+// ```javascript
+// dispatch(
+//   selectParentNodeOfType([tableCell, tableHeader])(state.tr)
+// );
+// ```
+export const selectParentNodeOfType = nodeType => tr => {
+  if (!isNodeSelection(tr.selection)) {
+    const parent = findParentNodeOfType(nodeType)(tr.selection);
+    if (parent) {
+      return cloneTr(tr.setSelection(NodeSelection.create(tr.doc, parent.pos)));
+    }
+  }
+  return tr;
+};
+
+// :: (tr: Transaction) → Transaction
+// Returns a new transaction that deletes previous node.
+//
+// ```javascript
+// dispatch(
+//   removeNodeBefore(state.tr)
+// );
+// ```
+export const removeNodeBefore = tr => {
+  const position = findPositionOfNodeBefore(tr.selection);
+  if (typeof position === 'number') {
+    return removeNodeAtPos(position)(tr);
+  }
+  return tr;
+};

package/node_modules/prosemirror-utils/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "prosemirror-utils",
+  "version": "1.0.0-0",
+  "description": "Utils library for ProseMirror",
+  "main": "dist/index.js",
+  "author": {
+    "name": "Eduard Shvedai",
+    "email": "eshvedai@gmail.com",
+    "url": "https://github.com/eshvedai"
+  },
+  "maintainers": [
+    {
+      "name": "Eduard Shvedai",
+      "email": "eshvedai@atlassian.com"
+    }
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/atlassian/prosemirror-utils.git"
+  },
+  "keywords": [
+    "ProseMirror",
+    "utils",
+    "helpers"
+  ],
+  "jest": {
+    "transform": {
+      "^.+\\.js$": "babel-jest"
+    },
+    "setupTestFrameworkScriptFile": "./jestFrameworkSetup.js",
+    "testURL": "http://localhost/"
+  },
+  "typings": "typings.d.ts",
+  "files": [
+    "dist",
+    "typings.d.ts"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "build_readme": "builddocs --name utils --format markdown --main src/README.md src/*.js > README.md",
+    "build_all": "npm run build && npm run build_readme",
+    "test": "NODE_ENV=testing jest",
+    "test-ci": "NODE_ENV=testing jest --coverage && codecov",
+    "prepare": "npm run build",
+    "precommit": "lint-staged"
+  },
+  "peerDependencies": {
+    "prosemirror-model": "^1.0.0",
+    "prosemirror-state": "^1.0.1"
+  },
+  "devDependencies": {
+    "babel-core": "^6.26.3",
+    "babel-jest": "^23.6.0",
+    "babel-preset-env": "^1.7.0",
+    "builddocs": "^0.3.2",
+    "codecov": "^3.1.0",
+    "husky": "^1.3.0",
+    "jest": "^23.6.0",
+    "jest-diff": "^23.6.0",
+    "lint-staged": "^8.1.0",
+    "prettier": "^1.15.3",
+    "prosemirror-model": "^1.0.0",
+    "prosemirror-schema-basic": "^1.0.0",
+    "prosemirror-state": "^1.0.1",
+    "prosemirror-test-builder": "^1.0.1",
+    "prosemirror-view": "^1.1.1",
+    "rollup": "^0.56.3",
+    "rollup-plugin-babel": "^3.0.3"
+  },
+  "lint-staged": {
+    "*.{js, md}": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "prettier": {
+    "singleQuote": true,
+    "trailing-comma": "es5"
+  }
+}

package/node_modules/prosemirror-utils/typings.d.ts

@@ -0,0 +1,79 @@
+import { Node as ProsemirrorNode, Schema, NodeType, Mark, MarkType, ResolvedPos, Fragment } from 'prosemirror-model';
+import { Selection, Transaction } from 'prosemirror-state';
+
+export type Predicate = (node: ProsemirrorNode) => boolean;
+
+export type DomAtPos = (pos: number) => {node: Node, offset: number};
+
+export type ContentNodeWithPos = {pos: number, start: number, depth: number, node: ProsemirrorNode};
+
+export type NodeWithPos = {pos: number, node: ProsemirrorNode};
+
+export type CellTransform = (cell: ContentNodeWithPos, tr: Transaction) => Transaction;
+
+export type MovementOptions = { tryToFit: boolean, direction?: -1 | 0 | 1 };
+
+// Selection
+export function findParentNode(predicate: Predicate): (selection: Selection) => ContentNodeWithPos | undefined;
+
+export function findParentNodeClosestToPos($pos: ResolvedPos, predicate: Predicate): ContentNodeWithPos | undefined;
+
+export function findParentDomRef(predicate: Predicate, domAtPos: DomAtPos): (selection: Selection) => Node | undefined;
+
+export function hasParentNode(predicate: Predicate): (selection: Selection) => boolean;
+
+export function findParentNodeOfType(nodeType: NodeType | NodeType[]): (selection: Selection) => ContentNodeWithPos | undefined;
+
+export function findParentNodeOfTypeClosestToPos($pos: ResolvedPos, nodeType: NodeType | NodeType[]): ContentNodeWithPos | undefined;
+
+export function hasParentNodeOfType(nodeType: NodeType | NodeType[]): (selection: Selection) => boolean;
+
+export function findParentDomRefOfType(nodeType: NodeType | NodeType[], domAtPos: DomAtPos): (selection: Selection) => Node | undefined;
+
+export function findSelectedNodeOfType(nodeType: NodeType | NodeType[]): (selection: Selection) => ContentNodeWithPos | undefined;
+
+export function isNodeSelection(selection: Selection): boolean;
+
+export function findPositionOfNodeBefore(selection: Selection): number | undefined;
+
+export function findDomRefAtPos(position: number, domAtPos: DomAtPos): Node;
+
+// Node
+export function flatten(node: ProsemirrorNode, descend?: boolean): NodeWithPos[];
+
+export function findChildren(node: ProsemirrorNode, predicate: Predicate, descend?: boolean): NodeWithPos[];
+
+export function findTextNodes(node: ProsemirrorNode, descend?: boolean): NodeWithPos[];
+
+export function findInlineNodes(node: ProsemirrorNode, descend?: boolean): NodeWithPos[];
+
+export function findBlockNodes(node: ProsemirrorNode, descend?: boolean): NodeWithPos[];
+
+export function findChildrenByAttr(node: ProsemirrorNode, predicate: Predicate, descend?: boolean): NodeWithPos[];
+
+export function findChildrenByType(node: ProsemirrorNode, nodeType: NodeType, descend?: boolean): NodeWithPos[];
+
+export function findChildrenByMark(node: ProsemirrorNode, markType: MarkType, descend?: boolean): NodeWithPos[];
+
+export function contains(node: ProsemirrorNode, nodeType: NodeType): boolean;
+
+// Transforms
+export function removeParentNodeOfType(nodeType: NodeType | NodeType[]): (tr: Transaction) => Transaction;
+
+export function replaceParentNodeOfType(nodeType: NodeType | NodeType[], node: ProsemirrorNode): (tr: Transaction) => Transaction;
+
+export function removeSelectedNode(tr: Transaction): Transaction;
+
+export function replaceSelectedNode(node: ProsemirrorNode): (tr: Transaction) => Transaction;
+
+export function canInsert($pos: ResolvedPos, node: ProsemirrorNode | Fragment): boolean;
+
+export function safeInsert(node: ProsemirrorNode | Fragment, position?: number, tryToReplace?: boolean): (tr: Transaction) => Transaction;
+
+export function setParentNodeMarkup(nodeType: NodeType | NodeType[], type?: NodeType | null, attrs?: { [key: string]: any } | null, marks?: Mark[]): (tr: Transaction) => Transaction;
+
+export function selectParentNodeOfType(nodeType: NodeType | NodeType[]): (tr: Transaction) => Transaction;
+
+export function removeNodeBefore(tr: Transaction): Transaction;
+
+export function setTextSelection(position: number, dir?: number): (tr: Transaction) => Transaction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modusoperandi/licit",
-  "version": "0.1.9",
+  "version": "0.13.2",
   "subversion": "1",
   "description": "Rich text editor built with React and ProseMirror",
   "main": "dist/index.js",
@@ -9,6 +9,9 @@
     "type": "git",
     "url": "git+https://github.com/MO-Movia/licit.git"
   },
+  "bundleDependencies": [
+    "prosemirror-utils"
+  ],
   "scripts": {
     "test": "jest",
     "build:bom": "cyclonedx-bom -o dist/bom.xml",
@@ -75,20 +78,23 @@
     "husky": "^4.3.0",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^26.6.3",
+    "jest-prosemirror": "^1.0.19",
+    "jest-sonar-reporter": "^2.0.0",
     "lint-staged": "^10.4.0",
     "mkdirp": "^1.0.4",
     "prettier": "^2.1.2",
-    "react-test-renderer": "^17.0.1",
     "stylelint": "^13.7.2",
     "stylelint-config-standard": "^20.0.0",
     "stylelint-prettier": "^1.2.0",
     "terser-webpack-plugin": "^3.1.0",
     "webpack": "^4.44.2",
+    "webpack-cli": "^4.9.1",
     "webpack-dev-server": "^3.11.0",
     "write-file-webpack-plugin": "4.5.1"
   },
   "dependencies": {
-    "@modusoperandi/licit-doc-attrs-step": "^0.1.1",
+    "@modusoperandi/licit-doc-attrs-step": "^0.1.2",
+    "@modusoperandi/licit-ui-commands": "^0.1.4",
     "body-parser": "^1.19.0",
     "browserkeymap": "2.0.2",
     "classnames": "2.2.6",
@@ -107,16 +113,16 @@
     "prosemirror-collab": "1.2.2",
     "prosemirror-commands": "1.1.5",
     "prosemirror-dev-tools": "3.0.2",
-    "prosemirror-dropcursor": "1.3.2",
-    "prosemirror-gapcursor": "1.1.5",
+    "prosemirror-dropcursor": "^1.3.5",
+    "prosemirror-gapcursor": "^1.2.2",
     "prosemirror-history": "1.1.3",
     "prosemirror-inputrules": "1.1.3",
     "prosemirror-keymap": "^1.1.4",
-    "prosemirror-model": "^1.13.1",
+    "prosemirror-model": "^1.16.1",
     "prosemirror-state": "^1.3.4",
     "prosemirror-tables": "^1.1.1",
     "prosemirror-transform": "^1.2.9",
-    "prosemirror-utils": "0.9.6",
+    "prosemirror-utils": "file:prosemirror-utils-1.0.0-0.tgz",
     "prosemirror-view": "^1.17.3",
     "query-string": "6.13.1",
     "react": "^16.13.1",
@@ -153,7 +159,7 @@
   "jest": {
     "rootDir": "src",
     "transform": {
-      "^.+\\.jsx?$": "babel-jest"
+      "^.+\\.js?$": "babel-jest"
     },
     "moduleNameMapper": {
       "\\.(css|less|scss|sass)$": "identity-obj-proxy"

package/src/CodeBlockCommand.js

@@ -6,7 +6,7 @@ import { findParentNodeOfType } from 'prosemirror-utils';
 import { EditorView } from 'prosemirror-view';
 
 import { CODE_BLOCK } from './NodeNames';
-import noop from './noop';
+import { noop } from '@modusoperandi/licit-ui-commands';
 import toggleCodeBlock from './toggleCodeBlock';
 import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
 

package/src/DocLayoutCommand.js

@@ -8,7 +8,7 @@ import { EditorView } from 'prosemirror-view';
 import { SetDocAttrStep } from '@modusoperandi/licit-doc-attrs-step';
 import DocLayoutEditor from './ui/DocLayoutEditor';
 import { UICommand } from '@modusoperandi/licit-doc-attrs-step';
-import createPopUp from './ui/createPopUp';
+import { createPopUp } from '@modusoperandi/licit-ui-commands';
 
 import type { DocLayoutEditorValue } from './ui/DocLayoutEditor';