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

package/configure/node_modules/slate-edit-list/README.md

@@ -0,0 +1,159 @@
+# slate-edit-list
+
+[![NPM version](https://badge.fury.io/js/slate-edit-list.svg)](http://badge.fury.io/js/slate-edit-list)
+[![Linux Build Status](https://travis-ci.org/GitbookIO/slate-edit-list.png?branch=master)](https://travis-ci.org/GitbookIO/slate-edit-list)
+
+A Slate plugin to handle keyboard events in lists. List items can contain blocks.
+
+Demo: [gitbookio.github.io/slate-edit-list/](https://gitbookio.github.io/slate-edit-list/)
+
+### Install
+
+```
+npm install slate-edit-list
+```
+
+### Features
+
+Natural keybindings:
+
+- Pressing <kbd>Enter</kbd> insert a new list item
+- Pressing <kbd>Shift+Enter</kbd> split the block in the list item
+- Pressing <kbd>Tab</kbd> increase the depth of the item (creates a sub-list)
+- Pressing <kbd>Shift+Tab</kbd> decrease the depth of the item
+- Pressing <kbd>Delete</kbd> (OSX) or <kbd>Backspace</kbd> at the start, remove the list item (or the list)
+
+Simple validation/normalization (see [assumptions about the schema](#assumption-about-the-schema)):
+
+- Lists can contain only list items, and at least one.
+- List items can only be the direct children of a list.
+- List items must always contain blocks.
+
+Useful transforms: see [Utilities and Transform](#utilities-and-transform).
+
+### Simple Usage
+
+```js
+import EditList from 'slate-edit-list'
+
+const plugins = [
+  EditList()
+]
+```
+
+#### Arguments
+
+This plugin accepts options to redefine the following block types:
+
+- `<String> types=["ol_list", "ul_list"]` — the array of possible types for list containers. First value will be used as default.
+- `<String> typeItem="list_item"` — type for list items.
+- `<String> typeDefault="paragraph"` — type for default block in list items.
+
+#### Assumption about the schema
+
+You can use this plugins with custom list block types (using plugin [arguments](#arguments)). But your lists structure should still conform to a few rules. These rules are implemented as schema.
+
+Here is what a minimal list would look like:
+
+
+```yaml
+nodes:
+    - kind: block
+      type: ul_list # Default type for bulleted lists container
+      nodes:
+          - kind: block
+            type: list_item # List containers can only contain list items
+            nodes:
+              # List items contain blocks. They cannot be the direct container of text.
+              - kind: block
+                type: paragraph # Default type of blocks in a list item
+                nodes:
+                  - kind: text
+                    text: Hello World
+```
+
+And here is an example of a multi-level list:
+
+```yaml
+nodes:
+  - kind: block
+    type: ol_list
+    nodes:
+      - kind: block
+        type: list_item
+        nodes:
+          - kind: block
+            type: paragraph
+            nodes:
+              - kind: text
+                text: Item 1
+          - kind: block
+            type: ol_list
+            nodes:
+              - kind: block
+                type: list_item
+                nodes:
+                  - kind: block
+                    type: paragraph
+                    nodes:
+                      - kind: text
+                        text: Item 1.1
+              - kind: block
+                type: list_item
+                nodes:
+                  - kind: block
+                    type: paragraph
+                    nodes:
+                      - kind: text
+                        text: Item 1.2
+```
+
+### Utilities and Transform
+
+`slate-edit-list` exports utilities and transforms:
+
+#### `plugin.utils.isSelectionInList(state: State) => Boolean`
+
+Return true if selection is inside a list (and it can be unwrap).
+
+#### `plugin.utils.isList(node: Node) => Boolean`
+
+Return true if the node is one of the list type.
+
+#### `plugin.utils.getItemDepth(state: State, block: Block?) => Number`
+
+Returns the depth of the current item (or the depth of the given block) in a list. 0 means not in a list.
+
+#### `plugin.utils.getCurrentItem(state: State, block: Block?) => Block || Void`
+
+Returns the current item at selection (or at the given block).
+
+#### `plugin.utils.getCurrentList(state: State, block: Block?) => Block || Void`
+
+Returns the current list at selection (or at the given block).
+
+#### `plugin.utils.getItemsAtRange(state: State, range: Selection?) => List<Node>`
+
+Return the list of items at the given range. The returned items are the highest list of of successive items that cover the given range.
+
+The returned list is empty if no such list can be found.
+
+#### `plugin.changes.increaseItemDepth(transform: Transform) => Transform`
+
+Increase the depth of the current item.
+
+#### `plugin.changes.decreaseItemDepth(transform: Transform) => Transform`
+
+Decrease the depth of the current item.
+
+#### `plugin.changes.wrapInList(transform: Transform, type: String?, data: Object|Data?) => Transform`
+
+Wrap the current blocks in list items of a list container of the given type. You can pass optional data for the created list container.
+
+#### `plugin.changes.unwrapList(transform: Transform) => Transform`
+
+Unwrap all items at range from their list.
+
+#### `plugin.changes.splitListItem(transform: Transform) => Transform`
+
+Split current block into a new list item.

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

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _slate = require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Decreases the depth of the current item. The following items will
+ * be moved as sublist of the decreased item.
+ *
+ * No-op for root items.
+ */
+function decreaseItemDepth(opts, change) {
+    var value = change.value;
+    var document = value.document;
+
+    // Cannot decrease item depth of root items
+
+    var depth = (0, _utils.getItemDepth)(opts, value);
+    if (depth == 1) {
+        return change;
+    }
+
+    var currentItem = (0, _utils.getCurrentItem)(opts, value);
+    if (!currentItem) {
+        return change;
+    }
+
+    var currentList = document.getParent(currentItem.key);
+    var parentItem = document.getParent(currentList.key);
+    var parentList = document.getParent(parentItem.key);
+    // The items following the item will be moved to a sublist of currentItem
+    var followingItems = currentList.nodes.skipUntil(function (i) {
+        return i === currentItem;
+    }).rest();
+
+    // True if the currentItem and the followingItems make the whole
+    // currentList, and hence the currentList will be emptied
+    var willEmptyCurrentList = currentList.nodes.size === followingItems.size + 1;
+
+    if (!followingItems.isEmpty()) {
+        // Add them as sublist of currentItem
+        var sublist = _slate.Block.create({
+            object: 'block',
+            type: currentList.type,
+            data: currentList.data
+        });
+        // Add the sublist
+        change.insertNodeByKey(currentItem.key, currentItem.nodes.size, sublist, { normalize: false });
+
+        change.moveNodeByKey(currentItem.key, parentList.key, parentList.nodes.indexOf(parentItem) + 1, { normalize: false });
+
+        // Move the followingItems to the sublist
+        followingItems.forEach(function (item, index) {
+            return change.moveNodeByKey(item.key, sublist.key, sublist.nodes.size + index, { normalize: false });
+        });
+    } else {
+        change.moveNodeByKey(currentItem.key, parentList.key, parentList.nodes.indexOf(parentItem) + 1);
+    }
+
+    // Remove the currentList completely if needed
+    if (willEmptyCurrentList) {
+        change.removeNodeByKey(currentList.key);
+    }
+
+    return change;
+}
+
+exports.default = decreaseItemDepth;

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

@@ -0,0 +1,88 @@
+// @flow
+import { Block, type Change } from 'slate';
+
+import type Options from '../options';
+import { getItemDepth, getCurrentItem } from '../utils';
+
+/**
+ * Decreases the depth of the current item. The following items will
+ * be moved as sublist of the decreased item.
+ *
+ * No-op for root items.
+ */
+function decreaseItemDepth(opts: Options, change: Change): Change {
+    const { value } = change;
+    const { document } = value;
+
+    // Cannot decrease item depth of root items
+    const depth = getItemDepth(opts, value);
+    if (depth == 1) {
+        return change;
+    }
+
+    const currentItem = getCurrentItem(opts, value);
+    if (!currentItem) {
+        return change;
+    }
+
+    const currentList = document.getParent(currentItem.key);
+    const parentItem = document.getParent(currentList.key);
+    const parentList = document.getParent(parentItem.key);
+    // The items following the item will be moved to a sublist of currentItem
+    const followingItems = currentList.nodes
+        .skipUntil(i => i === currentItem)
+        .rest();
+
+    // True if the currentItem and the followingItems make the whole
+    // currentList, and hence the currentList will be emptied
+    const willEmptyCurrentList =
+        currentList.nodes.size === followingItems.size + 1;
+
+    if (!followingItems.isEmpty()) {
+        // Add them as sublist of currentItem
+        const sublist = Block.create({
+            object: 'block',
+            type: currentList.type,
+            data: currentList.data
+        });
+        // Add the sublist
+        change.insertNodeByKey(
+            currentItem.key,
+            currentItem.nodes.size,
+            sublist,
+            { normalize: false }
+        );
+
+        change.moveNodeByKey(
+            currentItem.key,
+            parentList.key,
+            parentList.nodes.indexOf(parentItem) + 1,
+            { normalize: false }
+        );
+
+        // Move the followingItems to the sublist
+        followingItems.forEach((item, index) =>
+            change.moveNodeByKey(
+                item.key,
+                sublist.key,
+                sublist.nodes.size + index,
+                { normalize: false }
+            )
+        );
+    } else {
+        change.moveNodeByKey(
+            currentItem.key,
+            parentList.key,
+            parentList.nodes.indexOf(parentItem) + 1
+        );
+    }
+
+    // Remove the currentList completely if needed
+    if (willEmptyCurrentList) {
+        change.removeNodeByKey(currentList.key);
+    }
+
+    return change;
+}
+
+export default decreaseItemDepth;

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;