@pie-element/ebsr 6.6.3-next.411 → 6.6.3-next.412

package/configure/node_modules/slate-edit-list/dist/index.js.flow

@@ -0,0 +1,45 @@
+// @flow
+import Options, { type OptionsFormat } from './options';
+import { onEnter, onTab, onBackspace } from './handlers';
+import core from './core';
+
+const KEY_ENTER = 'Enter';
+const KEY_TAB = 'Tab';
+const KEY_BACKSPACE = 'Backspace';
+
+/**
+ * A Slate plugin to handle keyboard events in lists.
+ */
+function EditList(
+    // Options for the plugin
+    opts: OptionsFormat = {}
+): Object {
+    opts = new Options(opts);
+    const corePlugin = core(opts);
+
+    return {
+        ...corePlugin,
+
+        onKeyDown: onKeyDown.bind(null, opts)
+    };
+}
+
+/**
+ * User is pressing a key in the editor
+ */
+function onKeyDown(opts: Options, event, change, editor: *): void | any {
+    const args = [event, change, editor, opts];
+
+    switch (event.key) {
+        case KEY_ENTER:
+            return onEnter(...args);
+        case KEY_TAB:
+            return onTab(...args);
+        case KEY_BACKSPACE:
+            return onBackspace(...args);
+        default:
+            return undefined;
+    }
+}
+
+export default EditList;

package/configure/node_modules/slate-edit-list/dist/options.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _immutable = require('immutable');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+/**
+ * The plugin options
+ */
+var Options = function (_Record) {
+    _inherits(Options, _Record);
+
+    function Options() {
+        _classCallCheck(this, Options);
+
+        return _possibleConstructorReturn(this, (Options.__proto__ || Object.getPrototypeOf(Options)).apply(this, arguments));
+    }
+
+    return Options;
+}((0, _immutable.Record)({
+    types: ['ul_list', 'ol_list'],
+    typeItem: 'list_item',
+    typeDefault: 'paragraph'
+}));
+
+exports.default = Options;

package/configure/node_modules/slate-edit-list/dist/options.js.flow

@@ -0,0 +1,26 @@
+// @flow
+import { Record } from 'immutable';
+
+export type OptionsFormat = {
+    types?: string[],
+    typeItem?: string,
+    typeDefault?: string
+};
+
+/**
+ * The plugin options
+ */
+class Options extends Record({
+    types: ['ul_list', 'ol_list'],
+    typeItem: 'list_item',
+    typeDefault: 'paragraph'
+}) {
+    // The possibles types for list containers
+    types: string[];
+    // The type of list items
+    typeItem: string;
+    // The type of default block in items
+    typeDefault: string;
+}
+
+export default Options;

package/configure/node_modules/slate-edit-list/dist/utils/getCurrentItem.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+/**
+ * Return the current list item, from current selection or from a node.
+ */
+function getCurrentItem(opts, value, block) {
+    var document = value.document;
+
+
+    if (!block) {
+        if (!value.selection.startKey) return null;
+        block = value.startBlock;
+    }
+
+    var parent = document.getParent(block.key);
+    return parent && parent.type === opts.typeItem ? parent : null;
+}
+exports.default = getCurrentItem;

package/configure/node_modules/slate-edit-list/dist/utils/getCurrentItem.js.flow

@@ -0,0 +1,20 @@
+// @flow
+import { type Value, type Block } from 'slate';
+import type Options from '../options';
+
+/**
+ * Return the current list item, from current selection or from a node.
+ */
+function getCurrentItem(opts: Options, value: Value, block?: Block): ?Block {
+    const { document } = value;
+
+    if (!block) {
+        if (!value.selection.startKey) return null;
+        block = value.startBlock;
+    }
+
+    const parent = document.getParent(block.key);
+    return parent && parent.type === opts.typeItem ? parent : null;
+}
+
+export default getCurrentItem;

package/configure/node_modules/slate-edit-list/dist/utils/getCurrentList.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _getCurrentItem = require('./getCurrentItem');
+
+var _getCurrentItem2 = _interopRequireDefault(_getCurrentItem);
+
+var _getListForItem = require('./getListForItem');
+
+var _getListForItem2 = _interopRequireDefault(_getListForItem);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Return the parent list block, from current selection or from a node (paragraph in a list item).
+ */
+function getCurrentList(opts, value, block) {
+    var item = (0, _getCurrentItem2.default)(opts, value, block);
+
+    if (!item) {
+        return null;
+    }
+
+    return (0, _getListForItem2.default)(opts, value, item);
+}
+exports.default = getCurrentList;

package/configure/node_modules/slate-edit-list/dist/utils/getCurrentList.js.flow

@@ -0,0 +1,21 @@
+// @flow
+import { type Value, type Block } from 'slate';
+
+import type Options from '../options';
+import getCurrentItem from './getCurrentItem';
+import getListForItem from './getListForItem';
+
+/**
+ * Return the parent list block, from current selection or from a node (paragraph in a list item).
+ */
+function getCurrentList(opts: Options, value: Value, block?: Block): ?Block {
+    const item = getCurrentItem(opts, value, block);
+
+    if (!item) {
+        return null;
+    }
+
+    return getListForItem(opts, value, item);
+}
+
+export default getCurrentList;

package/configure/node_modules/slate-edit-list/dist/utils/getItemDepth.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _getCurrentItem = require('./getCurrentItem');
+
+var _getCurrentItem2 = _interopRequireDefault(_getCurrentItem);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Get depth of current block in a document list
+ */
+function getItemDepth(opts, value, block) {
+    var document = value.document,
+        startBlock = value.startBlock;
+
+    block = block || startBlock;
+
+    var currentItem = (0, _getCurrentItem2.default)(opts, value, block);
+    if (!currentItem) {
+        return 0;
+    }
+
+    var list = document.getParent(currentItem.key);
+
+    return 1 + getItemDepth(opts, value, list);
+}
+
+exports.default = getItemDepth;

package/configure/node_modules/slate-edit-list/dist/utils/getItemDepth.js.flow

@@ -0,0 +1,24 @@
+// @flow
+import { type Value, type Block } from 'slate';
+
+import type Options from '../options';
+import getCurrentItem from './getCurrentItem';
+
+/**
+ * Get depth of current block in a document list
+ */
+function getItemDepth(opts: Options, value: Value, block?: Block): number {
+    const { document, startBlock } = value;
+    block = block || startBlock;
+
+    const currentItem = getCurrentItem(opts, value, block);
+    if (!currentItem) {
+        return 0;
+    }
+
+    const list = document.getParent(currentItem.key);
+
+    return 1 + getItemDepth(opts, value, list);
+}
+
+export default getItemDepth;

package/configure/node_modules/slate-edit-list/dist/utils/getItemsAtRange.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _immutable = require('immutable');
+
+var _isList = require('./isList');
+
+var _isList2 = _interopRequireDefault(_isList);
+
+var _getCurrentItem = require('./getCurrentItem');
+
+var _getCurrentItem2 = _interopRequireDefault(_getCurrentItem);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Return the list of items at the given range. The returned items are
+ * the highest list item blocks that cover the range.
+ *
+ * Returns an empty list if no list of items can cover the range
+ */
+function getItemsAtRange(opts, value, range) {
+    range = range || value.selection;
+
+    if (!range.startKey) {
+        return (0, _immutable.List)();
+    }
+
+    var document = value.document;
+
+
+    var startBlock = document.getClosestBlock(range.startKey);
+    var endBlock = document.getClosestBlock(range.endKey);
+
+    if (startBlock === endBlock) {
+        var item = (0, _getCurrentItem2.default)(opts, value, startBlock);
+        return item ? (0, _immutable.List)([item]) : (0, _immutable.List)();
+    }
+
+    var ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);
+
+    if ((0, _isList2.default)(opts, ancestor)) {
+        var startPath = ancestor.getPath(startBlock.key);
+        var endPath = ancestor.getPath(endBlock.key);
+
+        return ancestor.nodes.slice(startPath[0], endPath[0] + 1);
+    } else if (ancestor.type === opts.typeItem) {
+        // The ancestor is the highest list item that covers the range
+        return (0, _immutable.List)([ancestor]);
+    }
+    // No list of items can cover the range
+    return (0, _immutable.List)();
+}
+
+exports.default = getItemsAtRange;

package/configure/node_modules/slate-edit-list/dist/utils/getItemsAtRange.js.flow

@@ -0,0 +1,51 @@
+// @flow
+import { type Value, type Block, type Range } from 'slate';
+import { List } from 'immutable';
+
+import type Options from '../options';
+import isList from './isList';
+import getCurrentItem from './getCurrentItem';
+
+/**
+ * Return the list of items at the given range. The returned items are
+ * the highest list item blocks that cover the range.
+ *
+ * Returns an empty list if no list of items can cover the range
+ */
+function getItemsAtRange(
+    opts: Options,
+    value: Value,
+    range?: Range
+): List<Block> {
+    range = range || value.selection;
+
+    if (!range.startKey) {
+        return List();
+    }
+
+    const { document } = value;
+
+    const startBlock = document.getClosestBlock(range.startKey);
+    const endBlock = document.getClosestBlock(range.endKey);
+
+    if (startBlock === endBlock) {
+        const item = getCurrentItem(opts, value, startBlock);
+        return item ? List([item]) : List();
+    }
+
+    const ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);
+
+    if (isList(opts, ancestor)) {
+        const startPath = ancestor.getPath(startBlock.key);
+        const endPath = ancestor.getPath(endBlock.key);
+
+        return ancestor.nodes.slice(startPath[0], endPath[0] + 1);
+    } else if (ancestor.type === opts.typeItem) {
+        // The ancestor is the highest list item that covers the range
+        return List([ancestor]);
+    }
+    // No list of items can cover the range
+    return List();
+}
+
+export default getItemsAtRange;

package/configure/node_modules/slate-edit-list/dist/utils/getListForItem.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _isList = require('./isList');
+
+var _isList2 = _interopRequireDefault(_isList);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Return the parent list block for an item block.
+ */
+function getListForItem(opts, value, item) {
+    var document = value.document;
+
+    var parent = document.getParent(item.key);
+    return parent && (0, _isList2.default)(opts, parent) ? parent : null;
+}
+
+exports.default = getListForItem;

package/configure/node_modules/slate-edit-list/dist/utils/getListForItem.js.flow

@@ -0,0 +1,16 @@
+// @flow
+import { type Value, type Block } from 'slate';
+
+import type Options from '../options';
+import isList from './isList';
+
+/**
+ * Return the parent list block for an item block.
+ */
+function getListForItem(opts: Options, value: Value, item: Block): ?Block {
+    const { document } = value;
+    const parent = document.getParent(item.key);
+    return parent && isList(opts, parent) ? parent : null;
+}
+
+export default getListForItem;

package/configure/node_modules/slate-edit-list/dist/utils/getPreviousItem.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _getCurrentItem = require('./getCurrentItem');
+
+var _getCurrentItem2 = _interopRequireDefault(_getCurrentItem);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Return the previous item, from current selection or from a node.
+ */
+function getPreviousItem(opts, value, block) {
+    var document = value.document,
+        startBlock = value.startBlock;
+
+    block = block || startBlock;
+
+    var currentItem = (0, _getCurrentItem2.default)(opts, value, block);
+    if (!currentItem) {
+        return null;
+    }
+
+    var previousSibling = document.getPreviousSibling(currentItem.key);
+
+    if (!previousSibling) {
+        return null;
+    } else if (previousSibling.type === opts.typeItem) {
+        return previousSibling;
+    }
+    return null;
+}
+
+exports.default = getPreviousItem;

package/configure/node_modules/slate-edit-list/dist/utils/getPreviousItem.js.flow

@@ -0,0 +1,29 @@
+// @flow
+import { type Value, type Block } from 'slate';
+
+import type Options from '../options';
+import getCurrentItem from './getCurrentItem';
+
+/**
+ * Return the previous item, from current selection or from a node.
+ */
+function getPreviousItem(opts: Options, value: Value, block?: Block): ?Block {
+    const { document, startBlock } = value;
+    block = block || startBlock;
+
+    const currentItem = getCurrentItem(opts, value, block);
+    if (!currentItem) {
+        return null;
+    }
+
+    const previousSibling = document.getPreviousSibling(currentItem.key);
+
+    if (!previousSibling) {
+        return null;
+    } else if (previousSibling.type === opts.typeItem) {
+        return previousSibling;
+    }
+    return null;
+}
+
+export default getPreviousItem;

package/configure/node_modules/slate-edit-list/dist/utils/index.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.isSelectionInList = exports.isList = exports.getPreviousItem = exports.getListForItem = exports.getItemsAtRange = exports.getItemDepth = exports.getCurrentList = exports.getCurrentItem = undefined;
+
+var _getCurrentItem = require('./getCurrentItem');
+
+var _getCurrentItem2 = _interopRequireDefault(_getCurrentItem);
+
+var _getCurrentList = require('./getCurrentList');
+
+var _getCurrentList2 = _interopRequireDefault(_getCurrentList);
+
+var _getItemDepth = require('./getItemDepth');
+
+var _getItemDepth2 = _interopRequireDefault(_getItemDepth);
+
+var _getItemsAtRange = require('./getItemsAtRange');
+
+var _getItemsAtRange2 = _interopRequireDefault(_getItemsAtRange);
+
+var _getListForItem = require('./getListForItem');
+
+var _getListForItem2 = _interopRequireDefault(_getListForItem);
+
+var _getPreviousItem = require('./getPreviousItem');
+
+var _getPreviousItem2 = _interopRequireDefault(_getPreviousItem);
+
+var _isList = require('./isList');
+
+var _isList2 = _interopRequireDefault(_isList);
+
+var _isSelectionInList = require('./isSelectionInList');
+
+var _isSelectionInList2 = _interopRequireDefault(_isSelectionInList);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.getCurrentItem = _getCurrentItem2.default;
+exports.getCurrentList = _getCurrentList2.default;
+exports.getItemDepth = _getItemDepth2.default;
+exports.getItemsAtRange = _getItemsAtRange2.default;
+exports.getListForItem = _getListForItem2.default;
+exports.getPreviousItem = _getPreviousItem2.default;
+exports.isList = _isList2.default;
+exports.isSelectionInList = _isSelectionInList2.default;

package/configure/node_modules/slate-edit-list/dist/utils/index.js.flow

@@ -0,0 +1,19 @@
+import getCurrentItem from './getCurrentItem';
+import getCurrentList from './getCurrentList';
+import getItemDepth from './getItemDepth';
+import getItemsAtRange from './getItemsAtRange';
+import getListForItem from './getListForItem';
+import getPreviousItem from './getPreviousItem';
+import isList from './isList';
+import isSelectionInList from './isSelectionInList';
+
+export {
+    getCurrentItem,
+    getCurrentList,
+    getItemDepth,
+    getItemsAtRange,
+    getListForItem,
+    getPreviousItem,
+    isList,
+    isSelectionInList
+};

package/configure/node_modules/slate-edit-list/dist/utils/isList.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require('slate');
+
+/**
+ * True if the node is a list container
+ */
+function isList(opts, node) {
+  return opts.types.includes(node.type);
+}
+exports.default = isList;

package/configure/node_modules/slate-edit-list/dist/utils/isList.js.flow

@@ -0,0 +1,13 @@
+// @flow
+import { type Node } from 'slate';
+
+import type Options from '../options';
+
+/**
+ * True if the node is a list container
+ */
+function isList(opts: Options, node: Node): boolean {
+    return opts.types.includes(node.type);
+}
+
+export default isList;

package/configure/node_modules/slate-edit-list/dist/utils/isSelectionInList.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require('slate');
+
+var _getItemsAtRange = require('./getItemsAtRange');
+
+var _getItemsAtRange2 = _interopRequireDefault(_getItemsAtRange);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * True if selection is inside a list (and can be unwrapped)
+ */
+function isSelectionInList(opts, value) {
+  return !(0, _getItemsAtRange2.default)(opts, value).isEmpty();
+}
+
+exports.default = isSelectionInList;

package/configure/node_modules/slate-edit-list/dist/utils/isSelectionInList.js.flow

@@ -0,0 +1,14 @@
+// @flow
+import { type Value } from 'slate';
+
+import type Options from '../options';
+import getItemsAtRange from './getItemsAtRange';
+
+/**
+ * True if selection is inside a list (and can be unwrapped)
+ */
+function isSelectionInList(opts: Options, value: Value): boolean {
+    return !getItemsAtRange(opts, value).isEmpty();
+}
+
+export default isSelectionInList;

package/configure/node_modules/slate-edit-list/dist/validation/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateNode = exports.schema = undefined;
+
+var _schema = require('./schema');
+
+var _schema2 = _interopRequireDefault(_schema);
+
+var _validateNode = require('./validateNode');
+
+var _validateNode2 = _interopRequireDefault(_validateNode);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.schema = _schema2.default;
+exports.validateNode = _validateNode2.default;

package/configure/node_modules/slate-edit-list/dist/validation/index.js.flow

@@ -0,0 +1,4 @@
+import schema from './schema';
+import validateNode from './validateNode';
+
+export { schema, validateNode };