studiokit-scaffolding-js 4.5.2-next.3.3 → 4.5.2-next.3.4

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

@@ -1,4 +1,9 @@
+import { Blot } from 'parchment/dist/src/blot/abstract/blot';
+import { BlotConstructor } from 'parchment/dist/src/registry';
 declare const Container: typeof import("parchment/dist/src/blot/abstract/container").default;
+export interface BaseTableBlotConstructor extends BlotConstructor {
+    dataValue(): string;
+}
 /**
  * A base class for all Table module blots to inherit.
  *
@@ -7,13 +12,16 @@ declare const Container: typeof import("parchment/dist/src/blot/abstract/contain
  */
 export declare class BaseTableBlot extends Container {
     static scope: import("parchment/dist/src/registry").Scope;
-    static requiredParent: string | null;
-    static allowedChildren: (typeof import("parchment/dist/src/blot/embed").default | typeof import("parchment/dist/src/blot/abstract/container").default)[];
+    static requiredParentName: string | null;
+    /** alternate to `allowedChildren`, to avoid circular class refs */
+    static allowedChildrenNames: string[];
+    static create(value: string): Node;
     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;

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

@@ -20,8 +20,6 @@ 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');
-var Block = react_quill_1.Quill.import('blots/block');
-var BlockEmbed = react_quill_1.Quill.import('blots/block/embed');
 /**
  * A base class for all Table module blots to inherit.
  *
@@ -33,6 +31,9 @@ var BaseTableBlot = /** @class */ (function (_super) {
     function BaseTableBlot() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    BaseTableBlot.create = function (value) {
+        return _super.create.call(this, value);
+    };
     BaseTableBlot.createWithValue = function (tagName, value) {
         var node = _super.create.call(this, tagName);
         node.setAttribute(constants_1.ATTRIBUTE.DATA_VALUE, value);
@@ -50,6 +51,16 @@ var BaseTableBlot = /** @class */ (function (_super) {
             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) {
@@ -90,15 +101,15 @@ var BaseTableBlot = /** @class */ (function (_super) {
     };
     BaseTableBlot.prototype.optimizeWrapInRequiredParent = function (value) {
         if (this.parent &&
-            this.statics.requiredParent !== null &&
-            !utils_1.isInstanceOfBlot(this.parent, this.statics.requiredParent)) {
-            logger_1.getLogger().debug(this.statics.tagName + " optimize: parent not " + this.statics.requiredParent + ". wrap in new " + this.statics.requiredParent + ".", {
+            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.requiredParent, value);
+            var newParent = Parchment.create(this.statics.requiredParentName, value);
             this.parent.removeChild(this);
             this.parent.insertBefore(newParent, this.next);
             newParent.appendChild(this);
@@ -110,8 +121,9 @@ var BaseTableBlot = /** @class */ (function (_super) {
         return this.domNode.getAttribute(constants_1.ATTRIBUTE.DATA_VALUE);
     };
     BaseTableBlot.scope = Parchment.Scope.BLOCK_BLOT;
-    BaseTableBlot.requiredParent = null;
-    BaseTableBlot.allowedChildren = [Block, BlockEmbed, Container];
+    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

@@ -1,12 +1,13 @@
 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 requiredParent: string | null;
-    static allowedChildren: (typeof TableBodyBlot)[];
+    static requiredParentName: string | null;
+    static allowedChildrenNames: string[];
     static create(value: string): HTMLTableElement;
     static createWithChildren(id: string, rows: number, cols: number): TableBlot;
     optimize(context: {
@@ -14,6 +15,6 @@ export declare class TableBlot extends BaseTableBlot {
     }): void;
     unwrap(): void;
     id(): string;
-    tableContainer(): import("parchment/dist/src/blot/abstract/blot").Parent | undefined;
+    tableContainer(): TableContainerBlot | undefined;
     tableBody(): TableBodyBlot;
 }

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

@@ -16,9 +16,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableBlot = 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 TableContainer_1 = require("./TableContainer");
 var Parchment = react_quill_1.Quill.import('parchment');
 var TableBlot = /** @class */ (function (_super) {
     __extends(TableBlot, _super);
@@ -54,8 +54,7 @@ var TableBlot = /** @class */ (function (_super) {
         return this.domNode.getAttribute(constants_1.ATTRIBUTE.ID);
     };
     TableBlot.prototype.tableContainer = function () {
-        // avoid a circular import issue by not casting parent to `TableContainerBlot`
-        return utils_1.isInstanceOfBlot(this.parent, constants_1.TABLE_BLOT_NAME.TABLE_CONTAINER) ? this.parent : undefined;
+        return this.parent instanceof TableContainer_1.TableContainerBlot ? this.parent : undefined;
     };
     TableBlot.prototype.tableBody = function () {
         return this.children.head;
@@ -63,8 +62,8 @@ var TableBlot = /** @class */ (function (_super) {
     TableBlot.blotName = constants_1.TABLE_BLOT_NAME.TABLE;
     TableBlot.tagName = constants_1.TAG_NAME.TABLE;
     TableBlot.scope = Parchment.Scope.BLOCK_BLOT;
-    TableBlot.requiredParent = constants_1.TABLE_BLOT_NAME.TABLE_CONTAINER;
-    TableBlot.allowedChildren = [TableBodyBlot_1.TableBodyBlot];
+    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

@@ -1,13 +1,12 @@
 import { TABLE_BLOT_NAME, TAG_NAME } from '../constants';
 import { BaseTableBlot } from './BaseTableBlot';
 import { TableBlot } from './TableBlot';
-import { TableRowBlot } from './TableRowBlot';
 export declare class TableBodyBlot extends BaseTableBlot {
     static blotName: TABLE_BLOT_NAME;
     static tagName: TAG_NAME;
     static scope: import("parchment/dist/src/registry").Scope;
-    static requiredParent: string | null;
-    static allowedChildren: (typeof TableRowBlot)[];
+    static requiredParentName: string | null;
+    static allowedChildrenNames: string[];
     static create(value: string): HTMLElement;
     static createWithChildren(id: string, rows: number, cols: number): TableBodyBlot;
     optimize(context: {

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

@@ -64,8 +64,8 @@ var TableBodyBlot = /** @class */ (function (_super) {
     TableBodyBlot.blotName = constants_1.TABLE_BLOT_NAME.TBODY;
     TableBodyBlot.tagName = constants_1.TAG_NAME.TBODY;
     TableBodyBlot.scope = Parchment.Scope.BLOCK_BLOT;
-    TableBodyBlot.requiredParent = constants_1.TABLE_BLOT_NAME.TABLE;
-    TableBodyBlot.allowedChildren = [TableRowBlot_1.TableRowBlot];
+    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

@@ -7,8 +7,9 @@ export declare class TableCellBlot extends BaseTableBlot {
     static blotName: TABLE_BLOT_NAME;
     static tagName: TAG_NAME;
     static scope: import("parchment/dist/src/registry").Scope;
-    static requiredParent: string | null;
-    static defaultChild: string;
+    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;

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

@@ -80,8 +80,8 @@ var TableCellBlot = /** @class */ (function (_super) {
             lastChild.optimize({});
             lastChild = this.children.tail;
         }
-        if (this.parent && !utils_1.isInstanceOfBlot(this.parent, this.statics.requiredParent)) {
-            logger_1.getLogger().debug(this.statics.tagName + " optimize: parent is not " + this.statics.requiredParent, {
+        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,
@@ -98,7 +98,7 @@ var TableCellBlot = /** @class */ (function (_super) {
                 this.parent.optimize(context);
             }
             else {
-                var newRow = Parchment.create(this.statics.requiredParent, this.tableId() + "|" + this.rowId());
+                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,
@@ -111,6 +111,7 @@ var TableCellBlot = /** @class */ (function (_super) {
         }
     };
     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,
@@ -128,14 +129,14 @@ var TableCellBlot = /** @class */ (function (_super) {
                 ref: refNode
             });
             newChild.appendChild(child);
-            _super.prototype.insertBefore.call(this, newChild, refNode);
+            newChild.insertInto(this, refNode);
         }
         else {
-            _super.prototype.insertBefore.call(this, child, refNode);
+            child.insertInto(this, refNode);
         }
     };
     TableCellBlot.prototype.createDefaultChild = function () {
-        return Parchment.create(this.statics.defaultChild);
+        return Parchment.create(this.statics.defaultChildName);
     };
     TableCellBlot.prototype.replace = function (target) {
         logger_1.getLogger().debug(this.statics.tagName + " replace: " + target.statics.tagName, {
@@ -226,8 +227,9 @@ var TableCellBlot = /** @class */ (function (_super) {
     TableCellBlot.blotName = constants_1.TABLE_BLOT_NAME.TD;
     TableCellBlot.tagName = constants_1.TAG_NAME.TD;
     TableCellBlot.scope = Parchment.Scope.BLOCK_BLOT;
-    TableCellBlot.requiredParent = constants_1.TABLE_BLOT_NAME.TR;
-    TableCellBlot.defaultChild = Block.blotName;
+    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));

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

@@ -1,4 +1,3 @@
-import { Blot } from 'parchment/dist/src/blot/abstract/blot';
 import { TABLE_BLOT_NAME, TAG_NAME } from '../constants';
 import { BaseTableBlot } from './BaseTableBlot';
 import { TableBlot } from './TableBlot';
@@ -6,10 +5,9 @@ export declare class TableContainerBlot extends BaseTableBlot {
     static blotName: TABLE_BLOT_NAME;
     static tagName: TAG_NAME;
     static scope: import("parchment/dist/src/registry").Scope;
-    static allowedChildren: (typeof TableBlot)[];
+    static allowedChildrenNames: string[];
     static create(value: string): HTMLDivElement;
     static createWithChildren(rows: number, cols: number): TableContainerBlot;
-    insertBefore(childBlot: Blot, refBlot?: Blot): void;
     optimize(context: {
         [key: string]: any;
     }): void;

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

@@ -42,10 +42,6 @@ var TableContainerBlot = /** @class */ (function (_super) {
         tableContainer.appendChild(table);
         return tableContainer;
     };
-    TableContainerBlot.prototype.insertBefore = function (childBlot, refBlot) {
-        logger_1.getLogger().debug('insertBefore', { childBlot: childBlot, refBlot: refBlot });
-        _super.prototype.insertBefore.call(this, childBlot, refBlot);
-    };
     TableContainerBlot.prototype.optimize = function (context) {
         _super.prototype.optimize.call(this, context);
         var didRemove = this.optimizeRemoveIfEmpty();
@@ -101,7 +97,7 @@ var TableContainerBlot = /** @class */ (function (_super) {
     TableContainerBlot.blotName = constants_1.TABLE_BLOT_NAME.TABLE_CONTAINER;
     TableContainerBlot.tagName = constants_1.TAG_NAME.DIV;
     TableContainerBlot.scope = Parchment.Scope.BLOCK_BLOT;
-    TableContainerBlot.allowedChildren = [TableBlot_1.TableBlot];
+    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

@@ -1,13 +1,12 @@
 import { TABLE_BLOT_NAME, TAG_NAME } from '../constants';
 import { BaseTableBlot } from './BaseTableBlot';
 import { TableBodyBlot } from './TableBodyBlot';
-import { TableCellBlot } from './TableCellBlot';
 export declare class TableRowBlot extends BaseTableBlot {
     static blotName: TABLE_BLOT_NAME;
     static tagName: TAG_NAME;
     static scope: import("parchment/dist/src/registry").Scope;
-    static requiredParent: string | null;
-    static allowedChildren: (typeof TableCellBlot)[];
+    static requiredParentName: string | null;
+    static allowedChildrenNames: string[];
     static create(value: string): HTMLElement;
     static createWithChildren(tableId: string, cols: number): TableRowBlot;
     static createFromReference(reference: TableRowBlot): TableRowBlot;

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

@@ -84,8 +84,8 @@ var TableRowBlot = /** @class */ (function (_super) {
     TableRowBlot.blotName = constants_1.TABLE_BLOT_NAME.TR;
     TableRowBlot.tagName = constants_1.TAG_NAME.TR;
     TableRowBlot.scope = Parchment.Scope.BLOCK_BLOT;
-    TableRowBlot.requiredParent = constants_1.TABLE_BLOT_NAME.TBODY;
-    TableRowBlot.allowedChildren = [TableCellBlot_1.TableCellBlot];
+    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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "studiokit-scaffolding-js",
-	"version": "4.5.2-next.3.3",
+	"version": "4.5.2-next.3.4",
 	"description": "Common scaffolding for Studio apps at Purdue",
 	"repository": "https://gitlab.com/purdue-informatics/studiokit/studiokit-scaffolding-js",
 	"license": "MIT",