@manuscripts/transform 2.1.1-LEAN-3336-13 → 2.1.1-LEAN-3336-16

package/dist/cjs/schema/nodes/table.js

@@ -15,129 +15,90 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tableHeader = exports.tableCell = exports.tableRow = exports.table = exports.tableNodes = exports.createTableNodes = void 0;
+exports.tableHeader = exports.tableCell = exports.tableRow = exports.table = exports.tableNodes = void 0;
+const prosemirror_tables_1 = require("prosemirror-tables");
 const table_cell_styles_1 = require("../../lib/table-cell-styles");
-function getCellAttrs(dom, extraAttrs) {
-    if (typeof dom === 'string') {
-        return {};
+const modifyTableCellSchema = (tableCell) => {
+    const modifiedTableCell = Object.assign({}, tableCell);
+    const originalToDOM = tableCell.toDOM;
+    if (!originalToDOM) {
+        throw new Error(`toDOM not found inside ${tableCell}, check for table schema changes in prosemirror-tables`);
     }
-    const widthAttr = dom.getAttribute('data-colwidth');
-    const widths = widthAttr && /^\d+(,\d+)*$/.test(widthAttr)
-        ? widthAttr.split(',').map((s) => Number(s))
-        : null;
-    const colspan = Number(dom.getAttribute('colspan') || 1);
-    const result = {
-        colspan,
-        rowspan: Number(dom.getAttribute('rowspan') || 1),
-        colwidth: widths && widths.length == colspan ? widths : null,
-    };
-    for (const prop in extraAttrs) {
-        const getter = extraAttrs[prop].getFromDOM;
-        const value = getter && getter(dom);
-        if (value != null) {
-            result[prop] = value;
+    modifiedTableCell.toDOM = function (node) {
+        const originalArray = originalToDOM.call(this, node);
+        if (!Array.isArray(originalArray)) {
+            throw new Error(`${originalArray} is of type ${typeof originalArray}, check for table schema changes in prosemirror-tables`);
         }
-    }
-    return result;
-}
-function setCellAttrs(node, extraAttrs) {
-    const attrs = {};
-    if (node.attrs.colspan != 1) {
-        attrs.colspan = node.attrs.colspan;
-    }
-    if (node.attrs.rowspan != 1) {
-        attrs.rowspan = node.attrs.rowspan;
-    }
-    if (node.attrs.colwidth) {
-        attrs['data-colwidth'] = node.attrs.colwidth.join(',');
-    }
-    if (!node.textContent) {
-        attrs.class = 'placeholder';
-    }
-    for (const prop in extraAttrs) {
-        const setter = extraAttrs[prop].setDOMAttr;
-        if (setter) {
-            setter(node.attrs[prop], attrs);
+        const attrsIndex = originalArray.findIndex((item) => typeof item === 'object' && !Array.isArray(item));
+        const modifiedAttrs = Object.assign({}, originalArray[attrsIndex]);
+        if (!node.textContent) {
+            modifiedAttrs.class = 'placeholder';
         }
+        originalArray[attrsIndex] = modifiedAttrs;
+        return originalArray;
+    };
+    return modifiedTableCell;
+};
+const modifyTableToDOM = (modifiedTable) => {
+    const originalToDOM = modifiedTable.toDOM;
+    if (!originalToDOM) {
+        throw new Error(`toDOM not found inside ${modifiedTable}, check for table schema changes in prosemirror-tables`);
     }
-    return attrs;
-}
-function createTableNodes(options) {
-    const extraAttrs = options.cellAttributes || {};
-    const cellAttrs = {
-        colspan: { default: 1 },
-        rowspan: { default: 1 },
-        colwidth: { default: null },
+    modifiedTable.toDOM = function (node) {
+        const originalArray = originalToDOM.call(this, node);
+        if (!Array.isArray(originalArray)) {
+            throw new Error(`${originalArray} is of type ${typeof originalArray}, check for table schema changes in prosemirror-tables`);
+        }
+        const modifiedAttrs = {
+            id: node.attrs.id,
+            'data-header-rows': String(node.attrs.headerRows),
+            'data-footer-rows': String(node.attrs.footerRows),
+        };
+        if (Array.isArray(originalArray[1])) {
+            originalArray.splice(1, 0, modifiedAttrs);
+        }
+        else if (typeof originalArray[1] === 'object') {
+            originalArray[1] = Object.assign(Object.assign({}, originalArray[1]), modifiedAttrs);
+        }
+        else {
+            throw new Error(`toDOM[1] ${originalArray[1]} is of type ${typeof originalArray[1]}, check for table schema changes in prosemirror-tables`);
+        }
+        return originalArray;
     };
-    for (const prop in extraAttrs) {
-        cellAttrs[prop] = { default: extraAttrs[prop].default };
+};
+const modifyTableParseDOM = (modifiedTable) => {
+    if (!modifiedTable.parseDOM || !modifiedTable.parseDOM[0]) {
+        throw new Error(`parseDOM not found inside ${modifiedTable}, check for table schema changes in prosemirror-tables`);
     }
-    return {
-        table: {
-            content: 'table_row+',
-            tableRole: 'table',
-            isolating: true,
-            group: options.tableGroup,
-            parseDOM: [
-                {
-                    tag: 'table',
-                    getAttrs: (p) => {
-                        const dom = p;
-                        return {
-                            id: dom.getAttribute('id'),
-                            headerRows: dom.dataset && dom.dataset['header-rows'],
-                            footerRows: dom.dataset && dom.dataset['footer-rows'],
-                        };
-                    },
-                },
-            ],
-            toDOM(node) {
-                return [
-                    'table',
-                    {
-                        id: node.attrs.id,
-                        'data-header-rows': String(node.attrs.headerRows),
-                        'data-footer-rows': String(node.attrs.footerRows),
-                    },
-                    ['tbody', 0],
-                ];
-            },
-        },
-        table_row: {
-            content: '(table_cell | table_header)*',
-            tableRole: 'row',
-            parseDOM: [{ tag: 'tr' }],
-            toDOM() {
-                return ['tr', 0];
-            },
-        },
-        table_cell: {
-            content: options.cellContent,
-            attrs: cellAttrs,
-            tableRole: 'cell',
-            isolating: true,
-            parseDOM: [
-                { tag: 'td', getAttrs: (dom) => getCellAttrs(dom, extraAttrs) },
-            ],
-            toDOM(node) {
-                return ['td', setCellAttrs(node, extraAttrs), 0];
-            },
-        },
-        table_header: {
-            content: options.cellContent,
-            attrs: cellAttrs,
-            tableRole: 'header_cell',
-            isolating: true,
-            parseDOM: [
-                { tag: 'th', getAttrs: (dom) => getCellAttrs(dom, extraAttrs) },
-            ],
-            toDOM(node) {
-                return ['th', setCellAttrs(node, extraAttrs), 0];
-            },
-        },
+    const originalGetAttrs = modifiedTable.parseDOM[0].getAttrs;
+    let originalAttrs;
+    modifiedTable.parseDOM[0].getAttrs = function (p) {
+        const dom = p;
+        if (originalGetAttrs) {
+            originalAttrs = originalGetAttrs.call(this, p);
+        }
+        if (originalAttrs && typeof originalAttrs === 'object') {
+            return Object.assign(Object.assign({}, originalAttrs), { id: dom.getAttribute('id'), headerRows: dom.dataset && dom.dataset['header-rows'], footerRows: dom.dataset && dom.dataset['footer-rows'] });
+        }
+        else {
+            return {
+                id: dom.getAttribute('id'),
+                headerRows: dom.dataset && dom.dataset['header-rows'],
+                footerRows: dom.dataset && dom.dataset['footer-rows'],
+            };
+        }
     };
-}
-exports.createTableNodes = createTableNodes;
+};
+const modifyTableAttrs = (modifiedTable, table) => {
+    modifiedTable.attrs = Object.assign(Object.assign({}, table.attrs), { id: { default: '' }, dataTracked: { default: null }, comments: { default: null }, headerRows: { default: 1 }, footerRows: { default: 1 } });
+};
+const modifyTableSchema = (table) => {
+    const modifiedTable = Object.assign({}, table);
+    modifyTableAttrs(modifiedTable, table);
+    modifyTableToDOM(modifiedTable);
+    modifyTableParseDOM(modifiedTable);
+    return modifiedTable;
+};
 const tableOptions = {
     tableGroup: 'block',
     cellContent: 'inline*',
@@ -165,14 +126,6 @@ const tableOptions = {
                 }
             },
         },
-        class: {
-            default: null,
-            setDOMAttr(value, attrs) {
-                if (value) {
-                    attrs['class'] = value;
-                }
-            },
-        },
         valign: {
             default: null,
             getFromDOM(dom) {
@@ -219,8 +172,8 @@ const tableOptions = {
         },
     },
 };
-exports.tableNodes = createTableNodes(tableOptions);
-exports.table = Object.assign(Object.assign({}, exports.tableNodes.table), { attrs: Object.assign(Object.assign({}, exports.tableNodes.table.attrs), { id: { default: '' }, dataTracked: { default: null }, comments: { default: null }, headerRows: { default: 1 }, footerRows: { default: 1 } }) });
+exports.tableNodes = (0, prosemirror_tables_1.tableNodes)(tableOptions);
+exports.table = modifyTableSchema(exports.tableNodes.table);
 exports.tableRow = exports.tableNodes.table_row;
-exports.tableCell = exports.tableNodes.table_cell;
-exports.tableHeader = exports.tableNodes.table_header;
+exports.tableCell = modifyTableCellSchema(exports.tableNodes.table_cell);
+exports.tableHeader = modifyTableCellSchema(exports.tableNodes.table_header);

package/dist/cjs/transformer/decode.js

@@ -574,12 +574,14 @@ class Decoder {
                 const figcaption = this.getFigcaption(model);
                 const comments = this.createCommentNodes(model);
                 comments.forEach((c) => this.comments.set(c.attrs.id, c));
-                const content = tableElementFooter
-                    ? [table, tableElementFooter, figcaption]
-                    : [table, figcaption];
+                const content = [table];
                 if (tableColGroup) {
                     content.unshift(tableColGroup);
                 }
+                if (tableElementFooter) {
+                    content.push(tableElementFooter);
+                }
+                content.push(figcaption);
                 if (model.listingID) {
                     const listing = this.createListing(model.listingID);
                     content.push(listing);

package/dist/es/schema/nodes/table.js

@@ -13,127 +13,89 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { tableNodes as createTableNodes, } from 'prosemirror-tables';
 import { getTableCellStyles, serializeTableCellStyles, } from '../../lib/table-cell-styles';
-function getCellAttrs(dom, extraAttrs) {
-    if (typeof dom === 'string') {
-        return {};
+const modifyTableCellSchema = (tableCell) => {
+    const modifiedTableCell = Object.assign({}, tableCell);
+    const originalToDOM = tableCell.toDOM;
+    if (!originalToDOM) {
+        throw new Error(`toDOM not found inside ${tableCell}, check for table schema changes in prosemirror-tables`);
     }
-    const widthAttr = dom.getAttribute('data-colwidth');
-    const widths = widthAttr && /^\d+(,\d+)*$/.test(widthAttr)
-        ? widthAttr.split(',').map((s) => Number(s))
-        : null;
-    const colspan = Number(dom.getAttribute('colspan') || 1);
-    const result = {
-        colspan,
-        rowspan: Number(dom.getAttribute('rowspan') || 1),
-        colwidth: widths && widths.length == colspan ? widths : null,
-    };
-    for (const prop in extraAttrs) {
-        const getter = extraAttrs[prop].getFromDOM;
-        const value = getter && getter(dom);
-        if (value != null) {
-            result[prop] = value;
+    modifiedTableCell.toDOM = function (node) {
+        const originalArray = originalToDOM.call(this, node);
+        if (!Array.isArray(originalArray)) {
+            throw new Error(`${originalArray} is of type ${typeof originalArray}, check for table schema changes in prosemirror-tables`);
         }
-    }
-    return result;
-}
-function setCellAttrs(node, extraAttrs) {
-    const attrs = {};
-    if (node.attrs.colspan != 1) {
-        attrs.colspan = node.attrs.colspan;
-    }
-    if (node.attrs.rowspan != 1) {
-        attrs.rowspan = node.attrs.rowspan;
-    }
-    if (node.attrs.colwidth) {
-        attrs['data-colwidth'] = node.attrs.colwidth.join(',');
-    }
-    if (!node.textContent) {
-        attrs.class = 'placeholder';
-    }
-    for (const prop in extraAttrs) {
-        const setter = extraAttrs[prop].setDOMAttr;
-        if (setter) {
-            setter(node.attrs[prop], attrs);
+        const attrsIndex = originalArray.findIndex((item) => typeof item === 'object' && !Array.isArray(item));
+        const modifiedAttrs = Object.assign({}, originalArray[attrsIndex]);
+        if (!node.textContent) {
+            modifiedAttrs.class = 'placeholder';
         }
+        originalArray[attrsIndex] = modifiedAttrs;
+        return originalArray;
+    };
+    return modifiedTableCell;
+};
+const modifyTableToDOM = (modifiedTable) => {
+    const originalToDOM = modifiedTable.toDOM;
+    if (!originalToDOM) {
+        throw new Error(`toDOM not found inside ${modifiedTable}, check for table schema changes in prosemirror-tables`);
     }
-    return attrs;
-}
-export function createTableNodes(options) {
-    const extraAttrs = options.cellAttributes || {};
-    const cellAttrs = {
-        colspan: { default: 1 },
-        rowspan: { default: 1 },
-        colwidth: { default: null },
+    modifiedTable.toDOM = function (node) {
+        const originalArray = originalToDOM.call(this, node);
+        if (!Array.isArray(originalArray)) {
+            throw new Error(`${originalArray} is of type ${typeof originalArray}, check for table schema changes in prosemirror-tables`);
+        }
+        const modifiedAttrs = {
+            id: node.attrs.id,
+            'data-header-rows': String(node.attrs.headerRows),
+            'data-footer-rows': String(node.attrs.footerRows),
+        };
+        if (Array.isArray(originalArray[1])) {
+            originalArray.splice(1, 0, modifiedAttrs);
+        }
+        else if (typeof originalArray[1] === 'object') {
+            originalArray[1] = Object.assign(Object.assign({}, originalArray[1]), modifiedAttrs);
+        }
+        else {
+            throw new Error(`toDOM[1] ${originalArray[1]} is of type ${typeof originalArray[1]}, check for table schema changes in prosemirror-tables`);
+        }
+        return originalArray;
     };
-    for (const prop in extraAttrs) {
-        cellAttrs[prop] = { default: extraAttrs[prop].default };
+};
+const modifyTableParseDOM = (modifiedTable) => {
+    if (!modifiedTable.parseDOM || !modifiedTable.parseDOM[0]) {
+        throw new Error(`parseDOM not found inside ${modifiedTable}, check for table schema changes in prosemirror-tables`);
     }
-    return {
-        table: {
-            content: 'table_row+',
-            tableRole: 'table',
-            isolating: true,
-            group: options.tableGroup,
-            parseDOM: [
-                {
-                    tag: 'table',
-                    getAttrs: (p) => {
-                        const dom = p;
-                        return {
-                            id: dom.getAttribute('id'),
-                            headerRows: dom.dataset && dom.dataset['header-rows'],
-                            footerRows: dom.dataset && dom.dataset['footer-rows'],
-                        };
-                    },
-                },
-            ],
-            toDOM(node) {
-                return [
-                    'table',
-                    {
-                        id: node.attrs.id,
-                        'data-header-rows': String(node.attrs.headerRows),
-                        'data-footer-rows': String(node.attrs.footerRows),
-                    },
-                    ['tbody', 0],
-                ];
-            },
-        },
-        table_row: {
-            content: '(table_cell | table_header)*',
-            tableRole: 'row',
-            parseDOM: [{ tag: 'tr' }],
-            toDOM() {
-                return ['tr', 0];
-            },
-        },
-        table_cell: {
-            content: options.cellContent,
-            attrs: cellAttrs,
-            tableRole: 'cell',
-            isolating: true,
-            parseDOM: [
-                { tag: 'td', getAttrs: (dom) => getCellAttrs(dom, extraAttrs) },
-            ],
-            toDOM(node) {
-                return ['td', setCellAttrs(node, extraAttrs), 0];
-            },
-        },
-        table_header: {
-            content: options.cellContent,
-            attrs: cellAttrs,
-            tableRole: 'header_cell',
-            isolating: true,
-            parseDOM: [
-                { tag: 'th', getAttrs: (dom) => getCellAttrs(dom, extraAttrs) },
-            ],
-            toDOM(node) {
-                return ['th', setCellAttrs(node, extraAttrs), 0];
-            },
-        },
+    const originalGetAttrs = modifiedTable.parseDOM[0].getAttrs;
+    let originalAttrs;
+    modifiedTable.parseDOM[0].getAttrs = function (p) {
+        const dom = p;
+        if (originalGetAttrs) {
+            originalAttrs = originalGetAttrs.call(this, p);
+        }
+        if (originalAttrs && typeof originalAttrs === 'object') {
+            return Object.assign(Object.assign({}, originalAttrs), { id: dom.getAttribute('id'), headerRows: dom.dataset && dom.dataset['header-rows'], footerRows: dom.dataset && dom.dataset['footer-rows'] });
+        }
+        else {
+            return {
+                id: dom.getAttribute('id'),
+                headerRows: dom.dataset && dom.dataset['header-rows'],
+                footerRows: dom.dataset && dom.dataset['footer-rows'],
+            };
+        }
     };
-}
+};
+const modifyTableAttrs = (modifiedTable, table) => {
+    modifiedTable.attrs = Object.assign(Object.assign({}, table.attrs), { id: { default: '' }, dataTracked: { default: null }, comments: { default: null }, headerRows: { default: 1 }, footerRows: { default: 1 } });
+};
+const modifyTableSchema = (table) => {
+    const modifiedTable = Object.assign({}, table);
+    modifyTableAttrs(modifiedTable, table);
+    modifyTableToDOM(modifiedTable);
+    modifyTableParseDOM(modifiedTable);
+    return modifiedTable;
+};
 const tableOptions = {
     tableGroup: 'block',
     cellContent: 'inline*',
@@ -161,14 +123,6 @@ const tableOptions = {
                 }
             },
         },
-        class: {
-            default: null,
-            setDOMAttr(value, attrs) {
-                if (value) {
-                    attrs['class'] = value;
-                }
-            },
-        },
         valign: {
             default: null,
             getFromDOM(dom) {
@@ -216,7 +170,7 @@ const tableOptions = {
     },
 };
 export const tableNodes = createTableNodes(tableOptions);
-export const table = Object.assign(Object.assign({}, tableNodes.table), { attrs: Object.assign(Object.assign({}, tableNodes.table.attrs), { id: { default: '' }, dataTracked: { default: null }, comments: { default: null }, headerRows: { default: 1 }, footerRows: { default: 1 } }) });
+export const table = modifyTableSchema(tableNodes.table);
 export const tableRow = tableNodes.table_row;
-export const tableCell = tableNodes.table_cell;
-export const tableHeader = tableNodes.table_header;
+export const tableCell = modifyTableCellSchema(tableNodes.table_cell);
+export const tableHeader = modifyTableCellSchema(tableNodes.table_header);

package/dist/es/transformer/decode.js

@@ -565,12 +565,14 @@ export class Decoder {
                 const figcaption = this.getFigcaption(model);
                 const comments = this.createCommentNodes(model);
                 comments.forEach((c) => this.comments.set(c.attrs.id, c));
-                const content = tableElementFooter
-                    ? [table, tableElementFooter, figcaption]
-                    : [table, figcaption];
+                const content = [table];
                 if (tableColGroup) {
                     content.unshift(tableColGroup);
                 }
+                if (tableElementFooter) {
+                    content.push(tableElementFooter);
+                }
+                content.push(figcaption);
                 if (model.listingID) {
                     const listing = this.createListing(model.listingID);
                     content.push(listing);

package/dist/types/schema/nodes/table.d.ts

@@ -13,33 +13,66 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Node } from 'prosemirror-model';
-import { TableNodes, TableNodesOptions } from 'prosemirror-tables';
-export declare function createTableNodes(options: TableNodesOptions): TableNodes;
+import { Node, NodeSpec } from 'prosemirror-model';
+import { TableNodes } from 'prosemirror-tables';
 export declare const tableNodes: TableNodes;
 export declare const table: {
-    attrs: {
-        id: {
-            default: string;
-        };
-        dataTracked: {
-            default: null;
-        };
-        comments: {
-            default: null;
-        };
-        headerRows: {
-            default: number;
-        };
-        footerRows: {
-            default: number;
-        };
-    };
+    [x: string]: any;
     content?: string | undefined;
     marks?: string | undefined;
     group?: string | undefined;
     inline?: boolean | undefined;
     atom?: boolean | undefined;
+    attrs?: {
+        [name: string]: import("prosemirror-model").AttributeSpec;
+    } | undefined;
+    selectable?: boolean | undefined;
+    draggable?: boolean | undefined;
+    code?: boolean | undefined;
+    whitespace?: "pre" | "normal" | undefined;
+    definingAsContext?: boolean | undefined;
+    definingForContent?: boolean | undefined;
+    defining?: boolean | undefined;
+    isolating?: boolean | undefined;
+    toDOM?: ((node: Node) => import("prosemirror-model").DOMOutputSpec) | undefined;
+    parseDOM?: readonly import("prosemirror-model").ParseRule[] | undefined;
+    toDebugString?: ((node: Node) => string) | undefined;
+    leafText?: ((node: Node) => string) | undefined;
+};
+export declare const tableRow: NodeSpec;
+export declare const tableCell: {
+    [x: string]: any;
+    content?: string | undefined;
+    marks?: string | undefined;
+    group?: string | undefined;
+    inline?: boolean | undefined;
+    atom?: boolean | undefined;
+    attrs?: {
+        [name: string]: import("prosemirror-model").AttributeSpec;
+    } | undefined;
+    selectable?: boolean | undefined;
+    draggable?: boolean | undefined;
+    code?: boolean | undefined;
+    whitespace?: "pre" | "normal" | undefined;
+    definingAsContext?: boolean | undefined;
+    definingForContent?: boolean | undefined;
+    defining?: boolean | undefined;
+    isolating?: boolean | undefined;
+    toDOM?: ((node: Node) => import("prosemirror-model").DOMOutputSpec) | undefined;
+    parseDOM?: readonly import("prosemirror-model").ParseRule[] | undefined;
+    toDebugString?: ((node: Node) => string) | undefined;
+    leafText?: ((node: Node) => string) | undefined;
+};
+export declare const tableHeader: {
+    [x: string]: any;
+    content?: string | undefined;
+    marks?: string | undefined;
+    group?: string | undefined;
+    inline?: boolean | undefined;
+    atom?: boolean | undefined;
+    attrs?: {
+        [name: string]: import("prosemirror-model").AttributeSpec;
+    } | undefined;
     selectable?: boolean | undefined;
     draggable?: boolean | undefined;
     code?: boolean | undefined;
@@ -53,6 +86,3 @@ export declare const table: {
     toDebugString?: ((node: Node) => string) | undefined;
     leafText?: ((node: Node) => string) | undefined;
 };
-export declare const tableRow: import("prosemirror-model").NodeSpec;
-export declare const tableCell: import("prosemirror-model").NodeSpec;
-export declare const tableHeader: import("prosemirror-model").NodeSpec;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@manuscripts/transform",
   "description": "ProseMirror transformer for Manuscripts applications",
-  "version": "2.1.1-LEAN-3336-13",
+  "version": "2.1.1-LEAN-3336-16",
   "repository": "github:Atypon-OpenSource/manuscripts-transform",
   "license": "Apache-2.0",
   "main": "dist/cjs",