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

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"
+  ]
+}

package/configure/node_modules/slate-edit-table/CHANGELOG.md

@@ -0,0 +1,192 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## Unreleased
+
+## [0.17.0] - 2018-07-26
+
+- Remove `key` parameter of getPosition, and create a function `getPositionByKey`    
+
+## [0.16.2] - 2018-07-16
+
+- Add byKey variants to remove utils. removeRowByKey, removeColumnByKey, removeTableByKey
+
+## [0.16.1] - 2018-06-28
+
+- Improve behavior of Backspace when deleting whole cells https://github.com/GitbookIO/slate-edit-table/pull/79
+
+## [0.16.0] - 2018-06-27
+
+- Fix some case where pressing Backspace would unexpectedly clear the whole cell
+
+## [0.16.0 (pre)] - 2018-06-27
+
+- Add keyboard interactions to handle multiple blocks in cells:
+  - Split block when pressing <kbd>Shift+Enter</kbd>
+  - Split block when pressing <kbd>Enter</kbd> inside the cell
+
+## [0.15.2] - 2018-06-19
+
+*  Export TablePosition type
+
+## [0.15.1] - 2018-06-13
+
+*   Add key option to `getPosition`
+
+## [0.15.0] - 2018-04-19
+
+*   Allow blocks in cells
+*   Align for columns have been removed
+*   Improve package size by publishing only the `dist` folder
+
+## [0.14.3] - 2018-02-06
+
+*   Fix normalization of multiple blocks in cells
+
+## [0.14.2] - 2018-02-06
+
+## [0.14.1] - 2018-02-06
+
+*   Fixed build
+
+## [0.14.0] - 2018-02-05
+
+**BREAKING**
+
+*   Upgrade to be compatible with Slate 0.32.x
+*   Fixed missing peerDependencies for `eslint-config-gitbook`
+
+## [0.13.3] - 2018-01-08
+
+*   Fix peer depedency range for slate to include 0.30 and 0.31
+
+## [0.13.2] - 2018-01-08
+
+*   Add `isSelectionOutOfTable`
+*   Fix keys detection
+*   Fix selection errors when deleting table
+
+## [0.13.1] - 2017-12-05
+
+*   Improve `isSelectionInTable` to check for both end of the selection to be in the same table.
+
+## [0.13.0] - 2017-11-22
+
+**BREAKING**
+
+*   Upgrade to be compatible with Slate 0.30.x
+
+## [0.12.0] - 2017-11-02
+
+**BREAKING**
+
+*   Upgrade to be compatible with Slate 0.27.x
+
+## [0.11.0] - 2017-09-20
+
+**BREAKING**
+
+*   Upgrade to be compatible with Slate after the `expose-transform` branch went in.
+*   Change all instances of `transform` to `change`
+*   Change the namespace of `plugin.transforms` to `plugin.changes`
+
+## [0.10.2] - 2017-09-20
+
+*   New `utils.getPosition(state) => TablePosition` to know easily the current
+    position within a table (#39)
+*   New option `exitBlockType`. When provided, `Mod+Enter` will exit the current
+    table into a new block of this type.
+*   Fixed cursor issues when inserting rows using Tab (#26)
+
+## [0.10.1] - 2017-07-13
+
+[0.10.1]: https://github.com/GitbookIO/slate-edit-table/compare/0.10.0...0.10.1
+
+*   Fix rule to prevent extra blocks in rows
+
+## [0.10.0] - 2017-07-13
+
+[0.10.0]: https://github.com/GitbookIO/slate-edit-table/compare/0.9.0...0.10.0
+
+*   Add rule to prevent nested blocks in cells
+
+## [0.9.0] - 2017-04-21
+
+[0.9.0]: https://github.com/GitbookIO/slate-edit-table/compare/0.8.4...0.9.0
+
+*   Update slate to `^0.19.x`
+
+## [0.8.4] - 2016-11-30
+
+[0.8.4]: https://github.com/GitbookIO/slate-edit-table/compare/0.8.3...0.8.4
+
+*   Update slate peer dependency to prevent NPM warnings when used with `0.15.x`
+
+## [0.8.3] - 2016-11-09
+
+[0.8.3]: https://github.com/GitbookIO/slate-edit-table/compare/0.8.2...0.8.3
+
+*   Enforce align to be Immutable.List
+*   Undo is now fixed, using GitbookIO:slate
+
+## [0.8.2] - 2016-11-03
+
+[0.8.2]: https://github.com/GitbookIO/slate-edit-table/compare/0.8.1...0.8.2
+
+*   Move slate to `peerDependencies`
+
+## [0.8.1] - 2016-11-01
+
+[0.8.1]: https://github.com/GitbookIO/slate-edit-table/compare/0.8.0...0.8.1
+
+*   Add schema to normalize `align` in table
+*   `insertColumn` and `removeColumn` update correctly the alignment
+
+## [0.8.0] - 2016-10-27
+
+[0.8.0]: https://github.com/GitbookIO/slate-edit-table/compare/0.7.0...0.8.0
+
+*   Expose `setColumnAlign` transform
+*   Expose `ALIGN.{LEFT,RIGHT,CENTER}` constants
+*   Rules to ensure cells or rows are always within a table. Fix
+    [#13](https://github.com/GitbookIO/slate-edit-table/issues/13)
+
+## [0.7.0] - 2016-10-27
+
+[0.7.0]: https://github.com/GitbookIO/slate-edit-table/compare/0.6.0...0.7.0
+
+*   Adapt for upcoming Slate release
+*   Improve stability
+
+## [0.6.0] - 2016-09-23
+
+[0.6.0]: https://github.com/GitbookIO/slate-edit-table/compare/0.5.1...0.6.0
+
+*   Expose `moveSelectionBy` transform
+*   `removeColumn` clears the column instead, if it is the last remaining column
+*   `removeRow` clears the row instead, if it is the last remaining row
+*   Undo of `insertColumn` when cursor is in inserted column
+
+## [0.5.1] - 2016-09-15
+
+[0.5.1]: https://github.com/GitbookIO/slate-edit-table/compare/0.5.0...0.5.1
+
+*   `insertTable` does not grab text from current block anymore, and simply inserts an empty table.
+*   Up/Down arrows behavior inside tables
+
+## [0.5.0] - 2016-09-15
+
+[0.5.0]: https://github.com/GitbookIO/slate-edit-table/compare/0.4.0...0.5.0
+
+*   `TablePosition.is{First|Last}{Row|Column|Cell}` methods
+*   **BREAKING** Now uses `slate^0.14.x`
+*   Split transform `moveSelection` into `moveSelection` and `moveSelectionBy`
+
+## [0.4.0] - 2016-09-06
+
+[0.4.0]: https://github.com/GitbookIO/slate-edit-table/compare/0.3.0...0.4.0
+
+*   Schema normalization rules