studiokit-scaffolding-js 4.5.2 → 4.5.3

package/lib/components/Quill/TableModule/Blots/TableBodyBlot.js

@@ -0,0 +1,71 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableBodyBlot = void 0;
+var react_quill_1 = require("react-quill");
+var constants_1 = require("../constants");
+var BaseTableBlot_1 = require("./BaseTableBlot");
+var TableBlot_1 = require("./TableBlot");
+var TableRowBlot_1 = require("./TableRowBlot");
+var Parchment = react_quill_1.Quill.import('parchment');
+var TableBodyBlot = /** @class */ (function (_super) {
+    __extends(TableBodyBlot, _super);
+    function TableBodyBlot() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableBodyBlot.create = function (value) {
+        var node = _super.createWithValue.call(this, constants_1.TAG_NAME.TBODY, value);
+        return node;
+    };
+    TableBodyBlot.createWithChildren = function (id, rows, cols) {
+        var tableBody = Parchment.create(this.blotName, id);
+        for (var row = 0; row < rows; row++) {
+            var tableRow = TableRowBlot_1.TableRowBlot.createWithChildren(id, cols);
+            tableBody.appendChild(tableRow);
+        }
+        return tableBody;
+    };
+    TableBodyBlot.prototype.optimize = function (context) {
+        _super.prototype.optimize.call(this, context);
+        var didRemove = this.optimizeRemoveIfEmpty();
+        if (didRemove)
+            return;
+        this.optimizeMergeWithNext();
+        this.optimizeWrapInRequiredParent(this.tableId());
+    };
+    TableBodyBlot.prototype.unwrap = function () {
+        // keep a reference to the rows, since `super.unwrap()` will break the ref
+        var rows = this.children.map(function (r) { return r; });
+        _super.prototype.unwrap.call(this);
+        rows.forEach(function (c) {
+            var row = c;
+            row.unwrap();
+        });
+    };
+    TableBodyBlot.prototype.tableId = function () {
+        return this.domNode.getAttribute(constants_1.ATTRIBUTE.DATA_VALUE);
+    };
+    TableBodyBlot.prototype.table = function () {
+        // tbody -> table
+        return this.parent instanceof TableBlot_1.TableBlot ? this.parent : undefined;
+    };
+    TableBodyBlot.blotName = constants_1.TABLE_BLOT_NAME.TBODY;
+    TableBodyBlot.tagName = constants_1.TAG_NAME.TBODY;
+    TableBodyBlot.scope = Parchment.Scope.BLOCK_BLOT;
+    TableBodyBlot.requiredParentName = constants_1.TABLE_BLOT_NAME.TABLE;
+    TableBodyBlot.allowedChildrenNames = [constants_1.TABLE_BLOT_NAME.TR];
+    return TableBodyBlot;
+}(BaseTableBlot_1.BaseTableBlot));
+exports.TableBodyBlot = TableBodyBlot;

package/lib/components/Quill/TableModule/Blots/TableCellBlot.d.ts

@@ -0,0 +1,34 @@
+import { Blot } from 'parchment/dist/src/blot/abstract/blot';
+import BlockBlot from 'parchment/dist/src/blot/block';
+import { TABLE_BLOT_NAME, TAG_NAME } from '../constants';
+import { BaseTableBlot } from './BaseTableBlot';
+import { TableRowBlot } from './TableRowBlot';
+export declare class TableCellBlot extends BaseTableBlot {
+    static blotName: TABLE_BLOT_NAME;
+    static tagName: TAG_NAME;
+    static scope: import("parchment/dist/src/registry").Scope;
+    static requiredParentName: string | null;
+    static defaultChildName: string;
+    /** use normal `allowedChildren` instead of `allowedChildrenNames` */
+    static allowedChildren: (typeof import("parchment/dist/src/blot/embed").default | typeof import("parchment/dist/src/blot/abstract/container").default)[];
+    static create(value: string): HTMLElement;
+    static createWithChildren(tableId: string, rowId: string): TableCellBlot;
+    formats(): {
+        [x: number]: string;
+    };
+    format(_name: string, _value: any): void;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    insertBefore(child: Blot, refNode?: Blot): void;
+    createDefaultChild(): BlockBlot;
+    replace(target: Blot): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    updateDataValue(): void;
+    id(): string;
+    tableId(): string;
+    rowId(): string;
+    row(): TableRowBlot | undefined;
+    table(): import("./TableBlot").TableBlot | undefined;
+    column(): number;
+}

package/lib/components/Quill/TableModule/Blots/TableCellBlot.js

@@ -0,0 +1,236 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableCellBlot = void 0;
+var react_quill_1 = require("react-quill");
+var logger_1 = require("../../../../utils/logger");
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+var BaseTableBlot_1 = require("./BaseTableBlot");
+var TableRowBlot_1 = require("./TableRowBlot");
+var Parchment = react_quill_1.Quill.import('parchment');
+var Container = react_quill_1.Quill.import('blots/container');
+var Block = react_quill_1.Quill.import('blots/block');
+var BlockEmbed = react_quill_1.Quill.import('blots/block/embed');
+var Break = react_quill_1.Quill.import('blots/break');
+var TableCellBlot = /** @class */ (function (_super) {
+    __extends(TableCellBlot, _super);
+    function TableCellBlot() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableCellBlot.create = function (value) {
+        var node = _super.createWithValue.call(this, constants_1.TAG_NAME.TD, value);
+        // split data-value into separate attributes for easier access
+        var values = value.split('|');
+        node.setAttribute(constants_1.ATTRIBUTE.TABLE, values[0]);
+        node.setAttribute(constants_1.ATTRIBUTE.ROW, values[1]);
+        node.setAttribute(constants_1.ATTRIBUTE.CELL, values[2]);
+        node.setAttribute(constants_1.ATTRIBUTE.ID, values[2]);
+        return node;
+    };
+    TableCellBlot.createWithChildren = function (tableId, rowId) {
+        var id = utils_1.newId(this.blotName);
+        var tableCell = Parchment.create(this.blotName, tableId + "|" + rowId + "|" + id);
+        var p = Parchment.create(Block.blotName);
+        tableCell.appendChild(p);
+        var br = Parchment.create(Break.blotName);
+        p.appendChild(br);
+        return tableCell;
+    };
+    TableCellBlot.prototype.formats = function () {
+        var _a;
+        // We don't inherit from FormatBlot
+        return _a = {},
+            _a[this.statics.blotName] = this.tableId() + "|" + this.rowId() + "|" + this.id(),
+            _a;
+    };
+    TableCellBlot.prototype.format = function (_name, _value) {
+        // don't do anything
+        // our "td" value does not do anything beyond making the <td> tag
+    };
+    TableCellBlot.prototype.optimize = function (context) {
+        _super.prototype.optimize.call(this, context);
+        var didRemove = this.optimizeRemoveIfEmpty();
+        if (didRemove)
+            return;
+        this.optimizeMergeWithNext();
+        var firstChild = this.children.head;
+        while (firstChild instanceof TableCellBlot) {
+            logger_1.getLogger().debug(this.statics.tagName + " optimize: head child is TD. insert into parent before this, then optimize");
+            this.parent.insertBefore(firstChild, this);
+            firstChild.optimize({});
+            firstChild = this.children.head;
+        }
+        var lastChild = this.children.tail;
+        while (lastChild instanceof TableCellBlot) {
+            logger_1.getLogger().debug(this.statics.tagName + " optimize: tail child is TD. insert into parent after this, then optimize");
+            this.parent.insertBefore(lastChild, this.next);
+            lastChild.optimize({});
+            lastChild = this.children.tail;
+        }
+        if (this.parent && !utils_1.isInstanceOfBlot(this.parent, this.statics.requiredParentName)) {
+            logger_1.getLogger().debug(this.statics.tagName + " optimize: parent is not " + this.statics.requiredParentName, {
+                this: this,
+                context: context,
+                parent: this.parent,
+                prev: this.prev,
+                next: this.next
+            });
+            if (this.parent instanceof TableCellBlot && this.parent.dataValue() === this.dataValue()) {
+                logger_1.getLogger().debug(this.statics.tagName + " optimize: parent is matching TD. merge this into parent.");
+                this.moveChildren(this.parent, this.next);
+                this.remove();
+            }
+            else if (this.parent instanceof TableCellBlot) {
+                logger_1.getLogger().debug(this.statics.tagName + " optimize: parent is TD. optimize parent TD.");
+                this.parent.optimize(context);
+            }
+            else {
+                var newRow = Parchment.create(this.statics.requiredParentName, this.tableId() + "|" + this.rowId());
+                logger_1.getLogger().debug(this.statics.tagName + " optimize: wrap in new TR.", {
+                    this: this,
+                    newRow: newRow,
+                    before: this.next
+                });
+                this.parent.insertBefore(newRow, this.next);
+                this.parent.removeChild(this);
+                newRow.appendChild(this);
+            }
+        }
+    };
+    TableCellBlot.prototype.insertBefore = function (child, refNode) {
+        // does not inherit from super, uses allowedChildren instead of allowedChildrenNames
+        logger_1.getLogger().debug(this.statics.tagName + " insertBefore: " + child.statics.tagName, {
+            this: this,
+            child: child,
+            ref: refNode
+        });
+        if (this.statics.allowedChildren != null &&
+            !this.statics.allowedChildren.some(function (allowedChild) {
+                return child instanceof allowedChild;
+            })) {
+            var newChild = this.createDefaultChild();
+            logger_1.getLogger().debug(this.statics.tagName + " insertBefore: createDefaultChild and append blot", {
+                this: this,
+                child: child,
+                newChild: newChild,
+                ref: refNode
+            });
+            newChild.appendChild(child);
+            newChild.insertInto(this, refNode);
+        }
+        else {
+            child.insertInto(this, refNode);
+        }
+    };
+    TableCellBlot.prototype.createDefaultChild = function () {
+        return Parchment.create(this.statics.defaultChildName);
+    };
+    TableCellBlot.prototype.replace = function (target) {
+        logger_1.getLogger().debug(this.statics.tagName + " replace: " + target.statics.tagName, {
+            this: this,
+            target: target
+        });
+        if (target instanceof Block) {
+            var newChild = target.clone();
+            target.moveChildren(newChild);
+            this.appendChild(newChild);
+        }
+        _super.prototype.replace.call(this, target);
+    };
+    TableCellBlot.prototype.formatAt = function (index, length, name, value) {
+        var _this = this;
+        var _a;
+        logger_1.getLogger().debug("TD formatAt", {
+            this: this,
+            childrenLength: this.children.length,
+            dataValue: this.dataValue(),
+            index: index,
+            length: length,
+            name: name,
+            value: value
+        });
+        // make a local copy of the "children.forEachAt" params, incase the cell is "unwrapped"
+        var childFormatAtParams = [];
+        this.children.forEachAt(index, length, function (child, offset, length) {
+            childFormatAtParams.push([child, offset, length]);
+        });
+        if (name === this.statics.blotName && (!value || value !== this.dataValue())) {
+            var tableContainer = (_a = this.table()) === null || _a === void 0 ? void 0 : _a.tableContainer();
+            if (tableContainer) {
+                logger_1.getLogger().debug("TD formatAt: cols or rows added were removed, deconstruct table to flatten cells");
+                tableContainer.unwrap();
+            }
+            if (value && index === 0 && length >= this.children.length) {
+                logger_1.getLogger().debug("TD formatAt: replace with new cell, do not format children");
+                this.replaceWith(name, value);
+                return;
+            }
+            if (!value && this.statics.containsOnlyEmptyBlock(this)) {
+                logger_1.getLogger().debug("TD formatAt: no value, unwrap, format children");
+                this.unwrap();
+            }
+        }
+        childFormatAtParams.forEach(function (params) {
+            var child = params[0], offset = params[1], length = params[2];
+            logger_1.getLogger().debug("TD formatAt child", {
+                this: _this,
+                child: child,
+                offset: offset,
+                length: length,
+                name: name,
+                value: value
+            });
+            child.formatAt(offset, length, name, value);
+        });
+    };
+    TableCellBlot.prototype.updateDataValue = function () {
+        this.domNode.setAttribute(constants_1.ATTRIBUTE.DATA_VALUE, this.formats()[this.statics.blotName]);
+    };
+    TableCellBlot.prototype.id = function () {
+        return this.domNode.getAttribute(constants_1.ATTRIBUTE.ID);
+    };
+    TableCellBlot.prototype.tableId = function () {
+        return this.domNode.getAttribute(constants_1.ATTRIBUTE.TABLE);
+    };
+    TableCellBlot.prototype.rowId = function () {
+        return this.domNode.getAttribute(constants_1.ATTRIBUTE.ROW);
+    };
+    TableCellBlot.prototype.row = function () {
+        // td -> tr
+        return this.parent instanceof TableRowBlot_1.TableRowBlot ? this.parent : undefined;
+    };
+    TableCellBlot.prototype.table = function () {
+        var _a;
+        return (_a = this.row()) === null || _a === void 0 ? void 0 : _a.table();
+    };
+    TableCellBlot.prototype.column = function () {
+        var row = this.row();
+        if (!row) {
+            throw new Error('row is required to know column');
+        }
+        var index = row.children.map(function (c) { return c; }).indexOf(this);
+        return index + 1;
+    };
+    TableCellBlot.blotName = constants_1.TABLE_BLOT_NAME.TD;
+    TableCellBlot.tagName = constants_1.TAG_NAME.TD;
+    TableCellBlot.scope = Parchment.Scope.BLOCK_BLOT;
+    TableCellBlot.requiredParentName = constants_1.TABLE_BLOT_NAME.TR;
+    TableCellBlot.defaultChildName = Block.blotName;
+    /** use normal `allowedChildren` instead of `allowedChildrenNames` */
+    TableCellBlot.allowedChildren = [Block, BlockEmbed, Container];
+    return TableCellBlot;
+}(BaseTableBlot_1.BaseTableBlot));
+exports.TableCellBlot = TableCellBlot;

package/lib/components/Quill/TableModule/Blots/TableContainer.d.ts

@@ -0,0 +1,16 @@
+import { TABLE_BLOT_NAME, TAG_NAME } from '../constants';
+import { BaseTableBlot } from './BaseTableBlot';
+import { TableBlot } from './TableBlot';
+export declare class TableContainerBlot extends BaseTableBlot {
+    static blotName: TABLE_BLOT_NAME;
+    static tagName: TAG_NAME;
+    static scope: import("parchment/dist/src/registry").Scope;
+    static allowedChildrenNames: string[];
+    static create(value: string): HTMLDivElement;
+    static createWithChildren(rows: number, cols: number): TableContainerBlot;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    unwrap(): void;
+    table(): TableBlot;
+}

package/lib/components/Quill/TableModule/Blots/TableContainer.js

@@ -0,0 +1,103 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableContainerBlot = void 0;
+var react_quill_1 = require("react-quill");
+var logger_1 = require("../../../../utils/logger");
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+var BaseTableBlot_1 = require("./BaseTableBlot");
+var TableBlot_1 = require("./TableBlot");
+var TableBodyBlot_1 = require("./TableBodyBlot");
+var TableCellBlot_1 = require("./TableCellBlot");
+var TableRowBlot_1 = require("./TableRowBlot");
+var Parchment = react_quill_1.Quill.import('parchment');
+var Block = react_quill_1.Quill.import('blots/block');
+var TableContainerBlot = /** @class */ (function (_super) {
+    __extends(TableContainerBlot, _super);
+    function TableContainerBlot() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableContainerBlot.create = function (value) {
+        var node = _super.createWithValue.call(this, constants_1.TAG_NAME.DIV, value);
+        node.classList.add('table-container');
+        return node;
+    };
+    TableContainerBlot.createWithChildren = function (rows, cols) {
+        var tableId = utils_1.newId(constants_1.TABLE_BLOT_NAME.TABLE);
+        var tableContainer = Parchment.create(this.blotName, tableId);
+        var table = TableBlot_1.TableBlot.createWithChildren(tableId, rows, cols);
+        tableContainer.appendChild(table);
+        return tableContainer;
+    };
+    TableContainerBlot.prototype.optimize = function (context) {
+        _super.prototype.optimize.call(this, context);
+        var didRemove = this.optimizeRemoveIfEmpty();
+        if (didRemove)
+            return;
+        this.optimizeMergeWithNext();
+        if (!this.prev ||
+            // check if prev is already a block
+            (!(this.prev instanceof Block) &&
+                // check if prev will be merged into the same table
+                !(this.prev instanceof TableContainerBlot && this.prev.dataValue() === this.dataValue()) &&
+                !(this.prev instanceof TableBlot_1.TableBlot && this.prev.id() === this.dataValue()) &&
+                !(this.prev instanceof TableBodyBlot_1.TableBodyBlot && this.prev.tableId() === this.dataValue()) &&
+                !(this.prev instanceof TableRowBlot_1.TableRowBlot && this.prev.tableId() === this.dataValue()) &&
+                !(this.prev instanceof TableCellBlot_1.TableCellBlot && this.prev.tableId() === this.dataValue()))) {
+            logger_1.getLogger().debug(this.statics.tagName + " optimize: no block before table container, inserting new block", {
+                this: this,
+                parent: this.parent,
+                prev: this.prev,
+                next: this.next
+            });
+            var block = Parchment.create(Block.blotName);
+            this.parent.insertBefore(block, this);
+        }
+        if (!this.next ||
+            // check if next is already a block
+            (!(this.next instanceof Block) &&
+                // check if next will be merged into the same table
+                !(this.next instanceof TableContainerBlot && this.next.dataValue() === this.dataValue()) &&
+                !(this.next instanceof TableBlot_1.TableBlot && this.next.id() === this.dataValue()) &&
+                !(this.next instanceof TableBodyBlot_1.TableBodyBlot && this.next.tableId() === this.dataValue()) &&
+                !(this.next instanceof TableRowBlot_1.TableRowBlot && this.next.tableId() === this.dataValue()) &&
+                !(this.next instanceof TableCellBlot_1.TableCellBlot && this.next.tableId() === this.dataValue()))) {
+            logger_1.getLogger().debug(this.statics.tagName + " optimize: no block after table container, inserting new block", {
+                this: this,
+                parent: this.parent,
+                prev: this.prev,
+                next: this.next
+            });
+            var block = Parchment.create(Block.blotName);
+            this.parent.insertBefore(block, this.next);
+        }
+    };
+    TableContainerBlot.prototype.unwrap = function () {
+        // keep a reference to the body, since `super.unwrap()` will break the ref
+        var table = this.table();
+        _super.prototype.unwrap.call(this);
+        table.unwrap();
+    };
+    TableContainerBlot.prototype.table = function () {
+        return this.children.head;
+    };
+    TableContainerBlot.blotName = constants_1.TABLE_BLOT_NAME.TABLE_CONTAINER;
+    TableContainerBlot.tagName = constants_1.TAG_NAME.DIV;
+    TableContainerBlot.scope = Parchment.Scope.BLOCK_BLOT;
+    TableContainerBlot.allowedChildrenNames = [constants_1.TABLE_BLOT_NAME.TABLE];
+    return TableContainerBlot;
+}(BaseTableBlot_1.BaseTableBlot));
+exports.TableContainerBlot = TableContainerBlot;

package/lib/components/Quill/TableModule/Blots/TableRowBlot.d.ts

@@ -0,0 +1,22 @@
+import { TABLE_BLOT_NAME, TAG_NAME } from '../constants';
+import { BaseTableBlot } from './BaseTableBlot';
+import { TableBodyBlot } from './TableBodyBlot';
+export declare class TableRowBlot extends BaseTableBlot {
+    static blotName: TABLE_BLOT_NAME;
+    static tagName: TAG_NAME;
+    static scope: import("parchment/dist/src/registry").Scope;
+    static requiredParentName: string | null;
+    static allowedChildrenNames: string[];
+    static create(value: string): HTMLElement;
+    static createWithChildren(tableId: string, cols: number): TableRowBlot;
+    static createFromReference(reference: TableRowBlot): TableRowBlot;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    id(): string;
+    tableId(): string;
+    tableBody(): TableBodyBlot | undefined;
+    prevRow(): TableRowBlot | null;
+    nextRow(): TableRowBlot | null;
+    table(): import("./TableBlot").TableBlot | undefined;
+}

package/lib/components/Quill/TableModule/Blots/TableRowBlot.js

@@ -0,0 +1,91 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableRowBlot = void 0;
+var react_quill_1 = require("react-quill");
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+var BaseTableBlot_1 = require("./BaseTableBlot");
+var TableBodyBlot_1 = require("./TableBodyBlot");
+var TableCellBlot_1 = require("./TableCellBlot");
+var Parchment = react_quill_1.Quill.import('parchment');
+var TableRowBlot = /** @class */ (function (_super) {
+    __extends(TableRowBlot, _super);
+    function TableRowBlot() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableRowBlot.create = function (value) {
+        var node = _super.createWithValue.call(this, constants_1.TAG_NAME.TR, value);
+        // split data-value into separate attributes for easier access
+        var values = value.split('|');
+        node.setAttribute(constants_1.ATTRIBUTE.TABLE, values[0]);
+        node.setAttribute(constants_1.ATTRIBUTE.ROW, values[1]);
+        node.setAttribute(constants_1.ATTRIBUTE.ID, values[1]);
+        return node;
+    };
+    TableRowBlot.createWithChildren = function (tableId, cols) {
+        var id = utils_1.newId(this.blotName);
+        var tableRow = Parchment.create(this.blotName, tableId + "|" + id);
+        for (var col = 0; col < cols; col++) {
+            var tableCell = TableCellBlot_1.TableCellBlot.createWithChildren(tableId, id);
+            tableRow.appendChild(tableCell);
+        }
+        return tableRow;
+    };
+    TableRowBlot.createFromReference = function (reference) {
+        var tableId = reference.tableId();
+        var tableRow = this.createWithChildren(tableId, 0);
+        reference.children.forEach(function (c) {
+            var newTableCell = TableCellBlot_1.TableCellBlot.createWithChildren(tableId, tableRow.id());
+            tableRow.appendChild(newTableCell);
+        });
+        return tableRow;
+    };
+    TableRowBlot.prototype.optimize = function (context) {
+        _super.prototype.optimize.call(this, context);
+        var didRemove = this.optimizeRemoveIfEmpty();
+        if (didRemove)
+            return;
+        this.optimizeMergeWithNext();
+        this.optimizeWrapInRequiredParent(this.tableId());
+    };
+    TableRowBlot.prototype.id = function () {
+        return this.domNode.getAttribute(constants_1.ATTRIBUTE.ID);
+    };
+    TableRowBlot.prototype.tableId = function () {
+        return this.domNode.getAttribute(constants_1.ATTRIBUTE.TABLE);
+    };
+    TableRowBlot.prototype.tableBody = function () {
+        // tr -> tbody
+        return this.parent instanceof TableBodyBlot_1.TableBodyBlot ? this.parent : undefined;
+    };
+    TableRowBlot.prototype.prevRow = function () {
+        return this.prev ? this.prev : null;
+    };
+    TableRowBlot.prototype.nextRow = function () {
+        return this.next ? this.next : null;
+    };
+    TableRowBlot.prototype.table = function () {
+        var _a;
+        return (_a = this.tableBody()) === null || _a === void 0 ? void 0 : _a.table();
+    };
+    TableRowBlot.blotName = constants_1.TABLE_BLOT_NAME.TR;
+    TableRowBlot.tagName = constants_1.TAG_NAME.TR;
+    TableRowBlot.scope = Parchment.Scope.BLOCK_BLOT;
+    TableRowBlot.requiredParentName = constants_1.TABLE_BLOT_NAME.TBODY;
+    TableRowBlot.allowedChildrenNames = [constants_1.TABLE_BLOT_NAME.TD];
+    return TableRowBlot;
+}(BaseTableBlot_1.BaseTableBlot));
+exports.TableRowBlot = TableRowBlot;

package/lib/components/Quill/TableModule/constants.d.ts

@@ -0,0 +1,34 @@
+export declare enum TABLE_BLOT_NAME {
+    TABLE_CONTAINER = "table-container",
+    TABLE = "table",
+    TBODY = "tbody",
+    TR = "tr",
+    TD = "td"
+}
+export declare enum TAG_NAME {
+    DIV = "DIV",
+    TABLE = "TABLE",
+    TBODY = "TBODY",
+    TR = "TR",
+    TD = "TD",
+    P = "P",
+    BR = "BR"
+}
+export declare enum TABLE_ACTION {
+    NEW_TABLE = "newtable_",
+    INSERT_COL = "insert-col",
+    INSERT_ROW = "insert-row",
+    DELETE_COL = "delete-col",
+    DELETE_ROW = "delete-row"
+}
+export declare enum ATTRIBUTE {
+    ID = "id",
+    DATA_VALUE = "data-value",
+    TABLE = "data-table",
+    ROW = "data-row",
+    CELL = "data-cell"
+}
+export declare enum KEY {
+    BACKSPACE = 8,
+    DELETE = 46
+}

package/lib/components/Quill/TableModule/constants.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY = exports.ATTRIBUTE = exports.TABLE_ACTION = exports.TAG_NAME = exports.TABLE_BLOT_NAME = void 0;
+var TABLE_BLOT_NAME;
+(function (TABLE_BLOT_NAME) {
+    TABLE_BLOT_NAME["TABLE_CONTAINER"] = "table-container";
+    TABLE_BLOT_NAME["TABLE"] = "table";
+    TABLE_BLOT_NAME["TBODY"] = "tbody";
+    TABLE_BLOT_NAME["TR"] = "tr";
+    TABLE_BLOT_NAME["TD"] = "td";
+})(TABLE_BLOT_NAME = exports.TABLE_BLOT_NAME || (exports.TABLE_BLOT_NAME = {}));
+var TAG_NAME;
+(function (TAG_NAME) {
+    TAG_NAME["DIV"] = "DIV";
+    TAG_NAME["TABLE"] = "TABLE";
+    TAG_NAME["TBODY"] = "TBODY";
+    TAG_NAME["TR"] = "TR";
+    TAG_NAME["TD"] = "TD";
+    TAG_NAME["P"] = "P";
+    TAG_NAME["BR"] = "BR";
+})(TAG_NAME = exports.TAG_NAME || (exports.TAG_NAME = {}));
+var TABLE_ACTION;
+(function (TABLE_ACTION) {
+    TABLE_ACTION["NEW_TABLE"] = "newtable_";
+    TABLE_ACTION["INSERT_COL"] = "insert-col";
+    TABLE_ACTION["INSERT_ROW"] = "insert-row";
+    TABLE_ACTION["DELETE_COL"] = "delete-col";
+    TABLE_ACTION["DELETE_ROW"] = "delete-row";
+})(TABLE_ACTION = exports.TABLE_ACTION || (exports.TABLE_ACTION = {}));
+var ATTRIBUTE;
+(function (ATTRIBUTE) {
+    ATTRIBUTE["ID"] = "id";
+    ATTRIBUTE["DATA_VALUE"] = "data-value";
+    ATTRIBUTE["TABLE"] = "data-table";
+    ATTRIBUTE["ROW"] = "data-row";
+    ATTRIBUTE["CELL"] = "data-cell";
+})(ATTRIBUTE = exports.ATTRIBUTE || (exports.ATTRIBUTE = {}));
+var KEY;
+(function (KEY) {
+    KEY[KEY["BACKSPACE"] = 8] = "BACKSPACE";
+    KEY[KEY["DELETE"] = 46] = "DELETE";
+})(KEY = exports.KEY || (exports.KEY = {}));