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

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

@@ -0,0 +1,46 @@
+// @flow
+import { type Change, type Block } from 'slate';
+
+import { TablePosition, createCell } from '../utils';
+import moveSelection from './moveSelection';
+
+import type Options from '../options';
+
+/**
+ * Insert a new column in current table
+ */
+function insertColumn(
+    opts: Options,
+    change: Change,
+    at?: number, // Column index
+    getCell?: (column: number, row: number) => Block
+): Change {
+    const { value } = change;
+    const { startKey } = value;
+
+    const pos = TablePosition.create(opts, value.document, startKey);
+    const { table } = pos;
+
+    const columnIndex =
+        typeof at === 'undefined' ? pos.getColumnIndex() + 1 : at;
+
+    // Insert the new cell
+    table.nodes.forEach((row, rowIndex) => {
+        const newCell = getCell
+            ? getCell(columnIndex, rowIndex)
+            : createCell(opts);
+        change.insertNodeByKey(row.key, columnIndex, newCell, {
+            normalize: false
+        });
+    });
+
+    // Update the selection (not doing can break the undo)
+    return moveSelection(
+        opts,
+        change,
+        pos.getColumnIndex() + 1,
+        pos.getRowIndex()
+    );
+}
+
+export default insertColumn;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Insert a new row in current table
+ */
+function insertRow(opts, change, at, // row index
+getRow // Generate the row yourself
+) {
+    var value = change.value;
+    var startKey = value.startKey;
+
+
+    var pos = _utils.TablePosition.create(opts, value.document, startKey);
+    var table = pos.table;
+
+    // Create a new row with the right count of cells
+
+    var columns = table.nodes.get(0).nodes.size;
+    var newRow = getRow ? getRow(columns) : (0, _utils.createRow)(opts, columns);
+
+    if (typeof at === 'undefined') {
+        at = pos.getRowIndex() + 1;
+    }
+
+    return change.insertNodeByKey(table.key, at, newRow).collapseToEndOf(newRow.nodes.get(pos.getColumnIndex()));
+}
+
+exports.default = insertRow;

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

@@ -0,0 +1,35 @@
+// @flow
+import { type Change, type Block } from 'slate';
+
+import { TablePosition, createRow } from '../utils';
+import type Options from '../options';
+
+/**
+ * Insert a new row in current table
+ */
+function insertRow(
+    opts: Options,
+    change: Change,
+    at?: number, // row index
+    getRow?: (columns: number) => Block // Generate the row yourself
+) {
+    const { value } = change;
+    const { startKey } = value;
+
+    const pos = TablePosition.create(opts, value.document, startKey);
+    const { table } = pos;
+
+    // Create a new row with the right count of cells
+    const columns = table.nodes.get(0).nodes.size;
+    const newRow = getRow ? getRow(columns) : createRow(opts, columns);
+
+    if (typeof at === 'undefined') {
+        at = pos.getRowIndex() + 1;
+    }
+
+    return change
+        .insertNodeByKey(table.key, at, newRow)
+        .collapseToEndOf(newRow.nodes.get(pos.getColumnIndex()));
+}
+
+export default insertRow;

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

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Insert a new table
+ */
+function insertTable(opts, change) {
+    var columns = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;
+    var rows = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 2;
+    var getCellContent = arguments[4];
+    var value = change.value;
+
+
+    if (!value.selection.startKey) return change;
+
+    // Create the table node
+    var table = (0, _utils.createTable)(opts, columns, rows, getCellContent);
+
+    return change.insertBlock(table);
+}
+
+exports.default = insertTable;

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

@@ -0,0 +1,27 @@
+// @flow
+import { type Change, type Node } from 'slate';
+
+import { createTable } from '../utils';
+import type Options from '../options';
+
+/**
+ * Insert a new table
+ */
+function insertTable(
+    opts: Options,
+    change: Change,
+    columns?: number = 2,
+    rows?: number = 2,
+    getCellContent?: (column: number, row: number) => Node[]
+): Change {
+    const { value } = change;
+
+    if (!value.selection.startKey) return change;
+
+    // Create the table node
+    const table = createTable(opts, columns, rows, getCellContent);
+
+    return change.insertBlock(table);
+}
+
+export default insertTable;

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

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+/**
+ * Move selection to {x,y}
+ */
+function moveSelection(opts, change, x, y) {
+    var value = change.value;
+    var startKey = value.startKey;
+
+    var pos = _utils.TablePosition.create(opts, value.document, startKey);
+
+    if (!pos.isInCell()) {
+        throw new Error('moveSelection can only be applied from within a cell');
+    }
+
+    var table = pos.table;
+
+    var row = table.nodes.get(y);
+    var cell = row.nodes.get(x);
+
+    return change.collapseToStartOf(cell);
+}
+
+exports.default = moveSelection;

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

@@ -0,0 +1,31 @@
+// @flow
+import { type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import type Options from '../options';
+
+/**
+ * Move selection to {x,y}
+ */
+function moveSelection(
+    opts: Options,
+    change: Change,
+    x: number,
+    y: number
+): Change {
+    const { value } = change;
+    const { startKey } = value;
+    const pos = TablePosition.create(opts, value.document, startKey);
+
+    if (!pos.isInCell()) {
+        throw new Error('moveSelection can only be applied from within a cell');
+    }
+
+    const { table } = pos;
+    const row = table.nodes.get(y);
+    const cell = row.nodes.get(x);
+
+    return change.collapseToStartOf(cell);
+}
+
+export default moveSelection;

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

@@ -0,0 +1,84 @@
+'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');
+
+/**
+ * Move selection by a {x,y} relative movement
+ */
+function moveSelectionBy(opts, change, x, //  Move horizontally by x
+y // Move vertically by y
+) {
+    var value = change.value;
+    var startKey = value.startKey;
+
+    var pos = _utils.TablePosition.create(opts, value.document, startKey);
+    if (!pos.isInCell()) {
+        throw new Error('moveSelectionBy can only be applied in a cell');
+    }
+
+    var rowIndex = pos.getRowIndex();
+    var colIndex = pos.getColumnIndex();
+    var width = pos.getWidth();
+    var height = pos.getHeight();
+
+    var _normPos = normPos(x + colIndex, y + rowIndex, width, height),
+        _normPos2 = _slicedToArray(_normPos, 2),
+        absX = _normPos2[0],
+        absY = _normPos2[1];
+
+    var isGoingUp = y < 0;
+
+    if (absX === -1) {
+        // Out of table
+        return change;
+    }
+
+    var table = pos.table;
+
+    var row = table.nodes.get(absY);
+    var cell = row.nodes.get(absX);
+
+    if (isGoingUp) {
+        change.collapseToEndOf(cell);
+    } else {
+        change.collapseToStartOf(cell);
+    }
+
+    return change;
+}
+
+/**
+ * Normalize position in a table. If x is out of the row, update y accordingly.
+ * Returns [-1, -1] if the new selection is out of table
+ */
+function normPos(x, y, width, height) {
+    if (x < 0) {
+        x = width - 1;
+        y -= 1;
+    }
+
+    if (y < 0) {
+        return [-1, -1];
+    }
+
+    if (x >= width) {
+        x = 0;
+        y += 1;
+    }
+
+    if (y >= height) {
+        return [-1, -1];
+    }
+
+    return [x, y];
+}
+
+exports.default = moveSelectionBy;

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

@@ -0,0 +1,80 @@
+// @flow
+import { type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import type Options from '../options';
+
+/**
+ * Move selection by a {x,y} relative movement
+ */
+function moveSelectionBy(
+    opts: Options,
+    change: Change,
+    x: number, //  Move horizontally by x
+    y: number // Move vertically by y
+): Change {
+    const { value } = change;
+    const { startKey } = value;
+    const pos = TablePosition.create(opts, value.document, startKey);
+    if (!pos.isInCell()) {
+        throw new Error('moveSelectionBy can only be applied in a cell');
+    }
+
+    const rowIndex = pos.getRowIndex();
+    const colIndex = pos.getColumnIndex();
+    const width = pos.getWidth();
+    const height = pos.getHeight();
+
+    const [absX, absY] = normPos(x + colIndex, y + rowIndex, width, height);
+    const isGoingUp = y < 0;
+
+    if (absX === -1) {
+        // Out of table
+        return change;
+    }
+
+    const { table } = pos;
+    const row = table.nodes.get(absY);
+    const cell = row.nodes.get(absX);
+
+    if (isGoingUp) {
+        change.collapseToEndOf(cell);
+    } else {
+        change.collapseToStartOf(cell);
+    }
+
+    return change;
+}
+
+/**
+ * Normalize position in a table. If x is out of the row, update y accordingly.
+ * Returns [-1, -1] if the new selection is out of table
+ */
+function normPos(
+    x: number,
+    y: number,
+    width: number,
+    height: number
+): number[] {
+    if (x < 0) {
+        x = width - 1;
+        y -= 1;
+    }
+
+    if (y < 0) {
+        return [-1, -1];
+    }
+
+    if (x >= width) {
+        x = 0;
+        y += 1;
+    }
+
+    if (y >= height) {
+        return [-1, -1];
+    }
+
+    return [x, y];
+}
+
+export default moveSelectionBy;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+var _removeColumnByKey = require('./removeColumnByKey');
+
+var _removeColumnByKey2 = _interopRequireDefault(_removeColumnByKey);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Delete current column in a table
+ */
+function removeColumn(opts, change, at) {
+    var value = change.value;
+    var startKey = value.startKey;
+
+
+    var pos = _utils.TablePosition.create(opts, value.document, startKey);
+
+    var columnKey = void 0;
+    if (typeof at === 'undefined') {
+        columnKey = pos.cell.key;
+    } else {
+        columnKey = pos.row.nodes.get(at).key;
+    }
+
+    return (0, _removeColumnByKey2.default)(opts, change, columnKey);
+}
+exports.default = removeColumn;

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

@@ -0,0 +1,28 @@
+// @flow
+import { type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import removeColumnByKey from './removeColumnByKey';
+
+import type Options from '../options';
+
+/**
+ * Delete current column in a table
+ */
+function removeColumn(opts: Options, change: Change, at: number): Change {
+    const { value } = change;
+    const { startKey } = value;
+
+    const pos = TablePosition.create(opts, value.document, startKey);
+
+    let columnKey;
+    if (typeof at === 'undefined') {
+        columnKey = pos.cell.key;
+    } else {
+        columnKey = pos.row.nodes.get(at).key;
+    }
+
+    return removeColumnByKey(opts, change, columnKey);
+}
+
+export default removeColumn;

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

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+var _clearCell = require('./clearCell');
+
+var _clearCell2 = _interopRequireDefault(_clearCell);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Delete the column associated with the given cell key in a table
+ */
+function removeColumnByKey(opts, change, key) {
+    var value = change.value;
+
+
+    var pos = _utils.TablePosition.create(opts, value.document, key);
+    var table = pos.table;
+
+
+    var colIndex = pos.getColumnIndex();
+
+    var rows = table.nodes;
+
+    // Remove the cell from every row
+    if (pos.getWidth() > 1) {
+        rows.forEach(function (row) {
+            var cell = row.nodes.get(colIndex);
+            change.removeNodeByKey(cell.key, { normalize: false });
+        });
+    } else {
+        // If last column, clear text in cells instead
+        rows.forEach(function (row) {
+            row.nodes.forEach(function (cell) {
+                cell.nodes.forEach(function (node) {
+                    return (0, _clearCell2.default)(opts, change, cell);
+                });
+            });
+        });
+    }
+
+    // Replace the table
+    return change;
+}
+exports.default = removeColumnByKey;

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

@@ -0,0 +1,40 @@
+// @flow
+import { type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import clearCell from './clearCell';
+import type Options from '../options';
+
+/**
+ * Delete the column associated with the given cell key in a table
+ */
+function removeColumnByKey(opts: Options, change: Change, key: string): Change {
+    const { value } = change;
+
+    const pos = TablePosition.create(opts, value.document, key);
+    const { table } = pos;
+
+    const colIndex = pos.getColumnIndex();
+
+    const rows = table.nodes;
+
+    // Remove the cell from every row
+    if (pos.getWidth() > 1) {
+        rows.forEach(row => {
+            const cell = row.nodes.get(colIndex);
+            change.removeNodeByKey(cell.key, { normalize: false });
+        });
+    } else {
+        // If last column, clear text in cells instead
+        rows.forEach(row => {
+            row.nodes.forEach(cell => {
+                cell.nodes.forEach(node => clearCell(opts, change, cell));
+            });
+        });
+    }
+
+    // Replace the table
+    return change;
+}
+
+export default removeColumnByKey;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+var _removeRowByKey = require('./removeRowByKey');
+
+var _removeRowByKey2 = _interopRequireDefault(_removeRowByKey);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Remove current row in a table. Clear it if last remaining row
+ */
+function removeRow(opts, change, at) {
+    var value = change.value;
+    var startKey = value.startKey;
+
+
+    var pos = _utils.TablePosition.create(opts, value.document, startKey);
+
+    var rowKey = void 0;
+    if (typeof at === 'undefined') {
+        rowKey = pos.row.key;
+    } else {
+        rowKey = pos.table.nodes.get(at).key;
+    }
+
+    return (0, _removeRowByKey2.default)(opts, change, rowKey);
+}
+exports.default = removeRow;

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

@@ -0,0 +1,27 @@
+// @flow
+import { type Change } from 'slate';
+
+import { TablePosition } from '../utils';
+import type Options from '../options';
+import removeRowByKey from './removeRowByKey';
+
+/**
+ * Remove current row in a table. Clear it if last remaining row
+ */
+function removeRow(opts: Options, change: Change, at: number): Change {
+    const { value } = change;
+    const { startKey } = value;
+
+    const pos = TablePosition.create(opts, value.document, startKey);
+
+    let rowKey;
+    if (typeof at === 'undefined') {
+        rowKey = pos.row.key;
+    } else {
+        rowKey = pos.table.nodes.get(at).key;
+    }
+
+    return removeRowByKey(opts, change, rowKey);
+}
+
+export default removeRow;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _utils = require('../utils');
+
+var _clearCell = require('./clearCell');
+
+var _clearCell2 = _interopRequireDefault(_clearCell);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Remove the row associated to a given key in a table.
+ * Clear thw row if last remaining row
+ */
+function removeRowByKey(opts, change, key) {
+    var value = change.value;
+
+
+    var pos = _utils.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(function (cell) {
+            cell.nodes.forEach(function (node) {
+                return (0, _clearCell2.default)(opts, change, cell);
+            });
+        });
+    }
+
+    return change;
+}
+exports.default = removeRowByKey;