@pie-element/ebsr 6.6.3-next.264 → 6.6.3-next.280

package/configure/node_modules/slate-edit-list/dist/handlers/onBackspace.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _changes = require('../changes');
+
+var _utils = require('../utils');
+
+/**
+ * User pressed Delete in an editor
+ */
+function onBackspace(event, change, editor, opts) {
+    var value = change.value;
+    var startOffset = value.startOffset,
+        selection = value.selection;
+
+    // Only unwrap...
+    // ... with a collapsed selection
+
+    if (selection.isExpanded) {
+        return undefined;
+    }
+
+    // ... when at the beginning of nodes
+    if (startOffset > 0) {
+        return undefined;
+    }
+    // ... in a list
+    var currentItem = (0, _utils.getCurrentItem)(opts, value);
+    if (!currentItem) {
+        return undefined;
+    }
+    // ... more precisely at the beginning of the current item
+    if (!selection.isAtStartOf(currentItem)) {
+        return undefined;
+    }
+
+    event.preventDefault();
+    return (0, _changes.unwrapList)(opts, change);
+}
+exports.default = onBackspace;

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

@@ -0,0 +1,44 @@
+// @flow
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import { unwrapList } from '../changes';
+import { getCurrentItem } from '../utils';
+
+/**
+ * User pressed Delete in an editor
+ */
+function onBackspace(
+    event: *,
+    change: Change,
+    editor: *,
+    opts: Options
+): void | any {
+    const { value } = change;
+    const { startOffset, selection } = value;
+
+    // Only unwrap...
+    // ... with a collapsed selection
+    if (selection.isExpanded) {
+        return undefined;
+    }
+
+    // ... when at the beginning of nodes
+    if (startOffset > 0) {
+        return undefined;
+    }
+    // ... in a list
+    const currentItem = getCurrentItem(opts, value);
+    if (!currentItem) {
+        return undefined;
+    }
+    // ... more precisely at the beginning of the current item
+    if (!selection.isAtStartOf(currentItem)) {
+        return undefined;
+    }
+
+    event.preventDefault();
+    return unwrapList(opts, change);
+}
+
+export default onBackspace;

package/configure/node_modules/slate-edit-list/dist/handlers/onEnter.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _changes = require('../changes');
+
+var _utils = require('../utils');
+
+/**
+ * User pressed Enter in an editor
+ *
+ * Enter in a list item should split the list item
+ * Enter in an empty list item should remove it
+ * Shift+Enter in a list item should make a new line
+ */
+function onEnter(event, change, editor, opts) {
+    // Pressing Shift+Enter
+    // should split block normally
+    if (event.shiftKey) {
+        return undefined;
+    }
+
+    var value = change.value;
+
+    var currentItem = (0, _utils.getCurrentItem)(opts, value);
+
+    // Not in a list
+    if (!currentItem) {
+        return undefined;
+    }
+
+    event.preventDefault();
+
+    // If expanded, delete first.
+    if (value.isExpanded) {
+        change.delete();
+    }
+
+    if (currentItem.isEmpty) {
+        // Block is empty, we exit the list
+        if ((0, _utils.getItemDepth)(opts, value) > 1) {
+            return (0, _changes.decreaseItemDepth)(opts, change);
+        }
+        // Exit list
+        return (0, _changes.unwrapList)(opts, change);
+    }
+    // Split list item
+    return (0, _changes.splitListItem)(opts, change);
+}
+exports.default = onEnter;

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

@@ -0,0 +1,54 @@
+// @flow
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import { unwrapList, splitListItem, decreaseItemDepth } from '../changes';
+import { getCurrentItem, getItemDepth } from '../utils';
+
+/**
+ * User pressed Enter in an editor
+ *
+ * Enter in a list item should split the list item
+ * Enter in an empty list item should remove it
+ * Shift+Enter in a list item should make a new line
+ */
+function onEnter(
+    event: *,
+    change: Change,
+    editor: *,
+    opts: Options
+): void | any {
+    // Pressing Shift+Enter
+    // should split block normally
+    if (event.shiftKey) {
+        return undefined;
+    }
+
+    const { value } = change;
+    const currentItem = getCurrentItem(opts, value);
+
+    // Not in a list
+    if (!currentItem) {
+        return undefined;
+    }
+
+    event.preventDefault();
+
+    // If expanded, delete first.
+    if (value.isExpanded) {
+        change.delete();
+    }
+
+    if (currentItem.isEmpty) {
+        // Block is empty, we exit the list
+        if (getItemDepth(opts, value) > 1) {
+            return decreaseItemDepth(opts, change);
+        }
+        // Exit list
+        return unwrapList(opts, change);
+    }
+    // Split list item
+    return splitListItem(opts, change);
+}
+
+export default onEnter;

package/configure/node_modules/slate-edit-list/dist/handlers/onTab.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _changes = require('../changes');
+
+var _utils = require('../utils');
+
+/**
+ * User pressed Tab in an editor.
+ * Tab       -> Increase item depth if inside a list item
+ * Shift+Tab -> Decrease item depth if inside a list item
+ */
+function onTab(event, change, editor, opts) {
+    var value = change.value;
+    var isCollapsed = value.isCollapsed;
+
+
+    if (!isCollapsed || !(0, _utils.getCurrentItem)(opts, value)) {
+        return undefined;
+    }
+
+    // Shift+tab reduce depth
+    if (event.shiftKey) {
+        event.preventDefault();
+
+        return (0, _changes.decreaseItemDepth)(opts, change);
+    }
+
+    // Tab increases depth
+    event.preventDefault();
+
+    return (0, _changes.increaseItemDepth)(opts, change);
+}
+exports.default = onTab;

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

@@ -0,0 +1,34 @@
+// @flow
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import { decreaseItemDepth, increaseItemDepth } from '../changes';
+import { getCurrentItem } from '../utils';
+
+/**
+ * User pressed Tab in an editor.
+ * Tab       -> Increase item depth if inside a list item
+ * Shift+Tab -> Decrease item depth if inside a list item
+ */
+function onTab(event: *, change: Change, editor: *, opts: Options): void | any {
+    const { value } = change;
+    const { isCollapsed } = value;
+
+    if (!isCollapsed || !getCurrentItem(opts, value)) {
+        return undefined;
+    }
+
+    // Shift+tab reduce depth
+    if (event.shiftKey) {
+        event.preventDefault();
+
+        return decreaseItemDepth(opts, change);
+    }
+
+    // Tab increases depth
+    event.preventDefault();
+
+    return increaseItemDepth(opts, change);
+}
+
+export default onTab;

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

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _options = require('./options');
+
+var _options2 = _interopRequireDefault(_options);
+
+var _handlers = require('./handlers');
+
+var _core = require('./core');
+
+var _core2 = _interopRequireDefault(_core);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var KEY_ENTER = 'Enter';
+var KEY_TAB = 'Tab';
+var KEY_BACKSPACE = 'Backspace';
+
+/**
+ * A Slate plugin to handle keyboard events in lists.
+ */
+function EditList() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    opts = new _options2.default(opts);
+    var corePlugin = (0, _core2.default)(opts);
+
+    return _extends({}, corePlugin, {
+
+        onKeyDown: onKeyDown.bind(null, opts)
+    });
+}
+
+/**
+ * User is pressing a key in the editor
+ */
+function onKeyDown(opts, event, change, editor) {
+    var args = [event, change, editor, opts];
+
+    switch (event.key) {
+        case KEY_ENTER:
+            return _handlers.onEnter.apply(undefined, args);
+        case KEY_TAB:
+            return _handlers.onTab.apply(undefined, args);
+        case KEY_BACKSPACE:
+            return _handlers.onBackspace.apply(undefined, args);
+        default:
+            return undefined;
+    }
+}
+
+exports.default = EditList;

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;