@modusoperandi/licit 0.13.3 → 0.13.10

package/src/index.js

@@ -5,6 +5,6 @@ export { default as isEditorStateEmpty } from './isEditorStateEmpty';
 export { default as uuid } from './ui/uuid';
 // [FS] IRAD-978 2020-06-05
 // Export Licit as a component
-export { default as Licit } from './client/Licit.js';
+export { default as Licit, DataType } from './client/Licit.js';
 export { ImageLike, EditorRuntime } from './Types';
 export { GET, POST, DELETE, PATCH } from './client/http';

package/src/patchStyleElements.js

@@ -1,6 +1,5 @@
 // @flow
 
-import stable from 'stable';
 import toCSSColor from './ui/toCSSColor';
 import { toCSSLineSpacing } from '@modusoperandi/licit-ui-commands';
 
@@ -94,7 +93,8 @@ export default function patchStyleElements(doc: Document): void {
   });
 
   // Sort selector by
-  stable(selectorTextToCSSTexts, sortBySpecificity)
+  selectorTextToCSSTexts
+    .sort(sortBySpecificity)
     .reduce(buildElementToCSSTexts.bind(null, doc), new Map<any, any>())
     .forEach(applyInlineStyleSheetCSSTexts);
 }

package/src/ui/czi-link-tooltip.css

@@ -1,4 +1,4 @@
-@import '../../node_modules/@modusoperandi/licit-ui-commands/dist/ui/czi-custom-button.css';
+@import '@modusoperandi/licit-ui-commands/dist/ui/czi-custom-button.css';
 @import './czi-vars.css';
 
 .czi-link-tooltip {

package/src/ui/czi-vars.css

@@ -1,2 +1,2 @@
-@import '../../node_modules/@modusoperandi/licit-ui-commands/dist/ui/czi-vars.css';
+@import '@modusoperandi/licit-ui-commands/dist/ui/czi-vars.css';
 

package/node_modules/prosemirror-utils/LICENSE

@@ -1,13 +0,0 @@
-Copyright 2018 Atlassian Pty Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

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

@@ -1,119 +0,0 @@
-import { NodeSelection } from 'prosemirror-state';
-import { Fragment, Node as PMNode } from 'prosemirror-model';
-import { setTextSelection } from './transforms';
-import { findParentNodeClosestToPos } from './selection';
-
-// :: (selection: Selection) → boolean
-// Checks if current selection is a `NodeSelection`.
-//
-// ```javascript
-// if (isNodeSelection(tr.selection)) {
-//   // ...
-// }
-// ```
-export const isNodeSelection = selection => {
-  return selection instanceof NodeSelection;
-};
-
-// (nodeType: union<NodeType, [NodeType]>) → boolean
-// Checks if the type a given `node` equals to a given `nodeType`.
-export const equalNodeType = (nodeType, node) => {
-  return (
-    (Array.isArray(nodeType) && nodeType.indexOf(node.type) > -1) ||
-    node.type === nodeType
-  );
-};
-
-// (tr: Transaction) → Transaction
-// Creates a new transaction object from a given transaction
-export const cloneTr = tr => {
-  return Object.assign(Object.create(tr), tr).setTime(Date.now());
-};
-
-// (position: number, content: union<ProseMirrorNode, Fragment>) → (tr: Transaction) → Transaction
-// Returns a `replace` transaction that replaces a node at a given position with the given `content`.
-// It will return the original transaction if replacing is not possible.
-// `position` should point at the position immediately before the node.
-export const replaceNodeAtPos = (position, content) => tr => {
-  const node = tr.doc.nodeAt(position);
-  const $pos = tr.doc.resolve(position);
-  if (canReplace($pos, content)) {
-    tr = tr.replaceWith(position, position + node.nodeSize, content);
-    const start = tr.selection.$from.pos - 1;
-    // put cursor inside of the inserted node
-    tr = setTextSelection(Math.max(start, 0), -1)(tr);
-    // move cursor to the start of the node
-    tr = setTextSelection(tr.selection.$from.start())(tr);
-    return cloneTr(tr);
-  }
-  return tr;
-};
-
-// ($pos: ResolvedPos, doc: ProseMirrorNode, content: union<ProseMirrorNode, Fragment>, ) → boolean
-// Checks if replacing a node at a given `$pos` inside of the `doc` node with the given `content` is possible.
-export const canReplace = ($pos, content) => {
-  const node = $pos.node($pos.depth);
-  return (
-    node &&
-    node.type.validContent(
-      content instanceof Fragment ? content : Fragment.from(content)
-    )
-  );
-};
-
-// (position: number) → (tr: Transaction) → Transaction
-// Returns a `delete` transaction that removes a node at a given position with the given `node`.
-// `position` should point at the position immediately before the node.
-export const removeNodeAtPos = position => tr => {
-  const node = tr.doc.nodeAt(position);
-  return cloneTr(tr.delete(position, position + node.nodeSize));
-};
-
-// :: ($pos: ResolvedPos, content: union<ProseMirrorNode, Fragment>) → boolean
-// Checks if a given `content` can be inserted at the given `$pos`
-//
-// ```javascript
-// const { selection: { $from } } = state;
-// const node = state.schema.nodes.atom.createChecked();
-// if (canInsert($from, node)) {
-//   // ...
-// }
-// ```
-export const canInsert = ($pos, content) => {
-  const index = $pos.index();
-
-  if (content instanceof Fragment) {
-    return $pos.parent.canReplace(index, index, content);
-  } else if (content instanceof PMNode) {
-    return $pos.parent.canReplaceWith(index, index, content.type);
-  }
-  return false;
-};
-
-// (node: ProseMirrorNode) → boolean
-// Checks if a given `node` is an empty paragraph
-export const isEmptyParagraph = node => {
-  return !node || (node.type.name === 'paragraph' && node.nodeSize === 2);
-};
-
-export const checkInvalidMovements = (
-  originIndex,
-  targetIndex,
-  targets,
-  type
-) => {
-  const direction = originIndex > targetIndex ? -1 : 1;
-  const errorMessage = `Target position is invalid, you can't move the ${type} ${originIndex} to ${targetIndex}, the target can't be split. You could use tryToFit option.`;
-
-  if (direction === 1) {
-    if (targets.slice(0, targets.length - 1).indexOf(targetIndex) !== -1) {
-      throw new Error(errorMessage);
-    }
-  } else {
-    if (targets.slice(1).indexOf(targetIndex) !== -1) {
-      throw new Error(errorMessage);
-    }
-  }
-
-  return true;
-};

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

@@ -1,17 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var selection_js = require('./selection.js');
-var node_js = require('./node.js');
-var transforms_js = require('./transforms.js');
-var helpers_js = require('./helpers.js');
-
-
-
-Object.keys(selection_js).forEach(function (key) { exports[key] = selection_js[key]; });
-Object.keys(node_js).forEach(function (key) { exports[key] = node_js[key]; });
-Object.keys(transforms_js).forEach(function (key) { exports[key] = transforms_js[key]; });
-exports.isNodeSelection = helpers_js.isNodeSelection;
-exports.canInsert = helpers_js.canInsert;
-//# sourceMappingURL=index.js.map

package/node_modules/prosemirror-utils/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}

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

@@ -1,106 +0,0 @@
-// :: (node: ProseMirrorNode, descend: ?boolean) → [{ node: ProseMirrorNode, pos: number }]
-// Flattens descendants of a given `node`. It doesn't descend into a node when descend argument is `false` (defaults to `true`).
-//
-// ```javascript
-// const children = flatten(node);
-// ```
-export const flatten = (node, descend = true) => {
-  if (!node) {
-    throw new Error('Invalid "node" parameter');
-  }
-  const result = [];
-  node.descendants((child, pos) => {
-    result.push({ node: child, pos });
-    if (!descend) {
-      return false;
-    }
-  });
-  return result;
-};
-
-// :: (node: ProseMirrorNode, predicate: (node: ProseMirrorNode) → boolean, descend: ?boolean) → [{ node: ProseMirrorNode, pos: number }]
-// Iterates over descendants of a given `node`, returning child nodes predicate returns truthy for. It doesn't descend into a node when descend argument is `false` (defaults to `true`).
-//
-// ```javascript
-// const textNodes = findChildren(node, child => child.isText, false);
-// ```
-export const findChildren = (node, predicate, descend) => {
-  if (!node) {
-    throw new Error('Invalid "node" parameter');
-  } else if (!predicate) {
-    throw new Error('Invalid "predicate" parameter');
-  }
-  return flatten(node, descend).filter(child => predicate(child.node));
-};
-
-// :: (node: ProseMirrorNode, descend: ?boolean) → [{ node: ProseMirrorNode, pos: number }]
-// Returns text nodes of a given `node`. It doesn't descend into a node when descend argument is `false` (defaults to `true`).
-//
-// ```javascript
-// const textNodes = findTextNodes(node);
-// ```
-export const findTextNodes = (node, descend) => {
-  return findChildren(node, child => child.isText, descend);
-};
-
-// :: (node: ProseMirrorNode, descend: ?boolean) → [{ node: ProseMirrorNode, pos: number }]
-// Returns inline nodes of a given `node`. It doesn't descend into a node when descend argument is `false` (defaults to `true`).
-//
-// ```javascript
-// const inlineNodes = findInlineNodes(node);
-// ```
-export const findInlineNodes = (node, descend) => {
-  return findChildren(node, child => child.isInline, descend);
-};
-
-// :: (node: ProseMirrorNode, descend: ?boolean) → [{ node: ProseMirrorNode, pos: number }]
-// Returns block descendants of a given `node`. It doesn't descend into a node when descend argument is `false` (defaults to `true`).
-//
-// ```javascript
-// const blockNodes = findBlockNodes(node);
-// ```
-export const findBlockNodes = (node, descend) => {
-  return findChildren(node, child => child.isBlock, descend);
-};
-
-// :: (node: ProseMirrorNode, predicate: (attrs: ?Object) → boolean, descend: ?boolean) → [{ node: ProseMirrorNode, pos: number }]
-// Iterates over descendants of a given `node`, returning child nodes predicate returns truthy for. It doesn't descend into a node when descend argument is `false` (defaults to `true`).
-//
-// ```javascript
-// const mergedCells = findChildrenByAttr(table, attrs => attrs.colspan === 2);
-// ```
-export const findChildrenByAttr = (node, predicate, descend) => {
-  return findChildren(node, child => !!predicate(child.attrs), descend);
-};
-
-// :: (node: ProseMirrorNode, nodeType: NodeType, descend: ?boolean) → [{ node: ProseMirrorNode, pos: number }]
-// Iterates over descendants of a given `node`, returning child nodes of a given nodeType. It doesn't descend into a node when descend argument is `false` (defaults to `true`).
-//
-// ```javascript
-// const cells = findChildrenByType(table, schema.nodes.tableCell);
-// ```
-export const findChildrenByType = (node, nodeType, descend) => {
-  return findChildren(node, child => child.type === nodeType, descend);
-};
-
-// :: (node: ProseMirrorNode, markType: markType, descend: ?boolean) → [{ node: ProseMirrorNode, pos: number }]
-// Iterates over descendants of a given `node`, returning child nodes that have a mark of a given markType. It doesn't descend into a `node` when descend argument is `false` (defaults to `true`).
-//
-// ```javascript
-// const nodes = findChildrenByMark(state.doc, schema.marks.strong);
-// ```
-export const findChildrenByMark = (node, markType, descend) => {
-  return findChildren(node, child => markType.isInSet(child.marks), descend);
-};
-
-// :: (node: ProseMirrorNode, nodeType: NodeType) → boolean
-// Returns `true` if a given node contains nodes of a given `nodeType`
-//
-// ```javascript
-// if (contains(panel, schema.nodes.listItem)) {
-//   // ...
-// }
-// ```
-export const contains = (node, nodeType) => {
-  return !!findChildrenByType(node, nodeType).length;
-};

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

@@ -1,168 +0,0 @@
-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;
-};