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

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

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _slate = require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Increase the depth of the current item by putting it in a sub-list
+ * of previous item.
+ * For first items in a list, does nothing.
+ */
+function increaseItemDepth(opts, change) {
+    var previousItem = (0, _utils.getPreviousItem)(opts, change.value);
+    var currentItem = (0, _utils.getCurrentItem)(opts, change.value);
+
+    if (!previousItem) {
+        return change;
+    }
+
+    if (!currentItem) {
+        return change;
+    }
+
+    // Move the item in the sublist of previous item
+    return moveAsSubItem(opts, change, currentItem, previousItem.key);
+}
+
+/**
+ * Move the given item to the sublist at the end of destination item,
+ * creating a sublist if needed.
+ */
+function moveAsSubItem(opts, change,
+// The list item to add
+item,
+// The key of the destination node
+destKey) {
+    var destination = change.value.document.getDescendant(destKey);
+    var lastIndex = destination.nodes.size;
+    var lastChild = destination.nodes.last();
+
+    // The potential existing last child list
+    var existingList = (0, _utils.isList)(opts, lastChild) ? lastChild : null;
+
+    if (existingList) {
+        return change.moveNodeByKey(item.key, existingList.key, existingList.nodes.size // as last item
+        );
+    }
+    var currentList = (0, _utils.getListForItem)(opts, change.value, destination);
+    if (!currentList) {
+        throw new Error('Destination is not in a list');
+    }
+
+    var newSublist = _slate.Block.create({
+        object: 'block',
+        type: currentList.type,
+        data: currentList.data
+    });
+
+    change.insertNodeByKey(destKey, lastIndex, newSublist, {
+        normalize: false
+    });
+
+    return change.moveNodeByKey(item.key, newSublist.key, 0);
+}
+
+exports.default = increaseItemDepth;

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

@@ -0,0 +1,77 @@
+// @flow
+import { Block, type Change } from 'slate';
+
+import type Options from '../options';
+import {
+    getPreviousItem,
+    getCurrentItem,
+    getListForItem,
+    isList
+} from '../utils';
+
+/**
+ * Increase the depth of the current item by putting it in a sub-list
+ * of previous item.
+ * For first items in a list, does nothing.
+ */
+function increaseItemDepth(opts: Options, change: Change): Change {
+    const previousItem = getPreviousItem(opts, change.value);
+    const currentItem = getCurrentItem(opts, change.value);
+
+    if (!previousItem) {
+        return change;
+    }
+
+    if (!currentItem) {
+        return change;
+    }
+
+    // Move the item in the sublist of previous item
+    return moveAsSubItem(opts, change, currentItem, previousItem.key);
+}
+
+/**
+ * Move the given item to the sublist at the end of destination item,
+ * creating a sublist if needed.
+ */
+function moveAsSubItem(
+    opts: Options,
+    change: Change,
+    // The list item to add
+    item: Block,
+    // The key of the destination node
+    destKey: string
+): Change {
+    const destination = change.value.document.getDescendant(destKey);
+    const lastIndex = destination.nodes.size;
+    const lastChild = destination.nodes.last();
+
+    // The potential existing last child list
+    const existingList = isList(opts, lastChild) ? lastChild : null;
+
+    if (existingList) {
+        return change.moveNodeByKey(
+            item.key,
+            existingList.key,
+            existingList.nodes.size // as last item
+        );
+    }
+    const currentList = getListForItem(opts, change.value, destination);
+    if (!currentList) {
+        throw new Error('Destination is not in a list');
+    }
+
+    const newSublist = Block.create({
+        object: 'block',
+        type: currentList.type,
+        data: currentList.data
+    });
+
+    change.insertNodeByKey(destKey, lastIndex, newSublist, {
+        normalize: false
+    });
+
+    return change.moveNodeByKey(item.key, newSublist.key, 0);
+}
+
+export default increaseItemDepth;

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

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.decreaseItemDepth = exports.increaseItemDepth = exports.splitListItem = exports.unwrapList = exports.wrapInList = undefined;
+
+var _wrapInList = require('./wrapInList');
+
+var _wrapInList2 = _interopRequireDefault(_wrapInList);
+
+var _unwrapList = require('./unwrapList');
+
+var _unwrapList2 = _interopRequireDefault(_unwrapList);
+
+var _splitListItem = require('./splitListItem');
+
+var _splitListItem2 = _interopRequireDefault(_splitListItem);
+
+var _increaseItemDepth = require('./increaseItemDepth');
+
+var _increaseItemDepth2 = _interopRequireDefault(_increaseItemDepth);
+
+var _decreaseItemDepth = require('./decreaseItemDepth');
+
+var _decreaseItemDepth2 = _interopRequireDefault(_decreaseItemDepth);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.wrapInList = _wrapInList2.default;
+exports.unwrapList = _unwrapList2.default;
+exports.splitListItem = _splitListItem2.default;
+exports.increaseItemDepth = _increaseItemDepth2.default;
+exports.decreaseItemDepth = _decreaseItemDepth2.default;

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

@@ -0,0 +1,13 @@
+import wrapInList from './wrapInList';
+import unwrapList from './unwrapList';
+import splitListItem from './splitListItem';
+import increaseItemDepth from './increaseItemDepth';
+import decreaseItemDepth from './decreaseItemDepth';
+
+export {
+    wrapInList,
+    unwrapList,
+    splitListItem,
+    increaseItemDepth,
+    decreaseItemDepth
+};

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

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Split a list item at the start of the current range.
+ */
+function splitListItem(opts, change) {
+    var value = change.value;
+
+    var currentItem = (0, _utils.getCurrentItem)(opts, value);
+    if (!currentItem) {
+        return change;
+    }
+
+    var splitOffset = value.startOffset;
+
+    return change.splitDescendantsByKey(currentItem.key, value.startKey, splitOffset);
+}
+
+exports.default = splitListItem;

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

@@ -0,0 +1,26 @@
+// @flow
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import { getCurrentItem } from '../utils';
+
+/**
+ * Split a list item at the start of the current range.
+ */
+function splitListItem(opts: Options, change: Change): Change {
+    const { value } = change;
+    const currentItem = getCurrentItem(opts, value);
+    if (!currentItem) {
+        return change;
+    }
+
+    const splitOffset = value.startOffset;
+
+    return change.splitDescendantsByKey(
+        currentItem.key,
+        value.startKey,
+        splitOffset
+    );
+}
+
+export default splitListItem;

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

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Unwrap items at range from their list.
+ */
+function unwrapList(opts, change) {
+    var items = (0, _utils.getItemsAtRange)(opts, change.value);
+
+    if (items.isEmpty()) {
+        return change;
+    }
+
+    // Unwrap the items from their list
+    items.forEach(function (item) {
+        return change.unwrapNodeByKey(item.key, { normalize: false });
+    });
+
+    // Parent of the list of the items
+    var firstItem = items.first();
+    var parent = change.value.document.getParent(firstItem.key);
+
+    var index = parent.nodes.findIndex(function (node) {
+        return node.key === firstItem.key;
+    });
+
+    // Unwrap the items' children
+    items.forEach(function (item) {
+        item.nodes.forEach(function (node) {
+            change.moveNodeByKey(node.key, parent.key, index, {
+                normalize: false
+            });
+            index += 1;
+        });
+    });
+
+    // Finally, remove the now empty items
+    items.forEach(function (item) {
+        return change.removeNodeByKey(item.key, { normalize: false });
+    });
+
+    return change;
+}
+
+exports.default = unwrapList;

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

@@ -0,0 +1,46 @@
+// @flow
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import { getItemsAtRange } from '../utils';
+
+/**
+ * Unwrap items at range from their list.
+ */
+function unwrapList(opts: Options, change: Change): Change {
+    const items = getItemsAtRange(opts, change.value);
+
+    if (items.isEmpty()) {
+        return change;
+    }
+
+    // Unwrap the items from their list
+    items.forEach(item =>
+        change.unwrapNodeByKey(item.key, { normalize: false })
+    );
+
+    // Parent of the list of the items
+    const firstItem = items.first();
+    const parent = change.value.document.getParent(firstItem.key);
+
+    let index = parent.nodes.findIndex(node => node.key === firstItem.key);
+
+    // Unwrap the items' children
+    items.forEach(item => {
+        item.nodes.forEach(node => {
+            change.moveNodeByKey(node.key, parent.key, index, {
+                normalize: false
+            });
+            index += 1;
+        });
+    });
+
+    // Finally, remove the now empty items
+    items.forEach(item =>
+        change.removeNodeByKey(item.key, { normalize: false })
+    );
+
+    return change;
+}
+
+export default unwrapList;

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