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

package/configure/node_modules/slate-edit-table/dist/handlers/onBackspace.js.flow

@@ -0,0 +1,87 @@
+// @flow
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import { clearCell } from '../changes';
+
+function onBackspace(
+    event: *,
+    change: Change,
+    editor: *,
+    opts: Options
+): void | Change {
+    const { value } = change;
+    const { startBlock, startOffset, isCollapsed, endBlock, document } = value;
+
+    const startCell = document.getClosest(startBlock.key, opts.isCell);
+    const endCell = document.getClosest(endBlock.key, opts.isCell);
+
+    const startBlockIndex = startCell.nodes.findIndex(
+        block => block.key == startBlock.key
+    );
+
+    // If a cursor is collapsed at the start of the first block, do nothing
+    if (startOffset === 0 && isCollapsed && startBlockIndex === 0) {
+        if (startBlock.isVoid) {
+            // Delete the block normally if it is a void block
+            return undefined;
+        }
+
+        event.preventDefault();
+        return change;
+    }
+
+    // If "normal" deletion, we continue
+    if (startCell === endCell) {
+        return undefined;
+    }
+
+    // If cursor is between multiple blocks,
+    // we clear the content of the cells.
+    event.preventDefault();
+
+    const { blocks } = value;
+
+    // Get all cells that contains the selection
+    const cells = blocks
+        .map(
+            node =>
+                node.type === opts.typeCell
+                    ? node
+                    : document.getClosest(
+                          node.key,
+                          a => a.type === opts.typeCell
+                      )
+        )
+        .toSet();
+
+    // If the cursor is at the very end of the first cell, ignore it.
+    // If the cursor is at the very start of the last cell, ignore it.
+    // This behavior is to compensate hanging selection behaviors:
+    // https://github.com/ianstormtaylor/slate/pull/1605
+    const ignoreFirstCell = value.selection
+        .collapseToStart()
+        .isAtEndOf(cells.first());
+    const ignoreLastCell = value.selection
+        .collapseToEnd()
+        .isAtStartOf(cells.last());
+
+    let cellsToClear = cells;
+    if (ignoreFirstCell) {
+        cellsToClear = cellsToClear.rest();
+    }
+    if (ignoreLastCell) {
+        cellsToClear = cellsToClear.butLast();
+    }
+
+    // Clear all the selection
+    cellsToClear.forEach(cell => clearCell(opts, change, cell));
+
+    // Update the selection properly, and avoid reset of selection
+    const updatedStartCell = change.value.document.getDescendant(
+        cellsToClear.first().key
+    );
+    return change.collapseToStartOf(updatedStartCell);
+}
+
+export default onBackspace;

package/configure/node_modules/slate-edit-table/dist/handlers/onEnter.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+var _changes = require('../changes');
+
+/**
+ * Insert a new row when pressing "Enter"
+ */
+function onEnter(event, change, editor, opts) {
+    event.preventDefault();
+    var _change$value = change.value,
+        selection = _change$value.selection,
+        document = _change$value.document;
+
+    var pos = _utils.TablePosition.create(opts, document, selection.startKey);
+
+    if (!selection.hasFocusAtStartOf(pos.cell) && !selection.hasFocusAtEndOf(pos.cell)) {
+        return undefined;
+    }
+
+    if (event.shiftKey) {
+        return change.splitBlock().setBlocks({ type: opts.typeContent, data: {} });
+    }
+
+    return (0, _changes.insertRow)(opts, change);
+}
+exports.default = onEnter;

package/configure/node_modules/slate-edit-table/dist/handlers/onEnter.js.flow

@@ -0,0 +1,37 @@
+// @flow
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import { TablePosition } from '../utils';
+import { insertRow } from '../changes';
+
+/**
+ * Insert a new row when pressing "Enter"
+ */
+function onEnter(
+    event: *,
+    change: Change,
+    editor: *,
+    opts: Options
+): void | Change {
+    event.preventDefault();
+    const { selection, document } = change.value;
+    const pos = TablePosition.create(opts, document, selection.startKey);
+
+    if (
+        !selection.hasFocusAtStartOf(pos.cell) &&
+        !selection.hasFocusAtEndOf(pos.cell)
+    ) {
+        return undefined;
+    }
+
+    if (event.shiftKey) {
+        return change
+            .splitBlock()
+            .setBlocks({ type: opts.typeContent, data: {} });
+    }
+
+    return insertRow(opts, change);
+}
+
+export default onEnter;

package/configure/node_modules/slate-edit-table/dist/handlers/onKeyDown.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+var _onEnter = require('./onEnter');
+
+var _onEnter2 = _interopRequireDefault(_onEnter);
+
+var _onModEnter = require('./onModEnter');
+
+var _onModEnter2 = _interopRequireDefault(_onModEnter);
+
+var _onTab = require('./onTab');
+
+var _onTab2 = _interopRequireDefault(_onTab);
+
+var _onBackspace = require('./onBackspace');
+
+var _onBackspace2 = _interopRequireDefault(_onBackspace);
+
+var _onUpDown = require('./onUpDown');
+
+var _onUpDown2 = _interopRequireDefault(_onUpDown);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var KEY_ENTER = 'Enter';
+
+var KEY_TAB = 'Tab';
+var KEY_BACKSPACE = 'Backspace';
+var KEY_DOWN = 'ArrowDown';
+var KEY_UP = 'ArrowUp';
+
+/**
+ * User is pressing a key in the editor
+ */
+function onKeyDown(opts, event, change, editor) {
+    // Only handle events in cells
+    if (!(0, _utils.isSelectionInTable)(opts, change.value)) {
+        return undefined;
+    }
+
+    // Build arguments list
+    var args = [event, change, editor, opts];
+
+    switch (event.key) {
+        case KEY_ENTER:
+            if (event.metaKey && opts.exitBlockType) {
+                return _onModEnter2.default.apply(undefined, args);
+            }
+            return _onEnter2.default.apply(undefined, args);
+
+        case KEY_TAB:
+            return _onTab2.default.apply(undefined, args);
+        case KEY_BACKSPACE:
+            return _onBackspace2.default.apply(undefined, args);
+        case KEY_DOWN:
+        case KEY_UP:
+            return _onUpDown2.default.apply(undefined, args);
+        default:
+            return undefined;
+    }
+}
+
+exports.default = onKeyDown;

package/configure/node_modules/slate-edit-table/dist/handlers/onKeyDown.js.flow

@@ -0,0 +1,56 @@
+// @flow
+
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import { isSelectionInTable } from '../utils';
+
+import onEnter from './onEnter';
+import onModEnter from './onModEnter';
+import onTab from './onTab';
+import onBackspace from './onBackspace';
+import onUpDown from './onUpDown';
+
+const KEY_ENTER = 'Enter';
+const KEY_TAB = 'Tab';
+const KEY_BACKSPACE = 'Backspace';
+const KEY_DOWN = 'ArrowDown';
+const KEY_UP = 'ArrowUp';
+
+/**
+ * User is pressing a key in the editor
+ */
+function onKeyDown(
+    opts: Options,
+    event: *,
+    change: Change,
+    editor: *
+): void | any {
+    // Only handle events in cells
+    if (!isSelectionInTable(opts, change.value)) {
+        return undefined;
+    }
+
+    // Build arguments list
+    const args = [event, change, editor, opts];
+
+    switch (event.key) {
+        case KEY_ENTER:
+            if (event.metaKey && opts.exitBlockType) {
+                return onModEnter(...args);
+            }
+            return onEnter(...args);
+
+        case KEY_TAB:
+            return onTab(...args);
+        case KEY_BACKSPACE:
+            return onBackspace(...args);
+        case KEY_DOWN:
+        case KEY_UP:
+            return onUpDown(...args);
+        default:
+            return undefined;
+    }
+}
+
+export default onKeyDown;

package/configure/node_modules/slate-edit-table/dist/handlers/onModEnter.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _slate = require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Exit the current table, by inserting a default block after the table.
+ */
+function onModEnter(event, change, editor, opts) {
+    var value = change.value;
+
+    if (!value.isCollapsed) {
+        return undefined;
+    }
+
+    event.preventDefault();
+
+    var exitBlock = _slate.Block.create({
+        type: opts.exitBlockType,
+        nodes: [_slate.Text.create('')]
+    });
+
+    var table = _utils.TablePosition.create(opts, value.document, value.startKey).table;
+    var tableParent = value.document.getParent(table.key);
+    var insertionIndex = tableParent.nodes.indexOf(table) + 1;
+
+    return change.insertNodeByKey(tableParent.key, insertionIndex, exitBlock).collapseToStartOf(exitBlock);
+}
+
+exports.default = onModEnter;

package/configure/node_modules/slate-edit-table/dist/handlers/onModEnter.js.flow

@@ -0,0 +1,38 @@
+// @flow
+import { Block, Text, type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import type Options from '../options';
+
+/**
+ * Exit the current table, by inserting a default block after the table.
+ */
+function onModEnter(
+    event: *,
+    change: Change,
+    editor: *,
+    opts: Options
+): void | Change {
+    const { value } = change;
+    if (!value.isCollapsed) {
+        return undefined;
+    }
+
+    event.preventDefault();
+
+    const exitBlock = Block.create({
+        type: opts.exitBlockType,
+        nodes: [Text.create('')]
+    });
+
+    const table = TablePosition.create(opts, value.document, value.startKey)
+        .table;
+    const tableParent = value.document.getParent(table.key);
+    const insertionIndex = tableParent.nodes.indexOf(table) + 1;
+
+    return change
+        .insertNodeByKey(tableParent.key, insertionIndex, exitBlock)
+        .collapseToStartOf(exitBlock);
+}
+
+export default onModEnter;

package/configure/node_modules/slate-edit-table/dist/handlers/onTab.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+var _changes = require('../changes');
+
+/**
+ * Select all text of current block.
+ */
+function selectAllText(change) {
+    var value = change.value;
+    var startBlock = value.startBlock;
+
+
+    return change.moveOffsetsTo(0).extend(startBlock.text.length);
+}
+
+/**
+ * Pressing "Tab" moves the cursor to the next cell
+ * and select the whole text
+ */
+
+function onTab(event, change, editor, opts) {
+    event.preventDefault();
+    var value = change.value;
+
+    var direction = event.shiftKey ? -1 : +1;
+
+    // Create new row if needed
+    var startKey = value.startKey,
+        selection = value.selection;
+
+    var pos = _utils.TablePosition.create(opts, value.document, startKey);
+    if (pos.isFirstCell() && direction === -1) {
+        (0, _changes.insertRow)(opts, change, 0);
+    } else if (pos.isLastCell() && direction === 1) {
+        (0, _changes.insertRow)(opts, change);
+    }
+
+    // Move back to initial cell (insertRow moves selection automatically).
+    change.select(selection);
+
+    // Move
+    (0, _changes.moveSelectionBy)(opts, change, direction, 0);
+
+    // Select all cell.
+    return selectAllText(change);
+}
+
+exports.default = onTab;

package/configure/node_modules/slate-edit-table/dist/handlers/onTab.js.flow

@@ -0,0 +1,51 @@
+// @flow
+import { type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import { moveSelectionBy, insertRow } from '../changes';
+import type Options from '../options';
+
+/**
+ * Select all text of current block.
+ */
+function selectAllText(change: Change): Change {
+    const { value } = change;
+    const { startBlock } = value;
+
+    return change.moveOffsetsTo(0).extend(startBlock.text.length);
+}
+
+/**
+ * Pressing "Tab" moves the cursor to the next cell
+ * and select the whole text
+ */
+function onTab(
+    event: *,
+    change: Change,
+    editor: *,
+    opts: Options
+): void | Change {
+    event.preventDefault();
+    const { value } = change;
+    const direction = event.shiftKey ? -1 : +1;
+
+    // Create new row if needed
+    const { startKey, selection } = value;
+    const pos = TablePosition.create(opts, value.document, startKey);
+    if (pos.isFirstCell() && direction === -1) {
+        insertRow(opts, change, 0);
+    } else if (pos.isLastCell() && direction === 1) {
+        insertRow(opts, change);
+    }
+
+    // Move back to initial cell (insertRow moves selection automatically).
+    change.select(selection);
+
+    // Move
+    moveSelectionBy(opts, change, direction, 0);
+
+    // Select all cell.
+    return selectAllText(change);
+}
+
+export default onTab;

package/configure/node_modules/slate-edit-table/dist/handlers/onUpDown.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+var _changes = require('../changes');
+
+function onUpDown(event, change, editor, opts) {
+    var value = change.value;
+
+    var direction = event.key === 'ArrowUp' ? -1 : +1;
+    var pos = _utils.TablePosition.create(opts, value.document, value.startKey);
+
+    if (pos.isFirstRow() && direction === -1 || pos.isLastRow() && direction === +1) {
+        // Let the default behavior move out of the table
+        return undefined;
+    }
+
+    if (direction === -1 && !pos.isTopOfCell()) {
+        return undefined;
+    }
+
+    if (direction === +1 && !pos.isBottomOfCell()) {
+        return undefined;
+    }
+
+    event.preventDefault();
+
+    (0, _changes.moveSelectionBy)(opts, change, 0, direction);
+
+    return change;
+}
+exports.default = onUpDown;

package/configure/node_modules/slate-edit-table/dist/handlers/onUpDown.js.flow

@@ -0,0 +1,41 @@
+// @flow
+import { type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import { moveSelectionBy } from '../changes';
+import type Options from '../options';
+
+function onUpDown(
+    event: *,
+    change: Change,
+    editor: *,
+    opts: Options
+): void | Change {
+    const { value } = change;
+    const direction = event.key === 'ArrowUp' ? -1 : +1;
+    const pos = TablePosition.create(opts, value.document, value.startKey);
+
+    if (
+        (pos.isFirstRow() && direction === -1) ||
+        (pos.isLastRow() && direction === +1)
+    ) {
+        // Let the default behavior move out of the table
+        return undefined;
+    }
+
+    if (direction === -1 && !pos.isTopOfCell()) {
+        return undefined;
+    }
+
+    if (direction === +1 && !pos.isBottomOfCell()) {
+        return undefined;
+    }
+
+    event.preventDefault();
+
+    moveSelectionBy(opts, change, 0, direction);
+
+    return change;
+}
+
+export default onUpDown;

package/configure/node_modules/slate-edit-table/dist/index.js

@@ -0,0 +1,36 @@
+'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 _core = require('./core');
+
+var _core2 = _interopRequireDefault(_core);
+
+var _handlers = require('./handlers');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ *  Returns the full plugin object (behavior + rendering + schema)
+ */
+function EditTable(
+// The plugin options
+optionsParam) {
+    var opts = new _options2.default(optionsParam || {});
+    var corePlugin = (0, _core2.default)(opts);
+
+    return _extends({}, corePlugin, {
+
+        onKeyDown: _handlers.onKeyDown.bind(null, opts)
+    });
+}
+
+exports.default = EditTable;

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

@@ -0,0 +1,27 @@
+/* @flow */
+
+import Options, { type OptionsFormat } from './options';
+import type { TablePosition as _TablePosition } from './utils/TablePosition';
+import core from './core';
+import { onKeyDown } from './handlers';
+
+/**
+ *  Returns the full plugin object (behavior + rendering + schema)
+ */
+function EditTable(
+    // The plugin options
+    optionsParam?: OptionsFormat
+): Object {
+    const opts = new Options(optionsParam || {});
+    const corePlugin = core(opts);
+
+    return {
+        ...corePlugin,
+
+        onKeyDown: onKeyDown.bind(null, opts)
+    };
+}
+
+export type TablePosition = _TablePosition;
+
+export default EditTable;

package/configure/node_modules/slate-edit-table/dist/options.js

@@ -0,0 +1,61 @@
+'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() {
+        var _ref;
+
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, Options);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Options.__proto__ || Object.getPrototypeOf(Options)).call.apply(_ref, [this].concat(args))), _this), _this.isCell = function (node) {
+            return node.object == 'block' && node.type == _this.typeCell;
+        }, _temp), _possibleConstructorReturn(_this, _ret);
+    }
+    // The type of table blocks
+
+    // The type of row blocks
+
+    // The type of cell blocks
+
+    // The default type for blocks in cells
+
+    // The type of block inserted when exiting
+
+
+    /*
+     * Return a node filter to find a cell.
+     */
+
+
+    return Options;
+}((0, _immutable.Record)({
+    typeTable: 'table',
+    typeRow: 'table_row',
+    typeCell: 'table_cell',
+    typeContent: 'paragraph',
+    exitBlockType: 'paragraph'
+}));
+
+exports.default = Options;