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

package/configure/node_modules/slate-edit-list/dist/changes/wrapInList.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _slate = require('slate');
+
+var _immutable = require('immutable');
+
+var _utils = require('../utils');
+
+/**
+ * Wrap the blocks in the current selection in a new list. Selected
+ * lists are merged together.
+ */
+function wrapInList(opts, change, type, data) {
+    var selectedBlocks = getHighestSelectedBlocks(change.value);
+    type = type || opts.types[0];
+
+    // Wrap in container
+    change.wrapBlock({
+        type: type,
+        data: _slate.Data.create(data)
+    }, { normalize: false });
+
+    // Wrap in list items
+    selectedBlocks.forEach(function (node) {
+        if ((0, _utils.isList)(opts, node)) {
+            // Merge its items with the created list
+            node.nodes.forEach(function (_ref) {
+                var key = _ref.key;
+                return change.unwrapNodeByKey(key, { normalize: false });
+            });
+        } else {
+            change.wrapBlockByKey(node.key, opts.typeItem, {
+                normalize: false
+            });
+        }
+    });
+
+    return change.normalize();
+}
+
+/**
+ * Returns the highest list of blocks that cover the current selection
+ */
+
+function getHighestSelectedBlocks(value) {
+    var range = value.selection;
+    var document = value.document;
+
+
+    var startBlock = document.getClosestBlock(range.startKey);
+    var endBlock = document.getClosestBlock(range.endKey);
+
+    if (startBlock === endBlock) {
+        return (0, _immutable.List)([startBlock]);
+    }
+    var ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);
+    var startPath = ancestor.getPath(startBlock.key);
+    var endPath = ancestor.getPath(endBlock.key);
+
+    return ancestor.nodes.slice(startPath[0], endPath[0] + 1);
+}
+
+exports.default = wrapInList;

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

@@ -0,0 +1,67 @@
+// @flow
+import { Data, type Value, type Change, type Block } from 'slate';
+import { List } from 'immutable';
+
+import type Options from '../options';
+import { isList } from '../utils';
+
+/**
+ * Wrap the blocks in the current selection in a new list. Selected
+ * lists are merged together.
+ */
+function wrapInList(
+    opts: Options,
+    change: Change,
+    type?: string,
+    data?: Object | Data
+): Change {
+    const selectedBlocks = getHighestSelectedBlocks(change.value);
+    type = type || opts.types[0];
+
+    // Wrap in container
+    change.wrapBlock(
+        {
+            type,
+            data: Data.create(data)
+        },
+        { normalize: false }
+    );
+
+    // Wrap in list items
+    selectedBlocks.forEach(node => {
+        if (isList(opts, node)) {
+            // Merge its items with the created list
+            node.nodes.forEach(({ key }) =>
+                change.unwrapNodeByKey(key, { normalize: false })
+            );
+        } else {
+            change.wrapBlockByKey(node.key, opts.typeItem, {
+                normalize: false
+            });
+        }
+    });
+
+    return change.normalize();
+}
+
+/**
+ * Returns the highest list of blocks that cover the current selection
+ */
+function getHighestSelectedBlocks(value: Value): List<Block> {
+    const range = value.selection;
+    const { document } = value;
+
+    const startBlock = document.getClosestBlock(range.startKey);
+    const endBlock = document.getClosestBlock(range.endKey);
+
+    if (startBlock === endBlock) {
+        return List([startBlock]);
+    }
+    const ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);
+    const startPath = ancestor.getPath(startBlock.key);
+    const endPath = ancestor.getPath(endBlock.key);
+
+    return ancestor.nodes.slice(startPath[0], endPath[0] + 1);
+}
+
+export default wrapInList;

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

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _options = require('./options');
+
+var _options2 = _interopRequireDefault(_options);
+
+var _validation = require('./validation');
+
+var _changes = require('./changes');
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+/**
+ * Returns the core of the plugin, limited to the validation and normalization
+ * part of `slate-edit-list`, and utils.
+ *
+ * Import this directly: `import EditListCore from 'slate-edit-table/lib/core'`
+ * if you don't care about behavior/rendering and you
+ * are only manipulating `Slate.Values` without rendering them.
+ * That way you do not depend on importing `slate-react`.
+ */
+function core() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    opts = new _options2.default(opts);
+
+    return {
+        schema: (0, _validation.schema)(opts),
+        validateNode: (0, _validation.validateNode)(opts),
+
+        utils: {
+            getCurrentItem: _utils.getCurrentItem.bind(null, opts),
+            getCurrentList: _utils.getCurrentList.bind(null, opts),
+            getItemDepth: _utils.getItemDepth.bind(null, opts),
+            getItemsAtRange: _utils.getItemsAtRange.bind(null, opts),
+            getPreviousItem: _utils.getPreviousItem.bind(null, opts),
+            isList: _utils.isList.bind(null, opts),
+            isSelectionInList: _utils.isSelectionInList.bind(null, opts)
+        },
+
+        changes: {
+            decreaseItemDepth: bindAndScopeChange(opts, _changes.decreaseItemDepth),
+            increaseItemDepth: bindAndScopeChange(opts, _changes.increaseItemDepth),
+            splitListItem: bindAndScopeChange(opts, _changes.splitListItem),
+            unwrapList: bindAndScopeChange(opts, _changes.unwrapList),
+            wrapInList: _changes.wrapInList.bind(null, opts)
+        }
+    };
+}
+
+/**
+ * Bind a change to given options, and scope it to act only inside a list
+ */
+function bindAndScopeChange(opts, fn) {
+    return function (change) {
+        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            args[_key - 1] = arguments[_key];
+        }
+
+        var value = change.value;
+
+
+        if (!(0, _utils.isSelectionInList)(opts, value)) {
+            return change;
+        }
+
+        // $FlowFixMe
+        return fn.apply(undefined, _toConsumableArray([opts, change].concat(args)));
+    };
+}
+
+exports.default = core;

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

@@ -0,0 +1,76 @@
+// @flow
+import Options, { type OptionsFormat } from './options';
+import { schema, validateNode } from './validation';
+import {
+    wrapInList,
+    unwrapList,
+    splitListItem,
+    increaseItemDepth,
+    decreaseItemDepth
+} from './changes';
+import {
+    getItemDepth,
+    isList,
+    isSelectionInList,
+    getCurrentItem,
+    getCurrentList,
+    getItemsAtRange,
+    getPreviousItem
+} from './utils';
+
+/**
+ * Returns the core of the plugin, limited to the validation and normalization
+ * part of `slate-edit-list`, and utils.
+ *
+ * Import this directly: `import EditListCore from 'slate-edit-table/lib/core'`
+ * if you don't care about behavior/rendering and you
+ * are only manipulating `Slate.Values` without rendering them.
+ * That way you do not depend on importing `slate-react`.
+ */
+function core(
+    // Options for the plugin
+    opts: OptionsFormat = {}
+): Object {
+    opts = new Options(opts);
+
+    return {
+        schema: schema(opts),
+        validateNode: validateNode(opts),
+
+        utils: {
+            getCurrentItem: getCurrentItem.bind(null, opts),
+            getCurrentList: getCurrentList.bind(null, opts),
+            getItemDepth: getItemDepth.bind(null, opts),
+            getItemsAtRange: getItemsAtRange.bind(null, opts),
+            getPreviousItem: getPreviousItem.bind(null, opts),
+            isList: isList.bind(null, opts),
+            isSelectionInList: isSelectionInList.bind(null, opts)
+        },
+
+        changes: {
+            decreaseItemDepth: bindAndScopeChange(opts, decreaseItemDepth),
+            increaseItemDepth: bindAndScopeChange(opts, increaseItemDepth),
+            splitListItem: bindAndScopeChange(opts, splitListItem),
+            unwrapList: bindAndScopeChange(opts, unwrapList),
+            wrapInList: wrapInList.bind(null, opts)
+        }
+    };
+}
+
+/**
+ * Bind a change to given options, and scope it to act only inside a list
+ */
+function bindAndScopeChange(opts: Options, fn: *): * {
+    return (change, ...args) => {
+        const { value } = change;
+
+        if (!isSelectionInList(opts, value)) {
+            return change;
+        }
+
+        // $FlowFixMe
+        return fn(...[opts, change].concat(args));
+    };
+}
+
+export default core;

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

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onBackspace = exports.onTab = exports.onEnter = undefined;
+
+var _onEnter = require('./onEnter');
+
+var _onEnter2 = _interopRequireDefault(_onEnter);
+
+var _onTab = require('./onTab');
+
+var _onTab2 = _interopRequireDefault(_onTab);
+
+var _onBackspace = require('./onBackspace');
+
+var _onBackspace2 = _interopRequireDefault(_onBackspace);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.onEnter = _onEnter2.default;
+exports.onTab = _onTab2.default;
+exports.onBackspace = _onBackspace2.default;

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

@@ -0,0 +1,5 @@
+import onEnter from './onEnter';
+import onTab from './onTab';
+import onBackspace from './onBackspace';
+
+export { onEnter, onTab, onBackspace };

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;