@modusoperandi/licit 0.1.10 → 0.13.3

package/licit/server/image/start.js

@@ -1,58 +1,58 @@
-// @flow
-
-const express = require('express');
-const cors = require('cors');
-const formidable = require('formidable');
-const mv = require('mv');
-const uuidv4 = require('uuid').v4;
-
-const app = express();
-
-const PORT = process.env.PORT || 3004;
-
-//allow OPTIONS on all resources
-app.options('*', cors());
-app.use(cors());
-
-// Handle asset GET url.
-app.use('/assets', express.static('../images/'));
-// Handle image upload.
-app.post('/saveimage', function (req, res) {
-  const form = new formidable.IncomingForm();
-  form.parse(req, function (err, fields, blob) {
-    const oldpath = blob.file.path;
-    const fileid = uuidv4();
-    const filename = fileid + '_' + req.query['fn'];
-    const newpath = '../images/' + filename;
-    mv(oldpath, newpath, function (err) {
-      if (err) {
-        res.writeHead(500, {
-          'Content-Type': 'application/json',
-          'Access-Control-Allow-Origin': '*',
-        });
-        res.json({error: err});
-      } else {
-        const host = req.headers['host'];
-        const proto = req.connection.encrypted ? 'https' : 'http';
-        const imgSrc = proto + '://' + host + '/assets/' + filename;
-        res.writeHead(200, {
-          'Content-Type': 'application/json',
-          'Access-Control-Allow-Origin': '*',
-        });
-        res.write(
-          JSON.stringify({
-            id: fileid,
-            width: 0,
-            height: 0,
-            src: imgSrc,
-          })
-        );
-      }
-      res.end();
-    });
-  });
-});
-
-app.listen(PORT, () =>
-  console.log('Image Server running on port ' + PORT + '!...')
-);
+// @flow
+
+const express = require('express');
+const cors = require('cors');
+const formidable = require('formidable');
+const mv = require('mv');
+const uuidv4 = require('uuid').v4;
+
+const app = express();
+
+const PORT = process.env.PORT || 3004;
+
+//allow OPTIONS on all resources
+app.options('*', cors());
+app.use(cors());
+
+// Handle asset GET url.
+app.use('/assets', express.static('../images/'));
+// Handle image upload.
+app.post('/saveimage', function (req, res) {
+  const form = new formidable.IncomingForm();
+  form.parse(req, function (err, fields, blob) {
+    const oldpath = blob.file.path;
+    const fileid = uuidv4();
+    const filename = fileid + '_' + req.query['fn'];
+    const newpath = '../images/' + filename;
+    mv(oldpath, newpath, function (err) {
+      if (err) {
+        res.writeHead(500, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        });
+        res.json({error: err});
+      } else {
+        const host = req.headers['host'];
+        const proto = req.connection.encrypted ? 'https' : 'http';
+        const imgSrc = proto + '://' + host + '/assets/' + filename;
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        });
+        res.write(
+          JSON.stringify({
+            id: fileid,
+            width: 0,
+            height: 0,
+            src: imgSrc,
+          })
+        );
+      }
+      res.end();
+    });
+  });
+});
+
+app.listen(PORT, () =>
+  console.log('Image Server running on port ' + PORT + '!...')
+);

package/lint.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
-
-node node_modules/eslint/bin/eslint.js --fix src/
-
+#!/bin/bash
+
+node node_modules/eslint/bin/eslint.js --fix src/
+

package/node_modules/prosemirror-utils/LICENSE

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,17 @@
+'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

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

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

@@ -0,0 +1,106 @@
+// :: (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

@@ -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;
+};