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

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

@@ -0,0 +1,42 @@
+// @flow
+
+import { Record } from 'immutable';
+import type { Node } from 'slate';
+
+export type OptionsFormat = {
+    typeTable?: string,
+    typeRow?: string,
+    typeCell?: string,
+    typeContent?: string,
+    exitBlockType?: string
+};
+
+/**
+ * The plugin options
+ */
+class Options extends Record({
+    typeTable: 'table',
+    typeRow: 'table_row',
+    typeCell: 'table_cell',
+    typeContent: 'paragraph',
+    exitBlockType: 'paragraph'
+}) {
+    // The type of table blocks
+    typeTable: string;
+    // The type of row blocks
+    typeRow: string;
+    // The type of cell blocks
+    typeCell: string;
+    // The default type for blocks in cells
+    typeContent: string;
+    // The type of block inserted when exiting
+    exitBlockType: string;
+
+    /*
+     * Return a node filter to find a cell.
+     */
+    isCell = (node: Node): boolean =>
+        node.object == 'block' && node.type == this.typeCell;
+}
+
+export default Options;

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

@@ -0,0 +1,306 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _immutable = require('immutable');
+
+var _slate = require('slate');
+
+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; }
+
+var TablePosition = function (_Record) {
+    _inherits(TablePosition, _Record);
+
+    function TablePosition() {
+        _classCallCheck(this, TablePosition);
+
+        return _possibleConstructorReturn(this, (TablePosition.__proto__ || Object.getPrototypeOf(TablePosition)).apply(this, arguments));
+    }
+
+    _createClass(TablePosition, [{
+        key: 'isInCell',
+
+
+        /**
+         * Check to see if this position is within a cell
+         */
+        value: function isInCell() {
+            return Boolean(this.cellBlock);
+        }
+
+        /**
+         * Check to see if this position is within a row
+         */
+
+    }, {
+        key: 'isInRow',
+        value: function isInRow() {
+            return Boolean(this.rowBlock);
+        }
+
+        /**
+         * Check to see if this position is within a table
+         */
+
+    }, {
+        key: 'isInTable',
+        value: function isInTable() {
+            return Boolean(this.tableBlock);
+        }
+
+        /**
+         * Check to see if this position is at the top of the cell.
+         */
+
+    }, {
+        key: 'isTopOfCell',
+        value: function isTopOfCell() {
+            var contentBlock = this.contentBlock,
+                cellBlock = this.cellBlock;
+
+
+            if (!contentBlock || !cellBlock) {
+                return false;
+            }
+
+            var nodes = cellBlock.nodes;
+
+            var index = nodes.findIndex(function (block) {
+                return block.key == contentBlock.key;
+            });
+
+            return index == 0;
+        }
+
+        /**
+         * Check to see if this position is at the bottom of the cell.
+         */
+
+    }, {
+        key: 'isBottomOfCell',
+        value: function isBottomOfCell() {
+            var contentBlock = this.contentBlock,
+                cellBlock = this.cellBlock;
+
+
+            if (!contentBlock || !cellBlock) {
+                return false;
+            }
+
+            var nodes = cellBlock.nodes;
+
+            var index = nodes.findIndex(function (block) {
+                return block.key == contentBlock.key;
+            });
+
+            return index == nodes.size - 1;
+        }
+
+        /**
+         * Get count of columns
+         */
+
+    }, {
+        key: 'getWidth',
+        value: function getWidth() {
+            var table = this.table;
+
+            var rows = table.nodes;
+            var cells = rows.get(0).nodes;
+
+            return cells.size;
+        }
+
+        /**
+         * Get count of rows
+         */
+
+    }, {
+        key: 'getHeight',
+        value: function getHeight() {
+            var table = this.table;
+
+            var rows = table.nodes;
+
+            return rows.size;
+        }
+
+        /**
+         * Get index of current row in the table.
+         */
+
+    }, {
+        key: 'getRowIndex',
+        value: function getRowIndex() {
+            var table = this.table,
+                row = this.row;
+
+            var rows = table.nodes;
+
+            return rows.findIndex(function (x) {
+                return x === row;
+            });
+        }
+
+        /**
+         * Get index of current column in the row.
+         */
+
+    }, {
+        key: 'getColumnIndex',
+        value: function getColumnIndex() {
+            var row = this.row,
+                cell = this.cell;
+
+            var cells = row.nodes;
+
+            return cells.findIndex(function (x) {
+                return x === cell;
+            });
+        }
+
+        /**
+         * True if on first cell of the table
+         */
+
+    }, {
+        key: 'isFirstCell',
+        value: function isFirstCell() {
+            return this.isFirstRow() && this.isFirstColumn();
+        }
+
+        /**
+         * True if on last cell of the table
+         */
+
+    }, {
+        key: 'isLastCell',
+        value: function isLastCell() {
+            return this.isLastRow() && this.isLastColumn();
+        }
+
+        /**
+         * True if on first row
+         */
+
+    }, {
+        key: 'isFirstRow',
+        value: function isFirstRow() {
+            return this.getRowIndex() === 0;
+        }
+
+        /**
+         * True if on last row
+         */
+
+    }, {
+        key: 'isLastRow',
+        value: function isLastRow() {
+            return this.getRowIndex() === this.getHeight() - 1;
+        }
+
+        /**
+         * True if on first column
+         */
+
+    }, {
+        key: 'isFirstColumn',
+        value: function isFirstColumn() {
+            return this.getColumnIndex() === 0;
+        }
+
+        /**
+         * True if on last column
+         */
+
+    }, {
+        key: 'isLastColumn',
+        value: function isLastColumn() {
+            return this.getColumnIndex() === this.getWidth() - 1;
+        }
+    }, {
+        key: 'table',
+        get: function get() {
+            if (!this.tableBlock) {
+                throw new Error('Not in a table');
+            }
+            return this.tableBlock;
+        }
+    }, {
+        key: 'row',
+        get: function get() {
+            if (!this.rowBlock) {
+                throw new Error('Not in a row');
+            }
+            return this.rowBlock;
+        }
+    }, {
+        key: 'cell',
+        get: function get() {
+            if (!this.cellBlock) {
+                throw new Error('Not in a cell');
+            }
+            return this.cellBlock;
+        }
+    }], [{
+        key: 'create',
+
+
+        /**
+         * Create a new instance of a TablePosition from a Slate document
+         * and a node key.
+         */
+
+
+        // Block for current cell
+
+        // Block container for the table
+        value: function create(opts, containerNode, key) {
+            var node = containerNode.getDescendant(key);
+            var ancestors = containerNode.getAncestors(key).push(node);
+            var tableBlock = ancestors.findLast(function (p) {
+                return p.type === opts.typeTable;
+            });
+            var rowBlock = ancestors.findLast(function (p) {
+                return p.type === opts.typeRow;
+            });
+
+            var cellBlock = ancestors.findLast(function (p) {
+                return p.type === opts.typeCell;
+            });
+            var contentBlock = ancestors.skipUntil(function (ancestor) {
+                return ancestor === cellBlock;
+            }).skip(1).first();
+
+            return new TablePosition({
+                tableBlock: tableBlock,
+                rowBlock: rowBlock,
+                cellBlock: cellBlock,
+                contentBlock: contentBlock
+            });
+        }
+
+        // Current content block in the cell
+
+
+        // Block for current row
+
+    }]);
+
+    return TablePosition;
+}((0, _immutable.Record)({
+    tableBlock: null,
+    rowBlock: null,
+    cellBlock: null,
+    contentBlock: null
+}));
+
+exports.default = TablePosition;

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

@@ -0,0 +1,211 @@
+// @flow
+import { Record } from 'immutable';
+import { Block, type Node } from 'slate';
+
+import type Options from '../options';
+
+class TablePosition extends Record({
+    tableBlock: null,
+    rowBlock: null,
+    cellBlock: null,
+    contentBlock: null
+}) {
+    // Block container for the table
+    tableBlock: ?Block;
+
+    // Block for current row
+    rowBlock: ?Block;
+
+    // Block for current cell
+    cellBlock: ?Block;
+
+    // Current content block in the cell
+    contentBlock: ?Block;
+
+    /**
+     * Create a new instance of a TablePosition from a Slate document
+     * and a node key.
+     */
+    static create(
+        opts: Options,
+        containerNode: Node,
+        key: string
+    ): TablePosition {
+        const node = containerNode.getDescendant(key);
+        const ancestors = containerNode.getAncestors(key).push(node);
+        const tableBlock = ancestors.findLast(p => p.type === opts.typeTable);
+        const rowBlock = ancestors.findLast(p => p.type === opts.typeRow);
+
+        const cellBlock = ancestors.findLast(p => p.type === opts.typeCell);
+        const contentBlock = ancestors
+            .skipUntil(ancestor => ancestor === cellBlock)
+            .skip(1)
+            .first();
+
+        return new TablePosition({
+            tableBlock,
+            rowBlock,
+            cellBlock,
+            contentBlock
+        });
+    }
+
+    get table(): Block {
+        if (!this.tableBlock) {
+            throw new Error('Not in a table');
+        }
+        return this.tableBlock;
+    }
+
+    get row(): Block {
+        if (!this.rowBlock) {
+            throw new Error('Not in a row');
+        }
+        return this.rowBlock;
+    }
+
+    get cell(): Block {
+        if (!this.cellBlock) {
+            throw new Error('Not in a cell');
+        }
+        return this.cellBlock;
+    }
+
+    /**
+     * Check to see if this position is within a cell
+     */
+    isInCell(): boolean {
+        return Boolean(this.cellBlock);
+    }
+
+    /**
+     * Check to see if this position is within a row
+     */
+    isInRow(): boolean {
+        return Boolean(this.rowBlock);
+    }
+
+    /**
+     * Check to see if this position is within a table
+     */
+    isInTable(): boolean {
+        return Boolean(this.tableBlock);
+    }
+
+    /**
+     * Check to see if this position is at the top of the cell.
+     */
+    isTopOfCell(): boolean {
+        const { contentBlock, cellBlock } = this;
+
+        if (!contentBlock || !cellBlock) {
+            return false;
+        }
+
+        const { nodes } = cellBlock;
+        const index = nodes.findIndex(block => block.key == contentBlock.key);
+
+        return index == 0;
+    }
+
+    /**
+     * Check to see if this position is at the bottom of the cell.
+     */
+    isBottomOfCell(): boolean {
+        const { contentBlock, cellBlock } = this;
+
+        if (!contentBlock || !cellBlock) {
+            return false;
+        }
+
+        const { nodes } = cellBlock;
+        const index = nodes.findIndex(block => block.key == contentBlock.key);
+
+        return index == nodes.size - 1;
+    }
+
+    /**
+     * Get count of columns
+     */
+    getWidth(): number {
+        const { table } = this;
+        const rows = table.nodes;
+        const cells = rows.get(0).nodes;
+
+        return cells.size;
+    }
+
+    /**
+     * Get count of rows
+     */
+    getHeight(): number {
+        const { table } = this;
+        const rows = table.nodes;
+
+        return rows.size;
+    }
+
+    /**
+     * Get index of current row in the table.
+     */
+    getRowIndex(): number {
+        const { table, row } = this;
+        const rows = table.nodes;
+
+        return rows.findIndex(x => x === row);
+    }
+
+    /**
+     * Get index of current column in the row.
+     */
+    getColumnIndex(): number {
+        const { row, cell } = this;
+        const cells = row.nodes;
+
+        return cells.findIndex(x => x === cell);
+    }
+
+    /**
+     * True if on first cell of the table
+     */
+    isFirstCell(): boolean {
+        return this.isFirstRow() && this.isFirstColumn();
+    }
+
+    /**
+     * True if on last cell of the table
+     */
+    isLastCell(): boolean {
+        return this.isLastRow() && this.isLastColumn();
+    }
+
+    /**
+     * True if on first row
+     */
+    isFirstRow(): boolean {
+        return this.getRowIndex() === 0;
+    }
+
+    /**
+     * True if on last row
+     */
+    isLastRow(): boolean {
+        return this.getRowIndex() === this.getHeight() - 1;
+    }
+
+    /**
+     * True if on first column
+     */
+    isFirstColumn(): boolean {
+        return this.getColumnIndex() === 0;
+    }
+
+    /**
+     * True if on last column
+     */
+    isLastColumn(): boolean {
+        return this.getColumnIndex() === this.getWidth() - 1;
+    }
+}
+
+export default TablePosition;

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

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _slate = require('slate');
+
+/**
+ * Create a new cell
+ */
+function createCell(opts, nodes) {
+    return _slate.Block.create({
+        type: opts.typeCell,
+        nodes: nodes || [createEmptyContent(opts)]
+    });
+}
+
+/**
+ * Create a new default content block
+ */
+
+function createEmptyContent(opts) {
+    return _slate.Block.create({
+        type: opts.typeContent,
+        nodes: [_slate.Text.create()]
+    });
+}
+
+exports.default = createCell;

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

@@ -0,0 +1,26 @@
+// @flow
+import { Block, Text, type Node } from 'slate';
+
+import type Options from '../options';
+
+/**
+ * Create a new cell
+ */
+function createCell(opts: Options, nodes?: Node[]): Block {
+    return Block.create({
+        type: opts.typeCell,
+        nodes: nodes || [createEmptyContent(opts)]
+    });
+}
+
+/**
+ * Create a new default content block
+ */
+function createEmptyContent(opts: Options): Block {
+    return Block.create({
+        type: opts.typeContent,
+        nodes: [Text.create()]
+    });
+}
+
+export default createCell;

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

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _immutable = require('immutable');
+
+var _slate = require('slate');
+
+var _createCell = require('./createCell');
+
+var _createCell2 = _interopRequireDefault(_createCell);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Create a new row block
+ */
+function createRow(opts, columns, getCellContent) {
+    var cellNodes = (0, _immutable.Range)(0, columns).map(function (i) {
+        return (0, _createCell2.default)(opts, getCellContent ? getCellContent(i) : undefined);
+    }).toList();
+
+    return _slate.Block.create({
+        type: opts.typeRow,
+        nodes: cellNodes
+    });
+}
+exports.default = createRow;

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

@@ -0,0 +1,28 @@
+// @flow
+import { Range } from 'immutable';
+import { Block, type Node } from 'slate';
+
+import type Options from '../options';
+import createCell from './createCell';
+
+/**
+ * Create a new row block
+ */
+function createRow(
+    opts: Options,
+    columns: number,
+    getCellContent?: (column: number) => Node[]
+): Block {
+    const cellNodes = Range(0, columns)
+        .map(i =>
+            createCell(opts, getCellContent ? getCellContent(i) : undefined)
+        )
+        .toList();
+
+    return Block.create({
+        type: opts.typeRow,
+        nodes: cellNodes
+    });
+}
+
+export default createRow;

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

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _immutable = require('immutable');
+
+var _slate = require('slate');
+
+var _createRow = require('./createRow');
+
+var _createRow2 = _interopRequireDefault(_createRow);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Create a table
+ */
+function createTable(opts, columns, rows, getCellContent) {
+    var rowNodes = (0, _immutable.Range)(0, rows).map(function (i) {
+        return (0, _createRow2.default)(opts, columns, getCellContent ? getCellContent.bind(null, i) : undefined);
+    }).toList();
+
+    return _slate.Block.create({
+        type: opts.typeTable,
+        nodes: rowNodes
+    });
+}
+exports.default = createTable;