slate-edit-list/example/bundle.js

A Slate plugin to handle keyboard events in lists.

(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

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; };
/* global document */
/* eslint-disable import/no-extraneous-dependencies */


var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _reactDom = require('react-dom');

var _reactDom2 = _interopRequireDefault(_reactDom);

var _slateReact = require('slate-react');

var _lib = require('../lib/');

var _lib2 = _interopRequireDefault(_lib);

var _value = require('./value');

var _value2 = _interopRequireDefault(_value);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

var plugin = (0, _lib2.default)();
var plugins = [plugin];

function renderNode(props) {
    var node = props.node,
        attributes = props.attributes,
        children = props.children,
        editor = props.editor;

    var isCurrentItem = plugin.utils.getItemsAtRange(editor.value).contains(node);

    switch (node.type) {
        case 'ul_list':
            return _react2.default.createElement(
                'ul',
                attributes,
                children
            );
        case 'ol_list':
            return _react2.default.createElement(
                'ol',
                attributes,
                children
            );

        case 'list_item':
            return _react2.default.createElement(
                'li',
                _extends({
                    className: isCurrentItem ? 'current-item' : '',
                    title: isCurrentItem ? 'Current Item' : ''
                }, props.attributes),
                props.children
            );

        case 'paragraph':
            return _react2.default.createElement(
                'p',
                attributes,
                children
            );
        case 'heading':
            return _react2.default.createElement(
                'h1',
                attributes,
                children
            );
        default:
            return _react2.default.createElement(
                'p',
                attributes,
                children
            );
    }
}

var Example = function (_React$Component) {
    _inherits(Example, _React$Component);

    function Example() {
        var _ref;

        var _temp, _this, _ret;

        _classCallCheck(this, Example);

        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
        }

        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Example.__proto__ || Object.getPrototypeOf(Example)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
            value: _value2.default
        }, _this.onChange = function (_ref2) {
            var value = _ref2.value;

            _this.setState({
                value: value
            });
        }, _temp), _possibleConstructorReturn(_this, _ret);
    }

    _createClass(Example, [{
        key: 'renderToolbar',
        value: function renderToolbar() {
            var _this2 = this;

            var _plugin$changes = plugin.changes,
                wrapInList = _plugin$changes.wrapInList,
                unwrapList = _plugin$changes.unwrapList,
                increaseItemDepth = _plugin$changes.increaseItemDepth,
                decreaseItemDepth = _plugin$changes.decreaseItemDepth;

            var inList = plugin.utils.isSelectionInList(this.state.value);

            return _react2.default.createElement(
                'div',
                null,
                _react2.default.createElement(
                    'button',
                    {
                        className: inList ? 'active' : '',
                        onClick: function onClick() {
                            return _this2.call(inList ? unwrapList : wrapInList);
                        }
                    },
                    _react2.default.createElement('i', { className: 'fa fa-list-ul fa-lg' })
                ),
                _react2.default.createElement(
                    'button',
                    {
                        className: inList ? '' : 'disabled',
                        onClick: function onClick() {
                            return _this2.call(decreaseItemDepth);
                        }
                    },
                    _react2.default.createElement('i', { className: 'fa fa-outdent fa-lg' })
                ),
                _react2.default.createElement(
                    'button',
                    {
                        className: inList ? '' : 'disabled',
                        onClick: function onClick() {
                            return _this2.call(increaseItemDepth);
                        }
                    },
                    _react2.default.createElement('i', { className: 'fa fa-indent fa-lg' })
                ),
                _react2.default.createElement(
                    'span',
                    { className: 'sep' },
                    '\xB7'
                ),
                _react2.default.createElement(
                    'button',
                    { onClick: function onClick() {
                            return _this2.call(wrapInList);
                        } },
                    'Wrap in list'
                ),
                _react2.default.createElement(
                    'button',
                    { onClick: function onClick() {
                            return _this2.call(unwrapList);
                        } },
                    'Unwrap from list'
                )
            );
        }
    }, {
        key: 'call',
        value: function call(change) {
            this.setState({
                value: this.state.value.change().call(change).value
            });
        }
    }, {
        key: 'render',
        value: function render() {
            return _react2.default.createElement(
                'div',
                null,
                this.renderToolbar(),
                _react2.default.createElement(_slateReact.Editor, {
                    placeholder: 'Enter some text...',
                    plugins: plugins,
                    value: this.state.value,
                    onChange: this.onChange,
                    renderNode: renderNode,
                    shouldNodeComponentUpdate: function shouldNodeComponentUpdate(props) {
                        return (
                            // To update the highlighting of nodes inside the selection
                            props.node.type === 'list_item'
                        );
                    }
                })
            );
        }
    }]);

    return Example;
}(_react2.default.Component);

// $FlowFixMe


_reactDom2.default.render(_react2.default.createElement(Example, null), document.getElementById('example'));

},{"../lib/":14,"./value":2,"react":251,"react-dom":237,"slate-react":270}],2:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _slateHyperscript = require('slate-hyperscript');

var h = (0, _slateHyperscript.createHyperscript)({
    blocks: {
        heading: 'heading',
        paragraph: 'paragraph',
        ul_list: 'ul_list',
        ol_list: 'ol_list',
        list_item: 'list_item'
    }
}); /** @jsx h */
// eslint-disable-next-line import/no-extraneous-dependencies
exports.default = h(
    'value',
    null,
    h(
        'document',
        null,
        h(
            'heading',
            null,
            'Slate + List Edition'
        ),
        h(
            'paragraph',
            null,
            'This page is a basic example of Slate + slate-edit-list plugin. Press Enter in a list to create a new list item. Press Enter again to exit and Shift+Enter to create a paragraph in a list. The items at range are detected and highlighted, for demonstration purpose.'
        ),
        h(
            'ul_list',
            { style: { listStyleType: 'disc' } },
            h(
                'list_item',
                null,
                h(
                    'paragraph',
                    null,
                    'First item in the list'
                )
            ),
            h(
                'list_item',
                null,
                h(
                    'paragraph',
                    null,
                    'List item can contain blocks'
                ),
                h(
                    'heading',
                    null,
                    'Here is a heading'
                ),
                h(
                    'paragraph',
                    null,
                    'And another paragraph'
                )
            ),
            h(
                'list_item',
                null,
                h(
                    'paragraph',
                    null,
                    'Third item in the list, with a nested list'
                ),
                h(
                    'ol_list',
                    { style: { listStyleType: 'decimal' } },
                    h(
                        'list_item',
                        null,
                        h(
                            'paragraph',
                            null,
                            'First item in the nested list'
                        )
                    ),
                    h(
                        'list_item',
                        null,
                        h(
                            'paragraph',
                            null,
                            'Second item in the nested list'
                        )
                    )
                )
            )
        ),
        h(
            'paragraph',
            null,
            'End paragraph'
        )
    )
);

},{"slate-hyperscript":256}],3:[function(require,module,exports){
'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;

},{"../utils":22,"slate":308}],4:[function(require,module,exports){
'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;

},{"../utils":22,"slate":308}],5:[function(require,module,exports){
'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;

},{"./decreaseItemDepth":3,"./increaseItemDepth":4,"./splitListItem":6,"./unwrapList":7,"./wrapInList":8}],6:[function(require,module,exports){
'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;

},{"../utils":22,"slate":308}],7:[function(require,module,exports){
'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;

},{"../utils":22,"slate":308}],8:[function(require,module,exports){
'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;

},{"../utils":22,"immutable":51,"slate":308}],9:[function(require,module,exports){
'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;

},{"./changes":5,"./options":15,"./utils":22,"./validation":25}],10:[function(require,module,exports){
'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;

},{"./onBackspace":11,"./onEnter":12,"./onTab":13}],11:[function(require,module,exports){
'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;

},{"../changes":5,"../utils":22,"slate":308}],12:[function(require,module,exports){
'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;

},{"../changes":5,"../utils":22,"slate":308}],13:[function(require,module,exports){
'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;

},{"../changes":5,"../utils":22,"slate":308}],14:[function(require,module,exports){
'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;

},{"./core":9,"./handlers":10,"./options":15}],15:[function(require,module,exports){
'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;

},{"immutable":51}],16:[function(require,module,exports){
'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;

},{"slate":308}],17:[function(require,module,exports){
'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;

},{"./getCurrentItem":16,"./getListForItem":20,"slate":308}],18:[function(require,module,exports){
'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;

},{"./getCurrentItem":16,"slate":308}],19:[function(require,module,exports){
'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;

},{"./getCurrentItem":16,"./isList":23,"immutable":51,"slate":308}],20:[function(require,module,exports){
'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;

},{"./isList":23,"slate":308}],21:[function(require,module,exports){
'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;

},{"./getCurrentItem":16,"slate":308}],22:[function(require,module,exports){
'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;

},{"./getCurrentItem":16,"./getCurrentList":17,"./getItemDepth":18,"./getItemsAtRange":19,"./getListForItem":20,"./getPreviousItem":21,"./isList":23,"./isSelectionInList":24}],23:[function(require,module,exports){
'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;

},{"slate":308}],24:[function(require,module,exports){
'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;

},{"./getItemsAtRange":19,"slate":308}],25:[function(require,module,exports){
'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;

},{"./schema":26,"./validateNode":27}],26:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

require('slate');

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * Create a schema definition with rules to normalize lists
 */
function schema(opts) {
    var constructedSchema = {
        blocks: _defineProperty({}, opts.typeItem, {
            parent: { types: opts.types },
            nodes: [{ objects: ['block'] }],

            normalize: normalize({
                parent_type_invalid: function parent_type_invalid(change, context) {
                    return change.unwrapBlockByKey(context.node.key, {
                        normalize: false
                    });
                },
                child_object_invalid: function child_object_invalid(change, context) {
                    return wrapChildrenInDefaultBlock(opts, change, context.node);
                }
            })
        })
    };

    // validate all list types, ensure they only have list item children
    opts.types.forEach(function (type) {
        constructedSchema.blocks[type] = {
            nodes: [{ types: [opts.typeItem] }],
            normalize: normalize({
                child_type_invalid: function child_type_invalid(change, context) {
                    return change.wrapBlockByKey(context.child.key, opts.typeItem, {
                        normalize: false
                    });
                }
            })
        };
    });

    return constructedSchema;
}

/*
 * Allows to define a normalize function through a keyed collection of functions
 */
function normalize(reasons) {
    return function (change, reason, context) {
        var reasonFn = reasons[reason];
        if (reasonFn) {
            reasonFn(change, context);
        }
    };
}

/**
 * Wraps all child of a node in the default block type.
 * Returns a change, for chaining purposes
 */
function wrapChildrenInDefaultBlock(opts, change, node) {
    change.wrapBlockByKey(node.nodes.first().key, opts.typeDefault, {
        normalize: false
    });

    var wrapper = change.value.document.getDescendant(node.key).nodes.first();

    // Add in the remaining items
    node.nodes.rest().forEach(function (child, index) {
        return change.moveNodeByKey(child.key, wrapper.key, index + 1, {
            normalize: false
        });
    });

    return change;
}

exports.default = schema;

},{"slate":308}],27:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

require('slate');

var _utils = require('../utils');

/**
 * Create a schema definition with rules to normalize lists
 */
function validateNode(opts) {
    return function (node) {
        return joinAdjacentLists(opts, node);
    };
}

/**
 * A rule that joins adjacent lists of the same type
 */
function joinAdjacentLists(opts, node) {
    if (node.object !== 'document' && node.object !== 'block') {
        return undefined;
    }

    var invalids = node.nodes.map(function (child, i) {
        if (!(0, _utils.isList)(opts, child)) return null;
        var next = node.nodes.get(i + 1);
        if (!next || next.type !== child.type) return null;
        return [child, next];
    }).filter(Boolean);

    if (invalids.isEmpty()) {
        return undefined;
    }

    /**
     * Join the list pairs
     */
    // We join in reverse order, so that multiple lists folds onto the first one
    return function (change) {
        invalids.reverse().forEach(function (pair) {
            var _pair = _slicedToArray(pair, 2),
                first = _pair[0],
                second = _pair[1];

            var updatedSecond = change.value.document.getDescendant(second.key);
            updatedSecond.nodes.forEach(function (secondNode, index) {
                change.moveNodeByKey(secondNode.key, first.key, first.nodes.size + index, { normalize: false });
            });

            change.removeNodeByKey(second.key, { normalize: false });
        });
    };
}

exports.default = validateNode;

},{"../utils":22,"slate":308}],28:[function(require,module,exports){
'use strict';

var GROUP_LEFT_TO_RIGHT,
    GROUP_RIGHT_TO_LEFT,
    EXPRESSION_LEFT_TO_RIGHT,
    EXPRESSION_RIGHT_TO_LEFT;

/*
 * Character ranges of left-to-right characters.
 */

GROUP_LEFT_TO_RIGHT = 'A-Za-z\u00C0-\u00D6\u00D8-\u00F6' +
    '\u00F8-\u02B8\u0300-\u0590\u0800-\u1FFF\u200E\u2C00-\uFB1C' +
    '\uFE00-\uFE6F\uFEFD-\uFFFF';

/*
 * Character ranges of right-to-left characters.
 */

GROUP_RIGHT_TO_LEFT = '\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC';

/*
 * Expression to match a left-to-right string.
 *
 * Matches the start of a string, followed by zero or
 * more non-right-to-left characters, followed by a
 * left-to-right character.
 */

EXPRESSION_LEFT_TO_RIGHT = new RegExp(
    '^[^' + GROUP_RIGHT_TO_LEFT + ']*[' + GROUP_LEFT_TO_RIGHT + ']'
);

/*
 * Expression to match a right-to-left string.
 *
 * Matches the start of a string, followed by zero or
 * more non-left-to-right characters, followed by a
 * right-to-left character.
 */

EXPRESSION_RIGHT_TO_LEFT = new RegExp(
    '^[^' + GROUP_LEFT_TO_RIGHT + ']*[' + GROUP_RIGHT_TO_LEFT + ']'
);

/**
 * Detect the direction of text.
 *
 * @param {string} value - value to stringify and check.
 * @return {string} - One of `"rtl"`, `"ltr"`, or
 *   `"neutral"`.
 */
function direction(value) {
    value = value.toString();

    if (EXPRESSION_RIGHT_TO_LEFT.test(value)) {
        return 'rtl';
    }

    if (EXPRESSION_LEFT_TO_RIGHT.test(value)) {
        return 'ltr';
    }

    return 'neutral';
}

/*
 * Expose `direction`.
 */

module.exports = direction;

},{}],29:[function(require,module,exports){
(function (global){
/*! https://mths.be/esrever v0.2.0 by @mathias */
;(function(root) {

	// Detect free variables `exports`
	var freeExports = typeof exports == 'object' && exports;

	// Detect free variable `module`
	var freeModule = typeof module == 'object' && module &&
		module.exports == freeExports && module;

	// Detect free variable `global`, from Node.js or Browserified code,
	// and use it as `root`
	var freeGlobal = typeof global == 'object' && global;
	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
		root = freeGlobal;
	}

	/*--------------------------------------------------------------------------*/

	var regexSymbolWithCombiningMarks = /([\0-\u02FF\u0370-\u1AAF\u1B00-\u1DBF\u1E00-\u20CF\u2100-\uD7FF\uE000-\uFE1F\uFE30-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])([\u0300-\u036F\u1AB0-\u1AFF\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]+)/g;
	var regexSurrogatePair = /([\uD800-\uDBFF])([\uDC00-\uDFFF])/g;

	var reverse = function(string) {
		// Step 1: deal with combining marks and astral symbols (surrogate pairs)
		string = string
			// Swap symbols with their combining marks so the combining marks go first
			.replace(regexSymbolWithCombiningMarks, function($0, $1, $2) {
				// Reverse the combining marks so they will end up in the same order
				// later on (after another round of reversing)
				return reverse($2) + $1;
			})
			// Swap high and low surrogates so the low surrogates go first
			.replace(regexSurrogatePair, '$2$1');
		// Step 2: reverse the code units in the string
		var result = '';
		var index = string.length;
		while (index--) {
			result += string.charAt(index);
		}
		return result;
	};

	/*--------------------------------------------------------------------------*/

	var esrever = {
		'version': '0.2.0',
		'reverse': reverse
	};

	// Some AMD build optimizers, like r.js, check for specific condition patterns
	// like the following:
	if (
		typeof define == 'function' &&
		typeof define.amd == 'object' &&
		define.amd
	) {
		define(function() {
			return esrever;
		});
	}	else if (freeExports && !freeExports.nodeType) {
		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
			freeModule.exports = esrever;
		} else { // in Narwhal or RingoJS v0.7.0-
			for (var key in esrever) {
				esrever.hasOwnProperty(key) && (freeExports[key] = esrever[key]);
			}
		}
	} else { // in Rhino or a web browser
		root.esrever = esrever;
	}

}(this));

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !