@modusoperandi/licit 0.1.9 → 0.13.2

package/dist/ui/resolveImage.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = resolveImage;
 exports.bpfrpt_proptype_ImageResult = void 0;
+exports.default = resolveImage;
 
 var _url = _interopRequireDefault(require("url"));
 
@@ -14,9 +14,9 @@ var _propTypes = _interopRequireDefault(require("prop-types"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 

package/dist/ui/toCSSColor.js

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = void 0;
 exports.isTransparent = isTransparent;
 exports.toCSSColor = toCSSColor;
-exports.default = void 0;
 
 var _color = _interopRequireDefault(require("color"));
 

package/dist/ui/toCSSLineSpacing.js

@@ -3,9 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.LINE_SPACING_200 = exports.LINE_SPACING_150 = exports.LINE_SPACING_115 = exports.LINE_SPACING_100 = void 0;
 exports.default = toCSSLineSpacing;
-exports.getLineSpacingValue = getLineSpacingValue;
-exports.DOUBLE_LINE_SPACING = exports.SINGLE_LINE_SPACING = exports.LINE_SPACING_200 = exports.LINE_SPACING_150 = exports.LINE_SPACING_115 = exports.LINE_SPACING_100 = void 0;
 // Line spacing names and their values.
 const LINE_SPACING_100 = '125%';
 exports.LINE_SPACING_100 = LINE_SPACING_100;
@@ -15,10 +14,6 @@ const LINE_SPACING_150 = '165%';
 exports.LINE_SPACING_150 = LINE_SPACING_150;
 const LINE_SPACING_200 = '232%';
 exports.LINE_SPACING_200 = LINE_SPACING_200;
-const SINGLE_LINE_SPACING = LINE_SPACING_100;
-exports.SINGLE_LINE_SPACING = SINGLE_LINE_SPACING;
-const DOUBLE_LINE_SPACING = LINE_SPACING_200;
-exports.DOUBLE_LINE_SPACING = DOUBLE_LINE_SPACING;
 const NUMBER_VALUE_PATTERN = /^\d+(.\d+)?$/; // Normalize the css line-height vlaue to percentage-based value if applicable.
 // Also, it calibrates the incorrect line spacing value exported from Google
 // Doc.
@@ -62,34 +57,4 @@ function toCSSLineSpacing(source) {
 
 
   return strValue;
-} // [FS] IRAD-1104 2020-11-13
-// Issue fix : Linespacing Double and Single not applied in the sample text paragraph
-
-
-function getLineSpacingValue(lineSpacing) {
-  let _lineSpaceValue = '';
-
-  switch (lineSpacing) {
-    case 'Single':
-      _lineSpaceValue = SINGLE_LINE_SPACING;
-      break;
-
-    case '1.15':
-      _lineSpaceValue = LINE_SPACING_115;
-      break;
-
-    case '1.5':
-      _lineSpaceValue = LINE_SPACING_150;
-      break;
-
-    case 'Double':
-      _lineSpaceValue = DOUBLE_LINE_SPACING;
-      break;
-
-    default:
-      _lineSpaceValue = SINGLE_LINE_SPACING;
-      break;
-  }
-
-  return _lineSpaceValue;
 }

package/dist/ui/toCSSLineSpacing.js.flow

@@ -6,9 +6,6 @@ export const LINE_SPACING_115 = '138%';
 export const LINE_SPACING_150 = '165%';
 export const LINE_SPACING_200 = '232%';
 
-export const SINGLE_LINE_SPACING = LINE_SPACING_100;
-export const DOUBLE_LINE_SPACING = LINE_SPACING_200;
-
 const NUMBER_VALUE_PATTERN = /^\d+(.\d+)?$/;
 
 // Normalize the css line-height vlaue to percentage-based value if applicable.
@@ -56,27 +53,3 @@ export default function toCSSLineSpacing(source: any): string {
   // e.g. line-height: 15px;
   return strValue;
 }
-
-// [FS] IRAD-1104 2020-11-13
-// Issue fix : Linespacing Double and Single not applied in the sample text paragraph
-export function getLineSpacingValue(lineSpacing: string): string {
-  let _lineSpaceValue = '';
-  switch (lineSpacing) {
-    case 'Single':
-      _lineSpaceValue = SINGLE_LINE_SPACING;
-      break;
-    case '1.15':
-      _lineSpaceValue = LINE_SPACING_115;
-      break;
-    case '1.5':
-      _lineSpaceValue = LINE_SPACING_150;
-      break;
-    case 'Double':
-      _lineSpaceValue = DOUBLE_LINE_SPACING;
-      break;
-    default:
-      _lineSpaceValue = SINGLE_LINE_SPACING;
-      break;
-  }
-  return _lineSpaceValue;
-}

package/flow-typed/@modusoperandilicit-ui-commands.js

@@ -0,0 +1,5 @@
+// @flow
+
+declare module '@modusoperandi/licit-ui-commands' {
+  declare module.exports: any;
+}

package/jest.config.js

@@ -0,0 +1,207 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+module.exports = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/tmp/jest_rs",
+
+  // Automatically clear mock calls and instances between every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  collectCoverageFrom: [
+      '**/*.{js}'
+    ],
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: '../coverage',
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  // coverageProvider: "babel",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  coverageReporters: [
+  //   "json",
+  //   "text",
+     'lcov',
+  //   "clover"
+  ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  moduleFileExtensions: [
+     'js',
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  moduleNameMapper: {
+'\\.(css|less|scss|sass)$': 'identity-obj-proxy'
+  },
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  //preset: 'ts-jest/presets/default',
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state between every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state between every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  rootDir: 'src',
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  setupFiles: [
+      '../jest.setup.js'
+  ],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  setupFilesAfterEnv: [
+      'jest-prosemirror/environment'
+    ],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  testEnvironment: 'jsdom',
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+   testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+     '**/?(*.)+(spec|test).[j]s?(x)'
+  ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  //testRegex: ["((\\.|/*.)(test))\\.ts?$"],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: "jest-sonar-reporter",
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // This option sets the URL for the jsdom environment. It is reflected in properties such as location.href
+  // testURL: "http://localhost",
+
+  // Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"
+  // timers: "real",
+
+  // A map from regular expressions to paths to transformers
+  /*transform: {
+   "^.+\\.(js|jsx|ts|tsx)$": "babel-jest"
+  },*/
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  transformIgnorePatterns: [
+   'node_modules/(?!(prosemirror-utils|@modusoperandi)/).+\\.js$'
+  //   "\\.pnp\\.[^\\/]+$"
+  ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  verbose: true,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+
+  // Default timeout of a test in milliseconds.
+  testTimeout: 30000,
+};

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