studiokit-scaffolding-js 4.5.2 → 4.5.3

package/lib/components/Quill/Formats/Image.d.ts

@@ -0,0 +1,46 @@
+declare const Parchment: {
+    Scope: typeof import("parchment/dist/src/registry").Scope;
+    create: typeof import("parchment/dist/src/registry").create;
+    find: typeof import("parchment/dist/src/registry").find;
+    query: typeof import("parchment/dist/src/registry").query;
+    register: typeof import("parchment/dist/src/registry").register;
+    Container: typeof import("parchment/dist/src/blot/abstract/container").default;
+    Format: typeof import("parchment/dist/src/blot/abstract/format").default;
+    Leaf: typeof import("parchment/dist/src/blot/abstract/leaf").default;
+    Embed: typeof import("parchment/dist/src/blot/embed").default;
+    Scroll: typeof import("parchment/dist/src/blot/scroll").default;
+    Block: typeof import("parchment/dist/src/blot/block").default;
+    Inline: typeof import("parchment/dist/src/blot/inline").default;
+    Text: typeof import("parchment/dist/src/blot/text").default;
+    Attributor: {
+        Attribute: typeof import("parchment/dist/src/attributor/attributor").default;
+        Class: typeof import("parchment/dist/src/attributor/class").default;
+        Style: typeof import("parchment/dist/src/attributor/style").default;
+        Store: typeof import("parchment/dist/src/attributor/store").default;
+    };
+};
+export interface ImageValue {
+    src: string;
+    alt: string;
+    width: string;
+    height: string;
+}
+declare type ImageBlotOnClick = (img: ImageValue, blot: Image) => void;
+export declare function setImageClickHandlersEnabled(value: boolean): void;
+export declare function setOnImageBlotClick(guid: string, value: ImageBlotOnClick | undefined): void;
+/**
+ * Defines a new implementation of `Image`, to allow setting alt text, width, and height.
+ *
+ * https://github.com/zenoamaro/react-quill/issues/169
+ */
+export declare class Image extends Parchment.Embed {
+    static blotName: string;
+    static tagName: string;
+    /** Creates the DOM Node from a value */
+    static create(value: ImageValue): HTMLImageElement;
+    /** Returns the value for a DOM Node */
+    static value(node: HTMLImageElement): ImageValue;
+    /** Create the Blot using the DOM Node from static `create` */
+    constructor(domNode: HTMLImageElement);
+}
+export {};

package/lib/components/Quill/Formats/Image.js

@@ -0,0 +1,86 @@
+"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.Image = exports.setOnImageBlotClick = exports.setImageClickHandlersEnabled = void 0;
+var react_quill_1 = require("react-quill");
+var dom_1 = require("../../../utils/dom");
+var logger_1 = require("../../../utils/logger");
+var Parchment = react_quill_1.Quill.import('parchment');
+var clickHandlersEnabled = true;
+var onClickHandlers = {};
+function setImageClickHandlersEnabled(value) {
+    clickHandlersEnabled = value;
+}
+exports.setImageClickHandlersEnabled = setImageClickHandlersEnabled;
+function setOnImageBlotClick(guid, value) {
+    if (value) {
+        onClickHandlers[guid] = value;
+    }
+    else {
+        delete onClickHandlers[guid];
+    }
+}
+exports.setOnImageBlotClick = setOnImageBlotClick;
+/**
+ * Defines a new implementation of `Image`, to allow setting alt text, width, and height.
+ *
+ * https://github.com/zenoamaro/react-quill/issues/169
+ */
+var Image = /** @class */ (function (_super) {
+    __extends(Image, _super);
+    /** Create the Blot using the DOM Node from static `create` */
+    function Image(domNode) {
+        var _this = _super.call(this, domNode) || this;
+        // right click listener to open modal to edit alt text
+        domNode.addEventListener('contextmenu', function (ev) {
+            logger_1.getLogger().debug('image right clicked', { this: _this, ev: ev });
+            var quillEdit = dom_1.getFirstParentElementWithClassName(domNode, 'QuillEdit');
+            if (!quillEdit) {
+                return;
+            }
+            var onClick = onClickHandlers[quillEdit.id];
+            if (onClick && clickHandlersEnabled) {
+                ev.preventDefault();
+                onClick(Image.value(domNode), _this);
+            }
+        });
+        return _this;
+    }
+    /** Creates the DOM Node from a value */
+    Image.create = function (value) {
+        var _a, _b, _c;
+        var node = _super.create.call(this, this.tagName);
+        // Adding a default value for images already saved in the db
+        node.setAttribute('alt', (_a = value.alt) !== null && _a !== void 0 ? _a : 'Statement Image');
+        node.setAttribute('src', value.src);
+        // Setting up the height and width to be reactive when an image is getting resize
+        node.setAttribute('height', (_b = value.height) !== null && _b !== void 0 ? _b : 'auto');
+        node.setAttribute('width', (_c = value.width) !== null && _c !== void 0 ? _c : 'auto');
+        return node;
+    };
+    /** Returns the value for a DOM Node */
+    Image.value = function (node) {
+        return {
+            width: node.getAttribute('width'),
+            height: node.getAttribute('height'),
+            alt: node.getAttribute('alt'),
+            src: node.getAttribute('src')
+        };
+    };
+    Image.blotName = 'image';
+    Image.tagName = 'IMG';
+    return Image;
+}(Parchment.Embed));
+exports.Image = Image;

package/lib/components/Quill/Formats/List.d.ts

@@ -0,0 +1,15 @@
+declare const QuillList: typeof import("parchment/dist/src/blot/abstract/container").default;
+declare const QuillListItem: typeof import("parchment/dist/src/blot/block").default;
+export declare class ListItem extends QuillListItem {
+    format(name: string, value: any): void;
+}
+/**
+ * Extend `List` to add new `alpha` type.
+ */
+export declare class List extends QuillList {
+    static allowedChildren: (typeof ListItem)[];
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): any;
+    optimize(context: any): void;
+}
+export {};

package/lib/components/Quill/Formats/List.js

@@ -0,0 +1,79 @@
+"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.List = exports.ListItem = void 0;
+var react_quill_1 = require("react-quill");
+var logger_1 = require("../../../utils/logger");
+var constants_1 = require("../TableModule/constants");
+var QuillList = react_quill_1.Quill.import('formats/list');
+var QuillListItem = react_quill_1.Quill.import('formats/list/item');
+var ALPHA = 'alpha';
+var ListItem = /** @class */ (function (_super) {
+    __extends(ListItem, _super);
+    function ListItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ListItem.prototype.format = function (name, value) {
+        if (name === constants_1.TABLE_BLOT_NAME.TD && this.parent) {
+            logger_1.getLogger().debug('ListItem format: wrap parent in TD');
+            this.parent.wrap(name, value);
+        }
+        else {
+            _super.prototype.format.call(this, name, value);
+        }
+    };
+    return ListItem;
+}(QuillListItem));
+exports.ListItem = ListItem;
+/**
+ * Extend `List` to add new `alpha` type.
+ */
+var List = /** @class */ (function (_super) {
+    __extends(List, _super);
+    function List() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    List.create = function (value) {
+        var node = _super.create.call(this, value === ALPHA ? 'ordered' : value);
+        if (value === ALPHA) {
+            node.setAttribute('data-value', ALPHA);
+        }
+        return node;
+    };
+    List.formats = function (domNode) {
+        if (domNode.tagName === 'OL' &&
+            domNode.hasAttribute('data-value') &&
+            domNode.getAttribute('data-value') === ALPHA) {
+            return ALPHA;
+        }
+        // @ts-ignore: parent List class _does_ implement `formats`
+        return _super.formats.call(this, domNode);
+    };
+    List.prototype.optimize = function (context) {
+        var next = this.next;
+        if (next != null &&
+            next.prev === this &&
+            next instanceof QuillList &&
+            next.domNode.tagName === this.domNode.tagName &&
+            next.domNode.getAttribute('data-checked') === this.domNode.getAttribute('data-checked') &&
+            // add data-value comparison, avoid combining "ordered" and "alpha" lists
+            next.domNode.getAttribute('data-value') === this.domNode.getAttribute('data-value')) {
+            _super.prototype.optimize.call(this, context);
+        }
+    };
+    List.allowedChildren = [ListItem];
+    return List;
+}(QuillList));
+exports.List = List;

package/lib/components/Quill/Formats/Video.d.ts

@@ -0,0 +1,11 @@
+declare const QuillVideo: typeof import("parchment/dist/src/blot/embed").default;
+/**
+ * Extend `Video` to allow use inside of a `TableCellBlot`
+ */
+export declare class Video extends QuillVideo {
+    formats(): {
+        [index: string]: any;
+    };
+    formatAt(index: number, length: number, name: string, value: any): void;
+}
+export {};

package/lib/components/Quill/Formats/Video.js

@@ -0,0 +1,50 @@
+"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.Video = void 0;
+var react_quill_1 = require("react-quill");
+var TableCellBlot_1 = require("../TableModule/Blots/TableCellBlot");
+var constants_1 = require("../TableModule/constants");
+var QuillVideo = react_quill_1.Quill.import('formats/video');
+/**
+ * Extend `Video` to allow use inside of a `TableCellBlot`
+ */
+var Video = /** @class */ (function (_super) {
+    __extends(Video, _super);
+    function Video() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Video.prototype.formats = function () {
+        var formats = _super.prototype.formats.call(this);
+        // allow video that is wrapped in a table cell to return this "format"
+        // when the delta op for this blot is created
+        if (this.parent instanceof TableCellBlot_1.TableCellBlot) {
+            formats[constants_1.TABLE_BLOT_NAME.TD] = this.parent.dataValue();
+        }
+        return formats;
+    };
+    Video.prototype.formatAt = function (index, length, name, value) {
+        // `BlockEmbed` ignores all formatting sent to `formatAt`
+        // allow the video iframe to be wrapped in a table cell, e.g. "formatted as a table cell"
+        if (name === constants_1.TABLE_BLOT_NAME.TD) {
+            this.wrap(name, value);
+        }
+        else {
+            _super.prototype.formatAt.call(this, index, length, name, value);
+        }
+    };
+    return Video;
+}(QuillVideo));
+exports.Video = Video;

package/lib/components/{Blots → Quill/Specs}/CustomImageSpec.d.ts

@@ -9,6 +9,7 @@ import { DeleteAction, ImageSpec, ResizeAction } from 'quill-blot-formatter';
 declare class CustomImageSpec extends ImageSpec {
     init(): void;
     getActions(): (typeof ResizeAction | typeof DeleteAction)[];
-    reposition: (e: any) => void;
+    onRightClick: (e: Event) => void;
+    reposition: (_e: Event) => void;
 }
 export default CustomImageSpec;

package/lib/components/{Blots → Quill/Specs}/CustomImageSpec.js

@@ -25,7 +25,13 @@ var CustomImageSpec = /** @class */ (function (_super) {
     __extends(CustomImageSpec, _super);
     function CustomImageSpec() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.reposition = function (e) {
+        _this.onRightClick = function (e) {
+            e.preventDefault();
+            if (_this.img) {
+                _this.img.dispatchEvent(new CustomEvent('contextmenu'));
+            }
+        };
+        _this.reposition = function (_e) {
             if (_this.img) {
                 _this.formatter.repositionOverlay();
             }
@@ -34,8 +40,11 @@ var CustomImageSpec = /** @class */ (function (_super) {
     }
     CustomImageSpec.prototype.init = function () {
         _super.prototype.init.call(this);
+        // listen for scroll and resize, to reposition the overlay
         this.formatter.quill.root.addEventListener('scroll', this.reposition);
         window.addEventListener('resize', this.reposition);
+        // listen for right-click of the overlay, to pass through to the img
+        this.formatter.overlay.addEventListener('contextmenu', this.onRightClick);
     };
     CustomImageSpec.prototype.getActions = function () {
         return [quill_blot_formatter_1.ResizeAction, quill_blot_formatter_1.DeleteAction];

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

@@ -0,0 +1,29 @@
+import { Blot } from 'parchment/dist/src/blot/abstract/blot';
+declare const Container: typeof import("parchment/dist/src/blot/abstract/container").default;
+/**
+ * A base class for all Table module blots to inherit.
+ *
+ * Created with a `value` that is stored on the DOM Node as the `data-value` attribute.
+ * This is used for optimization (merging related blots).
+ */
+export declare class BaseTableBlot extends Container {
+    static scope: import("parchment/dist/src/registry").Scope;
+    static requiredParentName: string | null;
+    /** alternate to `allowedChildren`, to avoid circular class refs */
+    static allowedChildrenNames: string[];
+    static createWithValue(tagName: string, value: string): HTMLElement;
+    /**
+     * Check if the blot only contains `<p><br></p>`
+     */
+    static containsOnlyEmptyBlock(blot: BaseTableBlot): boolean | null;
+    insertBefore(childBlot: Blot, refBlot?: Blot): void;
+    optimize(_context: {
+        [key: string]: any;
+    }): void;
+    unwrap(): void;
+    optimizeRemoveIfEmpty(): boolean;
+    optimizeMergeWithNext(): boolean;
+    optimizeWrapInRequiredParent(value: string): boolean;
+    dataValue(): string;
+}
+export {};

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

@@ -0,0 +1,126 @@
+"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.BaseTableBlot = 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 Parchment = react_quill_1.Quill.import('parchment');
+var Container = react_quill_1.Quill.import('blots/container');
+/**
+ * A base class for all Table module blots to inherit.
+ *
+ * Created with a `value` that is stored on the DOM Node as the `data-value` attribute.
+ * This is used for optimization (merging related blots).
+ */
+var BaseTableBlot = /** @class */ (function (_super) {
+    __extends(BaseTableBlot, _super);
+    function BaseTableBlot() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BaseTableBlot.createWithValue = function (tagName, value) {
+        var node = _super.create.call(this, tagName);
+        node.setAttribute(constants_1.ATTRIBUTE.DATA_VALUE, value);
+        logger_1.getLogger().debug(tagName + " created", { value: value, node: node });
+        return node;
+    };
+    /**
+     * Check if the blot only contains `<p><br></p>`
+     */
+    BaseTableBlot.containsOnlyEmptyBlock = function (blot) {
+        var _a;
+        return (blot.length() === 1 &&
+            blot.children.head &&
+            blot.children.head.domNode.tagName === constants_1.TAG_NAME.P &&
+            blot.children.head.length() === 1 &&
+            ((_a = blot.children.head.children.head) === null || _a === void 0 ? void 0 : _a.domNode).tagName === constants_1.TAG_NAME.BR);
+    };
+    BaseTableBlot.prototype.insertBefore = function (childBlot, refBlot) {
+        // override super.insertBefore to change `allowedChildren` to use blotName strings, instead of class constructors
+        if (this.statics.allowedChildrenNames != null &&
+            !this.statics.allowedChildrenNames.some(function (allowedBlotName) {
+                return childBlot.statics.blotName === allowedBlotName;
+            })) {
+            throw new Error("Cannot insert " + childBlot.statics.blotName + " into " + this.statics.blotName);
+        }
+        childBlot.insertInto(this, refBlot);
+    };
+    BaseTableBlot.prototype.optimize = function (_context) {
+        // @ts-ignore: copied from Parchment.ShadowBlot
+        if (this.domNode['__blot'] != null) {
+            // @ts-ignore: copied from Parchment.ShadowBlot
+            delete this.domNode['__blot'].mutations;
+        }
+        // do not inherit from Container, allow each child to determine optimization
+    };
+    BaseTableBlot.prototype.unwrap = function () {
+        _super.prototype.unwrap.call(this);
+        logger_1.getLogger().debug(this.statics.tagName + " unwrap");
+    };
+    BaseTableBlot.prototype.optimizeRemoveIfEmpty = function () {
+        if (this.children.length === 0) {
+            this.remove();
+            return true;
+        }
+        return false;
+    };
+    BaseTableBlot.prototype.optimizeMergeWithNext = function () {
+        var next = this.next;
+        if (next != null &&
+            next.prev === this &&
+            utils_1.isInstanceOfBlot(next, this.statics.blotName) &&
+            next.domNode.tagName === this.domNode.tagName &&
+            next.domNode.getAttribute(constants_1.ATTRIBUTE.DATA_VALUE) === this.dataValue()) {
+            logger_1.getLogger().debug(this.statics.tagName + " optimize: next is matching blot. merge next into this.", {
+                this: this,
+                parent: this.parent,
+                prev: this.prev,
+                next: this.next
+            });
+            next.moveChildren(this);
+            next.remove();
+            return true;
+        }
+        return false;
+    };
+    BaseTableBlot.prototype.optimizeWrapInRequiredParent = function (value) {
+        if (this.parent &&
+            this.statics.requiredParentName !== null &&
+            !utils_1.isInstanceOfBlot(this.parent, this.statics.requiredParentName)) {
+            logger_1.getLogger().debug(this.statics.tagName + " optimize: parent not " + this.statics.requiredParentName + ". wrap in new " + this.statics.requiredParentName + ".", {
+                this: this,
+                parent: this.parent,
+                prev: this.prev,
+                next: this.next
+            });
+            var newParent = Parchment.create(this.statics.requiredParentName, value);
+            this.parent.removeChild(this);
+            this.parent.insertBefore(newParent, this.next);
+            newParent.appendChild(this);
+            return true;
+        }
+        return false;
+    };
+    BaseTableBlot.prototype.dataValue = function () {
+        return this.domNode.getAttribute(constants_1.ATTRIBUTE.DATA_VALUE);
+    };
+    BaseTableBlot.scope = Parchment.Scope.BLOCK_BLOT;
+    BaseTableBlot.requiredParentName = null;
+    /** alternate to `allowedChildren`, to avoid circular class refs */
+    BaseTableBlot.allowedChildrenNames = [];
+    return BaseTableBlot;
+}(Container));
+exports.BaseTableBlot = BaseTableBlot;

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

@@ -0,0 +1,20 @@
+import { TABLE_BLOT_NAME, TAG_NAME } from '../constants';
+import { BaseTableBlot } from './BaseTableBlot';
+import { TableBodyBlot } from './TableBodyBlot';
+import { TableContainerBlot } from './TableContainer';
+export declare class TableBlot 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): HTMLTableElement;
+    static createWithChildren(id: string, rows: number, cols: number): TableBlot;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    unwrap(): void;
+    id(): string;
+    tableContainer(): TableContainerBlot | undefined;
+    tableBody(): TableBodyBlot;
+}

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

@@ -0,0 +1,69 @@
+"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.TableBlot = void 0;
+var react_quill_1 = require("react-quill");
+var constants_1 = require("../constants");
+var BaseTableBlot_1 = require("./BaseTableBlot");
+var TableBodyBlot_1 = require("./TableBodyBlot");
+var TableContainer_1 = require("./TableContainer");
+var Parchment = react_quill_1.Quill.import('parchment');
+var TableBlot = /** @class */ (function (_super) {
+    __extends(TableBlot, _super);
+    function TableBlot() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TableBlot.create = function (value) {
+        var node = _super.createWithValue.call(this, constants_1.TAG_NAME.TABLE, value);
+        node.setAttribute(constants_1.ATTRIBUTE.ID, value);
+        return node;
+    };
+    TableBlot.createWithChildren = function (id, rows, cols) {
+        var table = Parchment.create(this.blotName, id);
+        var tableBody = TableBodyBlot_1.TableBodyBlot.createWithChildren(id, rows, cols);
+        table.appendChild(tableBody);
+        return table;
+    };
+    TableBlot.prototype.optimize = function (context) {
+        _super.prototype.optimize.call(this, context);
+        var didRemove = this.optimizeRemoveIfEmpty();
+        if (didRemove)
+            return;
+        this.optimizeMergeWithNext();
+        this.optimizeWrapInRequiredParent(this.id());
+    };
+    TableBlot.prototype.unwrap = function () {
+        // keep a reference to the body, since `super.unwrap()` will break the ref
+        var tbody = this.tableBody();
+        _super.prototype.unwrap.call(this);
+        tbody.unwrap();
+    };
+    TableBlot.prototype.id = function () {
+        return this.domNode.getAttribute(constants_1.ATTRIBUTE.ID);
+    };
+    TableBlot.prototype.tableContainer = function () {
+        return this.parent instanceof TableContainer_1.TableContainerBlot ? this.parent : undefined;
+    };
+    TableBlot.prototype.tableBody = function () {
+        return this.children.head;
+    };
+    TableBlot.blotName = constants_1.TABLE_BLOT_NAME.TABLE;
+    TableBlot.tagName = constants_1.TAG_NAME.TABLE;
+    TableBlot.scope = Parchment.Scope.BLOCK_BLOT;
+    TableBlot.requiredParentName = constants_1.TABLE_BLOT_NAME.TABLE_CONTAINER;
+    TableBlot.allowedChildrenNames = [constants_1.TABLE_BLOT_NAME.TBODY];
+    return TableBlot;
+}(BaseTableBlot_1.BaseTableBlot));
+exports.TableBlot = TableBlot;

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

@@ -0,0 +1,18 @@
+import { TABLE_BLOT_NAME, TAG_NAME } from '../constants';
+import { BaseTableBlot } from './BaseTableBlot';
+import { TableBlot } from './TableBlot';
+export declare class TableBodyBlot 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(id: string, rows: number, cols: number): TableBodyBlot;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    unwrap(): void;
+    tableId(): string;
+    table(): TableBlot | undefined;
+}