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

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

@@ -0,0 +1,51 @@
+// @flow
+import { type Value, type Block, type Range } from 'slate';
+import { List } from 'immutable';
+
+import type Options from '../options';
+import isList from './isList';
+import getCurrentItem from './getCurrentItem';
+
+/**
+ * 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: Options,
+    value: Value,
+    range?: Range
+): List<Block> {
+    range = range || value.selection;
+
+    if (!range.startKey) {
+        return List();
+    }
+
+    const { document } = value;
+
+    const startBlock = document.getClosestBlock(range.startKey);
+    const endBlock = document.getClosestBlock(range.endKey);
+
+    if (startBlock === endBlock) {
+        const item = getCurrentItem(opts, value, startBlock);
+        return item ? List([item]) : List();
+    }
+
+    const ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);
+
+    if (isList(opts, ancestor)) {
+        const startPath = ancestor.getPath(startBlock.key);
+        const 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 List([ancestor]);
+    }
+    // No list of items can cover the range
+    return List();
+}
+
+export default getItemsAtRange;

package/configure/node_modules/slate-edit-list/dist/utils/getListForItem.js

@@ -0,0 +1,25 @@
+'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;

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

@@ -0,0 +1,16 @@
+// @flow
+import { type Value, type Block } from 'slate';
+
+import type Options from '../options';
+import isList from './isList';
+
+/**
+ * Return the parent list block for an item block.
+ */
+function getListForItem(opts: Options, value: Value, item: Block): ?Block {
+    const { document } = value;
+    const parent = document.getParent(item.key);
+    return parent && isList(opts, parent) ? parent : null;
+}
+
+export default getListForItem;

package/configure/node_modules/slate-edit-list/dist/utils/getPreviousItem.js

@@ -0,0 +1,39 @@
+'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;

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

@@ -0,0 +1,29 @@
+// @flow
+import { type Value, type Block } from 'slate';
+
+import type Options from '../options';
+import getCurrentItem from './getCurrentItem';
+
+/**
+ * Return the previous item, from current selection or from a node.
+ */
+function getPreviousItem(opts: Options, value: Value, block?: Block): ?Block {
+    const { document, startBlock } = value;
+    block = block || startBlock;
+
+    const currentItem = getCurrentItem(opts, value, block);
+    if (!currentItem) {
+        return null;
+    }
+
+    const previousSibling = document.getPreviousSibling(currentItem.key);
+
+    if (!previousSibling) {
+        return null;
+    } else if (previousSibling.type === opts.typeItem) {
+        return previousSibling;
+    }
+    return null;
+}
+
+export default getPreviousItem;

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

@@ -0,0 +1,49 @@
+'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;

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

@@ -0,0 +1,19 @@
+import getCurrentItem from './getCurrentItem';
+import getCurrentList from './getCurrentList';
+import getItemDepth from './getItemDepth';
+import getItemsAtRange from './getItemsAtRange';
+import getListForItem from './getListForItem';
+import getPreviousItem from './getPreviousItem';
+import isList from './isList';
+import isSelectionInList from './isSelectionInList';
+
+export {
+    getCurrentItem,
+    getCurrentList,
+    getItemDepth,
+    getItemsAtRange,
+    getListForItem,
+    getPreviousItem,
+    isList,
+    isSelectionInList
+};

package/configure/node_modules/slate-edit-list/dist/utils/isList.js

@@ -0,0 +1,15 @@
+'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;

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

@@ -0,0 +1,13 @@
+// @flow
+import { type Node } from 'slate';
+
+import type Options from '../options';
+
+/**
+ * True if the node is a list container
+ */
+function isList(opts: Options, node: Node): boolean {
+    return opts.types.includes(node.type);
+}
+
+export default isList;

package/configure/node_modules/slate-edit-list/dist/utils/isSelectionInList.js

@@ -0,0 +1,22 @@
+'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;

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

@@ -0,0 +1,14 @@
+// @flow
+import { type Value } from 'slate';
+
+import type Options from '../options';
+import getItemsAtRange from './getItemsAtRange';
+
+/**
+ * True if selection is inside a list (and can be unwrapped)
+ */
+function isSelectionInList(opts: Options, value: Value): boolean {
+    return !getItemsAtRange(opts, value).isEmpty();
+}
+
+export default isSelectionInList;

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

@@ -0,0 +1,19 @@
+'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;

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

@@ -0,0 +1,4 @@
+import schema from './schema';
+import validateNode from './validateNode';
+
+export { schema, validateNode };

package/configure/node_modules/slate-edit-list/dist/validation/schema.js

@@ -0,0 +1,83 @@
+'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;

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

@@ -0,0 +1,81 @@
+// @flow
+import { type Change, type Node } from 'slate';
+
+import type Options from '../options';
+
+/**
+ * Create a schema definition with rules to normalize lists
+ */
+function schema(opts: Options): Object {
+    const constructedSchema = {
+        blocks: {
+            [opts.typeItem]: {
+                parent: { types: opts.types },
+                nodes: [{ objects: ['block'] }],
+
+                normalize: normalize({
+                    parent_type_invalid: (change, context) =>
+                        change.unwrapBlockByKey(context.node.key, {
+                            normalize: false
+                        }),
+                    child_object_invalid: (change, context) =>
+                        wrapChildrenInDefaultBlock(opts, change, context.node)
+                })
+            }
+        }
+    };
+
+    // validate all list types, ensure they only have list item children
+    opts.types.forEach(type => {
+        constructedSchema.blocks[type] = {
+            nodes: [{ types: [opts.typeItem] }],
+            normalize: normalize({
+                child_type_invalid: (change, context) =>
+                    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: { [string]: (Change, context: any) => any }): * {
+    return (change, reason, context) => {
+        const 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: Options,
+    change: Change,
+    node: Node
+): Change {
+    change.wrapBlockByKey(node.nodes.first().key, opts.typeDefault, {
+        normalize: false
+    });
+
+    const wrapper = change.value.document.getDescendant(node.key).nodes.first();
+
+    // Add in the remaining items
+    node.nodes.rest().forEach((child, index) =>
+        change.moveNodeByKey(child.key, wrapper.key, index + 1, {
+            normalize: false
+        })
+    );
+
+    return change;
+}
+
+export default schema;

package/configure/node_modules/slate-edit-list/dist/validation/validateNode.js

@@ -0,0 +1,61 @@
+'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;

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

@@ -0,0 +1,61 @@
+// @flow
+import { type Change, type Node } from 'slate';
+
+import { isList } from '../utils';
+import type Options from '../options';
+
+type Normalizer = Change => any;
+
+/**
+ * Create a schema definition with rules to normalize lists
+ */
+function validateNode(opts: Options): Node => void | Normalizer {
+    return node => joinAdjacentLists(opts, node);
+}
+
+/**
+ * A rule that joins adjacent lists of the same type
+ */
+function joinAdjacentLists(opts: Options, node: Node): void | Normalizer {
+    if (node.object !== 'document' && node.object !== 'block') {
+        return undefined;
+    }
+
+    const invalids = node.nodes
+        .map((child, i) => {
+            if (!isList(opts, child)) return null;
+            const 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 change => {
+        invalids.reverse().forEach(pair => {
+            const [first, second] = pair;
+            const updatedSecond = change.value.document.getDescendant(
+                second.key
+            );
+            updatedSecond.nodes.forEach((secondNode, index) => {
+                change.moveNodeByKey(
+                    secondNode.key,
+                    first.key,
+                    first.nodes.size + index,
+                    { normalize: false }
+                );
+            });
+
+            change.removeNodeByKey(second.key, { normalize: false });
+        });
+    };
+}
+
+export default validateNode;

package/configure/node_modules/slate-edit-list/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "slate-edit-list",
+  "description": "A Slate plugin to handle keyboard events in lists.",
+  "version": "0.11.3",
+  "license": "Apache-2.0",
+  "repository": "git://github.com/GitbookIO/slate-edit-list.git",
+  "main": "./dist/index.js",
+  "peerDependencies": {
+    "immutable": "^3.8.2",
+    "slate": "^0.32.0"
+  },
+  "files": [
+     "dist",
+     "*.md"
+  ],
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-core": "^6.26.0",
+    "babel-eslint": "^8.0.2",
+    "babel-plugin-transform-flow-strip-types": "^6.22.0",
+    "babel-plugin-transform-runtime": "^6.23.0",
+    "babel-preset-env": "^1.6.1",
+    "babel-preset-flow": "^6.23.0",
+    "babel-preset-react": "^6.24.1",
+    "babel-preset-stage-0": "^6.24.1",
+    "babelify": "^8.0.0",
+    "browserify": "^13.3.0",
+    "eslint": "^4.15.0",
+    "eslint-config-gitbook": "^3.0.0",
+    "eslint-plugin-flowtype": "^2.41.0",
+    "eslint-plugin-import": "^2.8.0",
+    "eslint-plugin-jsx-a11y": "^5.1.1",
+    "eslint-plugin-prettier": "^2.4.0",
+    "eslint-plugin-react": "^7.5.1",
+    "expect": "^1.20.2",
+    "flow-bin": "^0.57.3",
+    "flow-copy-source": "^1.2.1",
+    "gh-pages": "^0.11.0",
+    "http-server": "^0.9.0",
+    "immutable": "^3.8.2",
+    "mocha": "^3.0.1",
+    "prettier": "^1.9.2",
+    "react": "^16.0.0",
+    "react-dom": "^16.0.0",
+    "read-metadata": "^1.0.0",
+    "slate": "^0.32.0",
+    "slate-hyperscript": "^0.5.0",
+    "slate-plain-serializer": "^0.5.0",
+    "slate-react": "^0.11.0",
+    "stringify": "^5.1.0"
+  },
+  "scripts": {
+    "build:dist": "rm -r ./dist; babel ./lib --out-dir ./dist",
+    "build:flow": "flow-copy-source -v ./lib/ ./dist/",
+    "prepublish": "npm run build:dist && npm run build:flow",
+    "postpublish": "npm run deploy-example",
+    "lint": "eslint ./",
+    "build-example": "browserify ./example/main.js -o ./example/bundle.js -t [ babelify --presets [ env react stage-0 ] ] -t [ stringify --extensions [.yaml] ]",
+    "serve-example": "http-server ./example/ -p 8081",
+    "start": "npm run build-example && npm run serve-example",
+    "deploy-example": "npm run build-example && gh-pages -d ./example",
+    "test": "./node_modules/.bin/mocha ./tests/all.js --compilers js:babel-register --reporter=list"
+  },
+  "keywords": [
+    "slate"
+  ]
+}