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

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

@@ -0,0 +1,33 @@
+// @flow
+import { Range } from 'immutable';
+import { Block, type Node } from 'slate';
+
+import type Options from '../options';
+import createRow from './createRow';
+
+/**
+ * Create a table
+ */
+function createTable(
+    opts: Options,
+    columns: number,
+    rows: number,
+    getCellContent?: (row: number, column: number) => Node[]
+): Block {
+    const rowNodes = Range(0, rows)
+        .map(i =>
+            createRow(
+                opts,
+                columns,
+                getCellContent ? getCellContent.bind(null, i) : undefined
+            )
+        )
+        .toList();
+
+    return Block.create({
+        type: opts.typeTable,
+        nodes: rowNodes
+    });
+}
+
+export default createTable;

package/configure/node_modules/slate-edit-table/dist/utils/forEachCells.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+/**
+ * Run the given function against each cells of the table
+ */
+function forEachCells(opts,
+// The table
+table, fn) {
+    return table.nodes.forEach(function (row, rowIndex) {
+        return row.nodes.forEach(function (cell, columnIndex) {
+            return fn(cell, rowIndex, columnIndex);
+        });
+    });
+}
+exports.default = forEachCells;

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

@@ -0,0 +1,22 @@
+// @flow
+import { type Block } from 'slate';
+
+import type Options from '../options';
+
+/**
+ * Run the given function against each cells of the table
+ */
+function forEachCells(
+    opts: Options,
+    // The table
+    table: Block,
+    fn: (cell: Block, row: number, column: number) => any
+): void {
+    return table.nodes.forEach((row, rowIndex) =>
+        row.nodes.forEach((cell, columnIndex) =>
+            fn(cell, rowIndex, columnIndex)
+        )
+    );
+}
+
+export default forEachCells;

package/configure/node_modules/slate-edit-table/dist/utils/getCellsAtColumn.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+require('immutable');
+
+/**
+ * Returns the list of cells at the given column index
+ */
+function getCellsAtColumn(opts,
+// The table
+table, columnIndex) {
+    return table.nodes.map(function (row) {
+        return row.nodes.get(columnIndex);
+    });
+}
+
+exports.default = getCellsAtColumn;

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

@@ -0,0 +1,19 @@
+// @flow
+import { type Block } from 'slate';
+import { type List } from 'immutable';
+
+import type Options from '../options';
+
+/**
+ * Returns the list of cells at the given column index
+ */
+function getCellsAtColumn(
+    opts: Options,
+    // The table
+    table: Block,
+    columnIndex: number
+): List<Block> {
+    return table.nodes.map(row => row.nodes.get(columnIndex));
+}
+
+export default getCellsAtColumn;

package/configure/node_modules/slate-edit-table/dist/utils/getCellsAtRow.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+require('immutable');
+
+/**
+ * Returns the list of cells at the given row index
+ */
+function getCellsAtRow(opts,
+// The table
+table, rowIndex) {
+    return table.nodes.get(rowIndex).nodes;
+}
+
+exports.default = getCellsAtRow;

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

@@ -0,0 +1,19 @@
+// @flow
+import { type Block } from 'slate';
+import { type List } from 'immutable';
+
+import type Options from '../options';
+
+/**
+ * Returns the list of cells at the given row index
+ */
+function getCellsAtRow(
+    opts: Options,
+    // The table
+    table: Block,
+    rowIndex: number
+): List<Block> {
+    return table.nodes.get(rowIndex).nodes;
+}
+
+export default getCellsAtRow;

package/configure/node_modules/slate-edit-table/dist/utils/getPosition.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _TablePosition = require('./TablePosition');
+
+var _TablePosition2 = _interopRequireDefault(_TablePosition);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * The position of the selection start block, in the current table
+ */
+function getPosition(opts,
+// The current value
+value) {
+    return _TablePosition2.default.create(opts, value.document, value.startKey);
+}
+
+exports.default = getPosition;

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

@@ -0,0 +1,19 @@
+// @flow
+import { type Value } from 'slate';
+
+import type Options from '../options';
+
+import TablePosition from './TablePosition';
+
+/**
+ * The position of the selection start block, in the current table
+ */
+function getPosition(
+    opts: Options,
+    // The current value
+    value: Value
+): TablePosition {
+    return TablePosition.create(opts, value.document, value.startKey);
+}
+
+export default getPosition;

package/configure/node_modules/slate-edit-table/dist/utils/getPositionByKey.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _TablePosition = require('./TablePosition');
+
+var _TablePosition2 = _interopRequireDefault(_TablePosition);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+ * The position of a particular node, in the current table
+ */
+function getPositionByKey(opts,
+// The current value
+containerNode,
+// Key of the node in desired position
+key) {
+    return _TablePosition2.default.create(opts, containerNode, key);
+}
+
+exports.default = getPositionByKey;

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

@@ -0,0 +1,21 @@
+// @flow
+import { type Node } from 'slate';
+
+import type Options from '../options';
+
+import TablePosition from './TablePosition';
+
+/*
+ * The position of a particular node, in the current table
+ */
+function getPositionByKey(
+    opts: Options,
+    // The current value
+    containerNode: Node,
+    // Key of the node in desired position
+    key: string
+): TablePosition {
+    return TablePosition.create(opts, containerNode, key);
+}
+
+export default getPositionByKey;

package/configure/node_modules/slate-edit-table/dist/utils/getRow.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+require('slate');
+
+var _TablePosition = require('./TablePosition');
+
+var _TablePosition2 = _interopRequireDefault(_TablePosition);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * The position of the selection start block, in the current table
+ */
+function getPosition(opts,
+// The current value
+value) {
+    return _TablePosition2.default.create(opts, value.document, value.startKey);
+}
+
+exports.default = getPosition;

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

@@ -0,0 +1,19 @@
+// @flow
+import { type Value } from 'slate';
+
+import type Options from '../options';
+
+import TablePosition from './TablePosition';
+
+/**
+ * The position of the selection start block, in the current table
+ */
+function getPosition(
+    opts: Options,
+    // The current value
+    value: Value
+): TablePosition {
+    return TablePosition.create(opts, value.document, value.startKey);
+}
+
+export default getPosition;

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

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.createTable = exports.createRow = exports.createCell = exports.TablePosition = exports.isSelectionOutOfTable = exports.isSelectionInTable = exports.getCellsAtColumn = exports.getCellsAtRow = exports.forEachCells = exports.getPositionByKey = exports.getPosition = undefined;
+
+var _createCell = require('./createCell');
+
+var _createCell2 = _interopRequireDefault(_createCell);
+
+var _createRow = require('./createRow');
+
+var _createRow2 = _interopRequireDefault(_createRow);
+
+var _createTable = require('./createTable');
+
+var _createTable2 = _interopRequireDefault(_createTable);
+
+var _getPosition = require('./getPosition');
+
+var _getPosition2 = _interopRequireDefault(_getPosition);
+
+var _getPositionByKey = require('./getPositionByKey');
+
+var _getPositionByKey2 = _interopRequireDefault(_getPositionByKey);
+
+var _isSelectionInTable = require('./isSelectionInTable');
+
+var _isSelectionInTable2 = _interopRequireDefault(_isSelectionInTable);
+
+var _isSelectionOutOfTable = require('./isSelectionOutOfTable');
+
+var _isSelectionOutOfTable2 = _interopRequireDefault(_isSelectionOutOfTable);
+
+var _TablePosition = require('./TablePosition');
+
+var _TablePosition2 = _interopRequireDefault(_TablePosition);
+
+var _forEachCells = require('./forEachCells');
+
+var _forEachCells2 = _interopRequireDefault(_forEachCells);
+
+var _getCellsAtRow = require('./getCellsAtRow');
+
+var _getCellsAtRow2 = _interopRequireDefault(_getCellsAtRow);
+
+var _getCellsAtColumn = require('./getCellsAtColumn');
+
+var _getCellsAtColumn2 = _interopRequireDefault(_getCellsAtColumn);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.getPosition = _getPosition2.default;
+exports.getPositionByKey = _getPositionByKey2.default;
+exports.forEachCells = _forEachCells2.default;
+exports.getCellsAtRow = _getCellsAtRow2.default;
+exports.getCellsAtColumn = _getCellsAtColumn2.default;
+exports.isSelectionInTable = _isSelectionInTable2.default;
+exports.isSelectionOutOfTable = _isSelectionOutOfTable2.default;
+exports.TablePosition = _TablePosition2.default;
+exports.createCell = _createCell2.default;
+exports.createRow = _createRow2.default;
+exports.createTable = _createTable2.default;

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

@@ -0,0 +1,25 @@
+import createCell from './createCell';
+import createRow from './createRow';
+import createTable from './createTable';
+import getPosition from './getPosition';
+import getPositionByKey from './getPositionByKey';
+import isSelectionInTable from './isSelectionInTable';
+import isSelectionOutOfTable from './isSelectionOutOfTable';
+import TablePosition from './TablePosition';
+import forEachCells from './forEachCells';
+import getCellsAtRow from './getCellsAtRow';
+import getCellsAtColumn from './getCellsAtColumn';
+
+export {
+    getPosition,
+    getPositionByKey,
+    forEachCells,
+    getCellsAtRow,
+    getCellsAtColumn,
+    isSelectionInTable,
+    isSelectionOutOfTable,
+    TablePosition,
+    createCell,
+    createRow,
+    createTable
+};

package/configure/node_modules/slate-edit-table/dist/utils/isSelectionInTable.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _TablePosition = require('./TablePosition');
+
+var _TablePosition2 = _interopRequireDefault(_TablePosition);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Is the selection in a table
+ */
+function isSelectionInTable(opts, value) {
+    if (!value.selection.startKey) return false;
+
+    var startKey = value.startKey,
+        endKey = value.endKey;
+
+    var startPosition = _TablePosition2.default.create(opts, value.document, startKey);
+    var endPosition = _TablePosition2.default.create(opts, value.document, endKey);
+
+    // Only handle events in tables
+    if (!startPosition.isInTable() || !endPosition.isInTable()) {
+        return false;
+    }
+
+    // Inside the same table
+    return startPosition.table === endPosition.table;
+}
+
+exports.default = isSelectionInTable;

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

@@ -0,0 +1,27 @@
+// @flow
+
+import type { Value } from 'slate';
+
+import TablePosition from './TablePosition';
+import type Options from '../options';
+
+/**
+ * Is the selection in a table
+ */
+function isSelectionInTable(opts: Options, value: Value): boolean {
+    if (!value.selection.startKey) return false;
+
+    const { startKey, endKey } = value;
+    const startPosition = TablePosition.create(opts, value.document, startKey);
+    const endPosition = TablePosition.create(opts, value.document, endKey);
+
+    // Only handle events in tables
+    if (!startPosition.isInTable() || !endPosition.isInTable()) {
+        return false;
+    }
+
+    // Inside the same table
+    return startPosition.table === endPosition.table;
+}
+
+export default isSelectionInTable;

package/configure/node_modules/slate-edit-table/dist/utils/isSelectionOutOfTable.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _TablePosition = require('./TablePosition');
+
+var _TablePosition2 = _interopRequireDefault(_TablePosition);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Are the selection start and end outside a table.
+ */
+function isSelectionOutOfTable(opts, value) {
+    if (!value.selection.startKey) return false;
+
+    var startKey = value.startKey,
+        endKey = value.endKey;
+
+
+    var startPosition = _TablePosition2.default.create(opts, value.document, startKey);
+    var endPosition = _TablePosition2.default.create(opts, value.document, endKey);
+
+    // Only handle events in tables
+    return !startPosition.isInTable() && !endPosition.isInTable();
+}
+
+exports.default = isSelectionOutOfTable;

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

@@ -0,0 +1,23 @@
+// @flow
+
+import type { Value } from 'slate';
+
+import TablePosition from './TablePosition';
+import type Options from '../options';
+
+/**
+ * Are the selection start and end outside a table.
+ */
+function isSelectionOutOfTable(opts: Options, value: Value): boolean {
+    if (!value.selection.startKey) return false;
+
+    const { startKey, endKey } = value;
+
+    const startPosition = TablePosition.create(opts, value.document, startKey);
+    const endPosition = TablePosition.create(opts, value.document, endKey);
+
+    // Only handle events in tables
+    return !startPosition.isInTable() && !endPosition.isInTable();
+}
+
+export default isSelectionOutOfTable;

package/configure/node_modules/slate-edit-table/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-table/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-table/dist/validation/schema.js

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _slate = require('slate');
+
+var _slateSchemaViolations = require('slate-schema-violations');
+
+var _utils = require('../utils');
+
+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; }
+
+/*
+ * Returns a schema definition for the plugin
+ */
+function schema(opts) {
+    var _blocks;
+
+    return {
+        blocks: (_blocks = {}, _defineProperty(_blocks, opts.typeTable, {
+            nodes: [{ types: [opts.typeRow] }]
+        }), _defineProperty(_blocks, opts.typeRow, {
+            nodes: [{ types: [opts.typeCell] }],
+            parent: { types: [opts.typeTable] },
+            normalize: function normalize(change, violation, context) {
+                switch (violation) {
+                    case _slateSchemaViolations.CHILD_TYPE_INVALID:
+                        return onlyCellsInRow(opts, change, context);
+                    case _slateSchemaViolations.PARENT_TYPE_INVALID:
+                        return rowOnlyInTable(opts, change, context);
+                    default:
+                        return undefined;
+                }
+            }
+        }), _defineProperty(_blocks, opts.typeCell, {
+            nodes: [{ objects: ['block'] }],
+            parent: { types: [opts.typeRow] },
+            normalize: function normalize(change, violation, context) {
+                switch (violation) {
+                    case _slateSchemaViolations.CHILD_OBJECT_INVALID:
+                        return onlyBlocksInCell(opts, change, context);
+                    case _slateSchemaViolations.PARENT_TYPE_INVALID:
+                        return cellOnlyInRow(opts, change, context);
+                    default:
+                        return undefined;
+                }
+            }
+        }), _blocks)
+    };
+}
+
+/*
+ * A row's children must be cells.
+ * If they're not then we wrap them within a cell.
+ */
+function onlyCellsInRow(opts, change, context) {
+    var cell = (0, _utils.createCell)(opts, []);
+    var index = context.node.nodes.findIndex(function (child) {
+        return child.key === context.child.key;
+    });
+    change.insertNodeByKey(context.node.key, index, cell, { normalize: false });
+    change.moveNodeByKey(context.child.key, cell.key, 0, { normalize: false });
+}
+
+/*
+ * Rows can't live outside a table, if one is found then we wrap it within a table.
+ */
+function rowOnlyInTable(opts, change, context) {
+    return change.wrapBlockByKey(context.node.key, opts.typeTable);
+}
+
+/*
+ * A cell's children must be "block"s.
+ * If they're not then we wrap them within a block with a type of opts.typeContent
+ */
+function onlyBlocksInCell(opts, change, context) {
+    var block = _slate.Block.create({
+        type: opts.typeContent
+    });
+    change.insertNodeByKey(context.node.key, 0, block, { normalize: false });
+
+    var inlines = context.node.nodes.filter(function (node) {
+        return node.object !== 'block';
+    });
+    inlines.forEach(function (inline, index) {
+        change.moveNodeByKey(inline.key, block.key, index, {
+            normalize: false
+        });
+    });
+}
+
+/*
+ * Cells can't live outside a row, if one is found then we wrap it within a row.
+ */
+function cellOnlyInRow(opts, change, context) {
+    return change.wrapBlockByKey(context.node.key, opts.typeRow);
+}
+
+exports.default = schema;