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

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

@@ -0,0 +1,30 @@
+// @flow
+import { type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import clearCell from './clearCell';
+import type Options from '../options';
+
+/**
+ * Remove the row associated to a given key in a table.
+ * Clear thw row if last remaining row
+ */
+function removeRowByKey(opts: Options, change: Change, key: string): Change {
+    const { value } = change;
+
+    const pos = TablePosition.create(opts, value.document, key);
+
+    // Update table by removing the row
+    if (pos.getHeight() > 1) {
+        change.removeNodeByKey(key);
+    } else {
+        // If last remaining row, clear it instead
+        pos.row.nodes.forEach(cell => {
+            cell.nodes.forEach(node => clearCell(opts, change, cell));
+        });
+    }
+
+    return change;
+}
+
+export default removeRowByKey;

package/configure/node_modules/slate-edit-table/dist/changes/removeTable.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _removeTableByKey = require('./removeTableByKey');
+
+var _removeTableByKey2 = _interopRequireDefault(_removeTableByKey);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Delete the whole table at position
+ */
+function removeTable(opts, change) {
+    var value = change.value;
+    var startKey = value.startKey;
+
+
+    return (0, _removeTableByKey2.default)(opts, change, startKey);
+}
+
+exports.default = removeTable;

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

@@ -0,0 +1,17 @@
+// @flow
+import { type Change } from 'slate';
+
+import type Options from '../options';
+import removeTableByKey from './removeTableByKey';
+
+/**
+ * Delete the whole table at position
+ */
+function removeTable(opts: Options, change: Change): Change {
+    const { value } = change;
+    const { startKey } = value;
+
+    return removeTableByKey(opts, change, startKey);
+}
+
+export default removeTable;

package/configure/node_modules/slate-edit-table/dist/changes/removeTableByKey.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _slate = require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Delete the whole table at the given node key
+ */
+function removeTableByKey(opts, change, key) {
+    var value = change.value;
+
+
+    var pos = _utils.TablePosition.create(opts, value.document, key);
+    var table = pos.table;
+    var document = change.value.document;
+
+    var nextFocusBlock = null;
+    var shouldCollapseToEnd = false;
+
+    var nextBlock = change.value.document.getNextBlock(table.key);
+    if (nextBlock) {
+        nextFocusBlock = nextBlock;
+    } else {
+        var prevBlock = change.value.document.getPreviousBlock(table.key);
+        if (prevBlock) {
+            nextFocusBlock = prevBlock;
+            shouldCollapseToEnd = true;
+        } else if (opts.exitBlockType) {
+            nextFocusBlock = _slate.Block.create({
+                type: opts.exitBlockType,
+                nodes: [_slate.Text.create('')]
+            });
+            var tableParent = document.getParent(table.key);
+            var insertionIndex = tableParent.nodes.indexOf(table) + 1;
+            change.insertNodeByKey(tableParent.key, insertionIndex, nextFocusBlock);
+        }
+    }
+
+    change.removeNodeByKey(table.key);
+    if (!nextFocusBlock) {
+        return change;
+    }
+    if (shouldCollapseToEnd) {
+        change.collapseToEndOf(nextFocusBlock).focus();
+    } else {
+        change.collapseToStartOf(nextFocusBlock).focus();
+    }
+    return change;
+}
+
+exports.default = removeTableByKey;

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

@@ -0,0 +1,54 @@
+// @flow
+import { Block, Text, type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import type Options from '../options';
+
+/**
+ * Delete the whole table at the given node key
+ */
+function removeTableByKey(opts: Options, change: Change, key: string): Change {
+    const { value } = change;
+
+    const pos = TablePosition.create(opts, value.document, key);
+    const { table } = pos;
+    const { document } = change.value;
+    let nextFocusBlock = null;
+    let shouldCollapseToEnd = false;
+
+    const nextBlock = change.value.document.getNextBlock(table.key);
+    if (nextBlock) {
+        nextFocusBlock = nextBlock;
+    } else {
+        const prevBlock = change.value.document.getPreviousBlock(table.key);
+        if (prevBlock) {
+            nextFocusBlock = prevBlock;
+            shouldCollapseToEnd = true;
+        } else if (opts.exitBlockType) {
+            nextFocusBlock = Block.create({
+                type: opts.exitBlockType,
+                nodes: [Text.create('')]
+            });
+            const tableParent = document.getParent(table.key);
+            const insertionIndex = tableParent.nodes.indexOf(table) + 1;
+            change.insertNodeByKey(
+                tableParent.key,
+                insertionIndex,
+                nextFocusBlock
+            );
+        }
+    }
+
+    change.removeNodeByKey(table.key);
+    if (!nextFocusBlock) {
+        return change;
+    }
+    if (shouldCollapseToEnd) {
+        change.collapseToEndOf(nextFocusBlock).focus();
+    } else {
+        change.collapseToStartOf(nextFocusBlock).focus();
+    }
+    return change;
+}
+
+export default removeTableByKey;

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

@@ -0,0 +1,88 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _changes = require('./changes');
+
+var _utils = require('./utils');
+
+var _validation = require('./validation');
+
+var _options = require('./options');
+
+var _options2 = _interopRequireDefault(_options);
+
+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-table`, and utils.
+ *
+ * Import this directly: `import EditTable 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 `slate-react`.
+ */
+function core(optionsParam) {
+    var opts = new _options2.default(optionsParam);
+
+    return {
+        schema: (0, _validation.schema)(opts),
+        validateNode: (0, _validation.validateNode)(opts),
+
+        utils: {
+            isSelectionInTable: _utils.isSelectionInTable.bind(null, opts),
+            isSelectionOutOfTable: _utils.isSelectionOutOfTable.bind(null, opts),
+            getPosition: _utils.getPosition.bind(null, opts),
+            getPositionByKey: _utils.getPositionByKey.bind(null, opts),
+            createCell: _utils.createCell.bind(null, opts),
+            createRow: _utils.createRow.bind(null, opts),
+            createTable: _utils.createTable.bind(null, opts),
+            forEachCells: _utils.forEachCells.bind(null, opts),
+            getCellsAtRow: _utils.getCellsAtRow.bind(null, opts),
+            getCellsAtColumn: _utils.getCellsAtColumn.bind(null, opts)
+        },
+
+        changes: {
+            insertTable: _changes.insertTable.bind(null, opts),
+            clearCell: _changes.clearCell.bind(null, opts),
+            removeRowByKey: _changes.removeRowByKey.bind(null, opts),
+            removeColumnByKey: _changes.removeColumnByKey.bind(null, opts),
+            removeTableByKey: _changes.removeTableByKey.bind(null, opts),
+            insertRow: bindAndScopeChange(opts, _changes.insertRow),
+            removeRow: bindAndScopeChange(opts, _changes.removeRow),
+            insertColumn: bindAndScopeChange(opts, _changes.insertColumn),
+            removeColumn: bindAndScopeChange(opts, _changes.removeColumn),
+            removeTable: bindAndScopeChange(opts, _changes.removeTable),
+            moveSelection: bindAndScopeChange(opts, _changes.moveSelection),
+            moveSelectionBy: bindAndScopeChange(opts, _changes.moveSelectionBy)
+        }
+    };
+}
+
+/**
+ * Bind a change to given options, and scope it to act only inside a table
+ */
+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.isSelectionInTable)(opts, value)) {
+            return change;
+        }
+
+        // $FlowFixMe
+        return fn.apply(undefined, _toConsumableArray([opts, change].concat(args)));
+    };
+}
+
+exports.default = core;

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

@@ -0,0 +1,94 @@
+// @flow
+import {
+    insertTable,
+    insertRow,
+    removeRow,
+    insertColumn,
+    removeColumn,
+    removeTable,
+    clearCell,
+    moveSelection,
+    moveSelectionBy,
+    removeRowByKey,
+    removeColumnByKey,
+    removeTableByKey
+} from './changes';
+import {
+    isSelectionInTable,
+    isSelectionOutOfTable,
+    getPosition,
+    getPositionByKey,
+    createCell,
+    createRow,
+    createTable,
+    forEachCells,
+    getCellsAtRow,
+    getCellsAtColumn
+} from './utils';
+import { schema, validateNode } from './validation';
+
+import Options, { type OptionsFormat } from './options';
+
+/**
+ * Returns the core of the plugin, limited to the validation and normalization
+ * part of `slate-edit-table`, and utils.
+ *
+ * Import this directly: `import EditTable 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 `slate-react`.
+ */
+function core(optionsParam: Options | OptionsFormat): Object {
+    const opts = new Options(optionsParam);
+
+    return {
+        schema: schema(opts),
+        validateNode: validateNode(opts),
+
+        utils: {
+            isSelectionInTable: isSelectionInTable.bind(null, opts),
+            isSelectionOutOfTable: isSelectionOutOfTable.bind(null, opts),
+            getPosition: getPosition.bind(null, opts),
+            getPositionByKey: getPositionByKey.bind(null, opts),
+            createCell: createCell.bind(null, opts),
+            createRow: createRow.bind(null, opts),
+            createTable: createTable.bind(null, opts),
+            forEachCells: forEachCells.bind(null, opts),
+            getCellsAtRow: getCellsAtRow.bind(null, opts),
+            getCellsAtColumn: getCellsAtColumn.bind(null, opts)
+        },
+
+        changes: {
+            insertTable: insertTable.bind(null, opts),
+            clearCell: clearCell.bind(null, opts),
+            removeRowByKey: removeRowByKey.bind(null, opts),
+            removeColumnByKey: removeColumnByKey.bind(null, opts),
+            removeTableByKey: removeTableByKey.bind(null, opts),
+            insertRow: bindAndScopeChange(opts, insertRow),
+            removeRow: bindAndScopeChange(opts, removeRow),
+            insertColumn: bindAndScopeChange(opts, insertColumn),
+            removeColumn: bindAndScopeChange(opts, removeColumn),
+            removeTable: bindAndScopeChange(opts, removeTable),
+            moveSelection: bindAndScopeChange(opts, moveSelection),
+            moveSelectionBy: bindAndScopeChange(opts, moveSelectionBy)
+        }
+    };
+}
+
+/**
+ * Bind a change to given options, and scope it to act only inside a table
+ */
+function bindAndScopeChange(opts: Options, fn: *): * {
+    return (change, ...args) => {
+        const { value } = change;
+
+        if (!isSelectionInTable(opts, value)) {
+            return change;
+        }
+
+        // $FlowFixMe
+        return fn(...[opts, change].concat(args));
+    };
+}
+
+export default core;

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

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onKeyDown = exports.onUpDown = exports.onBackspace = exports.onTab = exports.onModEnter = exports.onEnter = undefined;
+
+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);
+
+var _onKeyDown = require('./onKeyDown');
+
+var _onKeyDown2 = _interopRequireDefault(_onKeyDown);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.onEnter = _onEnter2.default;
+exports.onModEnter = _onModEnter2.default;
+exports.onTab = _onTab2.default;
+exports.onBackspace = _onBackspace2.default;
+exports.onUpDown = _onUpDown2.default;
+exports.onKeyDown = _onKeyDown2.default;

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

@@ -0,0 +1,8 @@
+import onEnter from './onEnter';
+import onModEnter from './onModEnter';
+import onTab from './onTab';
+import onBackspace from './onBackspace';
+import onUpDown from './onUpDown';
+import onKeyDown from './onKeyDown';
+
+export { onEnter, onModEnter, onTab, onBackspace, onUpDown, onKeyDown };

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

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _changes = require('../changes');
+
+function onBackspace(event, change, editor, opts) {
+    var value = change.value;
+    var startBlock = value.startBlock,
+        startOffset = value.startOffset,
+        isCollapsed = value.isCollapsed,
+        endBlock = value.endBlock,
+        document = value.document;
+
+
+    var startCell = document.getClosest(startBlock.key, opts.isCell);
+    var endCell = document.getClosest(endBlock.key, opts.isCell);
+
+    var startBlockIndex = startCell.nodes.findIndex(function (block) {
+        return 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();
+
+    var blocks = value.blocks;
+
+    // Get all cells that contains the selection
+
+    var cells = blocks.map(function (node) {
+        return node.type === opts.typeCell ? node : document.getClosest(node.key, function (a) {
+            return 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
+    var ignoreFirstCell = value.selection.collapseToStart().isAtEndOf(cells.first());
+    var ignoreLastCell = value.selection.collapseToEnd().isAtStartOf(cells.last());
+
+    var cellsToClear = cells;
+    if (ignoreFirstCell) {
+        cellsToClear = cellsToClear.rest();
+    }
+    if (ignoreLastCell) {
+        cellsToClear = cellsToClear.butLast();
+    }
+
+    // Clear all the selection
+    cellsToClear.forEach(function (cell) {
+        return (0, _changes.clearCell)(opts, change, cell);
+    });
+
+    // Update the selection properly, and avoid reset of selection
+    var updatedStartCell = change.value.document.getDescendant(cellsToClear.first().key);
+    return change.collapseToStartOf(updatedStartCell);
+}
+
+exports.default = onBackspace;

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;