@milkdown/preset-gfm 6.5.2 → 6.5.3

package/src/table/plugin/fix-tables.ts

@@ -1,34 +1,39 @@
 /* Copyright 2021, Milkdown by Mirone. */
 
-import { Node } from '@milkdown/prose/model';
-import { EditorState, PluginKey, Transaction } from '@milkdown/prose/state';
+import type { Node } from '@milkdown/prose/model'
+import type { EditorState, Transaction } from '@milkdown/prose/state'
+import { PluginKey } from '@milkdown/prose/state'
 
-import { tableNodeTypes } from './schema';
-import { Problem, TableMap } from './table-map';
-import { removeColSpan, setAttr } from './util';
+import { tableNodeTypes } from './schema'
+import type { Problem } from './table-map'
+import { TableMap } from './table-map'
+import { removeColSpan, setAttr } from './util'
 
-export const fixTablesKey = new PluginKey('fix-tables');
+export const fixTablesKey = new PluginKey('fix-tables')
 
 // Helper for iterating through the nodes in a document that changed
 // compared to the given previous document. Useful for avoiding
 // duplicate work on each transaction.
 function changedDescendants(old: Node, cur: Node, offset: number, f: (node: Node, pos: number) => void | boolean) {
-    const oldSize = old.childCount,
-        curSize = cur.childCount;
-    outer: for (let i = 0, j = 0; i < curSize; i++) {
-        const child = cur.child(i);
-        for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
-            if (old.child(scan) == child) {
-                j = scan + 1;
-                offset += child.nodeSize;
-                continue outer;
-            }
-        }
-        f(child, offset);
-        if (j < oldSize && old.child(j).sameMarkup(child)) changedDescendants(old.child(j), child, offset + 1, f);
-        else child.nodesBetween(0, child.content.size, f, offset + 1);
-        offset += child.nodeSize;
+  const oldSize = old.childCount
+  const curSize = cur.childCount
+  // eslint-disable-next-line no-restricted-syntax, no-labels
+  outer: for (let i = 0, j = 0; i < curSize; i++) {
+    const child = cur.child(i)
+    for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
+      if (old.child(scan) == child) {
+        j = scan + 1
+        offset += child.nodeSize
+        // eslint-disable-next-line no-labels
+        continue outer
+      }
     }
+    f(child, offset)
+    if (j < oldSize && old.child(j).sameMarkup(child))
+      changedDescendants(old.child(j), child, offset + 1, f)
+    else child.nodesBetween(0, child.content.size, f, offset + 1)
+    offset += child.nodeSize
+  }
 }
 
 // :: (EditorState, ?EditorState) → ?Transaction
@@ -38,80 +43,90 @@ function changedDescendants(old: Node, cur: Node, offset: number, f: (node: Node
 // which will be used to avoid re-scanning unchanged parts of the
 // document.
 export function fixTables(state: EditorState, oldState: EditorState) {
-    let tr: undefined | Transaction;
-    const check = (node: Node, pos: number) => {
-        if (node.type.spec['tableRole'] == 'table') tr = fixTable(state, node, pos, tr);
-    };
-    if (!oldState) state.doc.descendants(check);
-    else if (oldState.doc != state.doc) changedDescendants(oldState.doc, state.doc, 0, check);
-    return tr;
+  let tr: undefined | Transaction
+  const check = (node: Node, pos: number) => {
+    if (node.type.spec.tableRole == 'table')
+      tr = fixTable(state, node, pos, tr)
+  }
+  if (!oldState)
+    state.doc.descendants(check)
+  else if (oldState.doc != state.doc)
+    changedDescendants(oldState.doc, state.doc, 0, check)
+  return tr
 }
 
 // : (EditorState, Node, number, ?Transaction) → ?Transaction
 // Fix the given table, if necessary. Will append to the transaction
 // it was given, if non-null, or create a new one if necessary.
 export function fixTable(state: EditorState, table: Node, tablePos: number, tr?: Transaction) {
-    const map = TableMap.get(table);
-    if (!map.problems) return tr;
-    if (!tr) tr = state.tr;
+  const map = TableMap.get(table)
+  if (!map.problems)
+    return tr
+  if (!tr)
+    tr = state.tr
 
-    // Track which rows we must add cells to, so that we can adjust that
-    // when fixing collisions.
-    const mustAdd = [];
-    for (let i = 0; i < map.height; i++) mustAdd.push(0);
-    for (let i = 0; i < map.problems.length; i++) {
-        const prob = map.problems[i] as Problem;
-        if (prob.type == 'collision') {
-            const cell = table.nodeAt(prob.pos) as Node;
-            for (let j = 0; j < cell.attrs['rowspan']; j++) mustAdd[prob.row + j] += prob.n;
-            tr.setNodeMarkup(
-                tr.mapping.map(tablePos + 1 + prob.pos),
-                null,
-                removeColSpan(cell.attrs, cell.attrs['colspan'] - prob.n, prob.n),
-            );
-        } else if (prob.type == 'missing') {
-            mustAdd[prob.row] += prob.n;
-        } else if (prob.type == 'overlong_rowspan') {
-            const cell = table.nodeAt(prob.pos) as Node;
-            tr.setNodeMarkup(
-                tr.mapping.map(tablePos + 1 + prob.pos),
-                null,
-                setAttr(cell.attrs, 'rowspan', cell.attrs['rowspan'] - prob.n),
-            );
-        } else if (prob.type == 'colwidth mismatch') {
-            const cell = table.nodeAt(prob.pos) as Node;
-            tr.setNodeMarkup(
-                tr.mapping.map(tablePos + 1 + prob.pos),
-                null,
-                setAttr(cell.attrs, 'colwidth', prob.colwidth),
-            );
-        }
+  // Track which rows we must add cells to, so that we can adjust that
+  // when fixing collisions.
+  const mustAdd = []
+  for (let i = 0; i < map.height; i++) mustAdd.push(0)
+  for (let i = 0; i < map.problems.length; i++) {
+    const prob = map.problems[i] as Problem
+    if (prob.type == 'collision') {
+      const cell = table.nodeAt(prob.pos) as Node
+      for (let j = 0; j < cell.attrs.rowspan; j++) mustAdd[prob.row + j] += prob.n
+      tr.setNodeMarkup(
+        tr.mapping.map(tablePos + 1 + prob.pos),
+        null,
+        removeColSpan(cell.attrs, cell.attrs.colspan - prob.n, prob.n),
+      )
     }
-    let first, last;
-    for (let i = 0; i < mustAdd.length; i++)
-        if (mustAdd[i]) {
-            if (first == null) first = i;
-            last = i;
-        }
-    // Add the necessary cells, using a heuristic for whether to add the
-    // cells at the start or end of the rows (if it looks like a 'bite'
-    // was taken out of the table, add cells at the start of the row
-    // after the bite. Otherwise add them at the end).
-    for (let i = 0, pos = tablePos + 1; i < map.height; i++) {
-        const row = table.child(i);
-        const end = pos + row.nodeSize;
-        const add = mustAdd[i] as number;
-        if (add > 0) {
-            let tableNodeType = 'cell';
-            if (row.firstChild) {
-                tableNodeType = row.firstChild.type.spec['tableRole'];
-            }
-            const nodes = [];
-            for (let j = 0; j < add; j++) nodes.push(tableNodeTypes(state.schema)[tableNodeType].createAndFill());
-            const side = (i == 0 || first == i - 1) && last == i ? pos + 1 : end - 1;
-            tr.insert(tr.mapping.map(side), nodes);
-        }
-        pos = end;
+    else if (prob.type == 'missing') {
+      mustAdd[prob.row] += prob.n
     }
-    return tr.setMeta(fixTablesKey, { fixTables: true });
+    else if (prob.type == 'overlong_rowspan') {
+      const cell = table.nodeAt(prob.pos) as Node
+      tr.setNodeMarkup(
+        tr.mapping.map(tablePos + 1 + prob.pos),
+        null,
+        setAttr(cell.attrs, 'rowspan', cell.attrs.rowspan - prob.n),
+      )
+    }
+    else if (prob.type == 'colwidth mismatch') {
+      const cell = table.nodeAt(prob.pos) as Node
+      tr.setNodeMarkup(
+        tr.mapping.map(tablePos + 1 + prob.pos),
+        null,
+        setAttr(cell.attrs, 'colwidth', prob.colwidth),
+      )
+    }
+  }
+  let first, last
+  for (let i = 0; i < mustAdd.length; i++) {
+    if (mustAdd[i]) {
+      if (first == null)
+        first = i
+      last = i
+    }
+  }
+  // Add the necessary cells, using a heuristic for whether to add the
+  // cells at the start or end of the rows (if it looks like a 'bite'
+  // was taken out of the table, add cells at the start of the row
+  // after the bite. Otherwise add them at the end).
+  for (let i = 0, pos = tablePos + 1; i < map.height; i++) {
+    const row = table.child(i)
+    const end = pos + row.nodeSize
+    const add = mustAdd[i] as number
+    if (add > 0) {
+      let tableNodeType = 'cell'
+      if (row.firstChild)
+        tableNodeType = row.firstChild.type.spec.tableRole
+
+      const nodes = []
+      for (let j = 0; j < add; j++) nodes.push(tableNodeTypes(state.schema)[tableNodeType].createAndFill())
+      const side = (i == 0 || first == i - 1) && last == i ? pos + 1 : end - 1
+      tr.insert(tr.mapping.map(side), nodes)
+    }
+    pos = end
+  }
+  return tr.setMeta(fixTablesKey, { fixTables: true })
 }

package/src/table/plugin/index.ts

@@ -1,4 +1,4 @@
 /* Copyright 2021, Milkdown by Mirone. */
-export * from './cell-selection';
-export * from './commands';
-export * from './util';
+export * from './cell-selection'
+export * from './commands'
+export * from './util'

package/src/table/plugin/schema.ts

@@ -1,114 +1,120 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { Attrs, Node, NodeSpec, Schema } from '@milkdown/prose/model';
+import type { Attrs, Node, NodeSpec, Schema } from '@milkdown/prose/model'
 
-import { TableNodesOptions } from './types';
+import type { TableNodesOptions } from './types'
 
 function getCellAttrs(dom: HTMLElement, extraAttrs: Attrs) {
-    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 as keyof typeof result] = value;
-    }
-    return result;
+  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 as keyof typeof result] = value
+  }
+  return result
 }
 
 function setCellAttrs(node: Node, extraAttrs: Attrs) {
-    const attrs: Record<string, unknown> = {};
-    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(',');
-    for (const prop in extraAttrs) {
-        const setter = extraAttrs[prop].setDOMAttr;
-        if (setter) setter(node.attrs[prop], attrs);
-    }
-    return attrs;
+  const attrs: Record<string, unknown> = {}
+  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(',')
+  for (const prop in extraAttrs) {
+    const setter = extraAttrs[prop].setDOMAttr
+    if (setter)
+      setter(node.attrs[prop], attrs)
+  }
+  return attrs
 }
 
 function tableNodesSpecCreator(options: TableNodesOptions) {
-    const extraAttrs: Attrs = options.cellAttributes || {};
-    const cellAttrs: Record<string, unknown> = {
-        colspan: { default: 1 },
-        rowspan: { default: 1 },
-        colwidth: { default: null },
-    };
-    for (const prop in extraAttrs) cellAttrs[prop] = { default: extraAttrs[prop].default };
-    const finalAttrs = cellAttrs as Attrs;
+  const extraAttrs: Attrs = options.cellAttributes || {}
+  const cellAttrs: Record<string, unknown> = {
+    colspan: { default: 1 },
+    rowspan: { default: 1 },
+    colwidth: { default: null },
+  }
+  for (const prop in extraAttrs) cellAttrs[prop] = { default: extraAttrs[prop].default }
+  const finalAttrs = cellAttrs as Attrs
 
-    const schema: Record<'table' | 'table_row' | 'table_cell' | 'table_header', NodeSpec> = {
-        table: {
-            content: 'table_row+',
-            tableRole: 'table',
-            isolating: true,
-            group: options.tableGroup,
-            parseDOM: [{ tag: 'table' }],
-            toDOM() {
-                return ['table', ['tbody', 0]];
-            },
-        },
-        table_row: {
-            content: '(table_cell | table_header)*',
-            tableRole: 'row',
-            parseDOM: [{ tag: 'tr' }],
-            toDOM() {
-                return ['tr', 0];
-            },
-        },
-        table_cell: {
-            content: options.cellContent,
-            attrs: finalAttrs,
-            tableRole: 'cell',
-            isolating: true,
-            parseDOM: [{ tag: 'td', getAttrs: (dom) => getCellAttrs(dom as HTMLElement, extraAttrs) }],
-            toDOM(node) {
-                return ['td', setCellAttrs(node, extraAttrs), 0];
-            },
-        },
-        table_header: {
-            content: options.cellContent,
-            attrs: finalAttrs,
-            tableRole: 'header_cell',
-            isolating: true,
-            parseDOM: [{ tag: 'th', getAttrs: (dom) => getCellAttrs(dom as HTMLElement, extraAttrs) }],
-            toDOM(node) {
-                return ['th', setCellAttrs(node, extraAttrs), 0];
-            },
-        },
-    };
+  const schema: Record<'table' | 'table_row' | 'table_cell' | 'table_header', NodeSpec> = {
+    table: {
+      content: 'table_row+',
+      tableRole: 'table',
+      isolating: true,
+      group: options.tableGroup,
+      parseDOM: [{ tag: 'table' }],
+      toDOM() {
+        return ['table', ['tbody', 0]]
+      },
+    },
+    table_row: {
+      content: '(table_cell | table_header)*',
+      tableRole: 'row',
+      parseDOM: [{ tag: 'tr' }],
+      toDOM() {
+        return ['tr', 0]
+      },
+    },
+    table_cell: {
+      content: options.cellContent,
+      attrs: finalAttrs,
+      tableRole: 'cell',
+      isolating: true,
+      parseDOM: [{ tag: 'td', getAttrs: dom => getCellAttrs(dom as HTMLElement, extraAttrs) }],
+      toDOM(node) {
+        return ['td', setCellAttrs(node, extraAttrs), 0]
+      },
+    },
+    table_header: {
+      content: options.cellContent,
+      attrs: finalAttrs,
+      tableRole: 'header_cell',
+      isolating: true,
+      parseDOM: [{ tag: 'th', getAttrs: dom => getCellAttrs(dom as HTMLElement, extraAttrs) }],
+      toDOM(node) {
+        return ['th', setCellAttrs(node, extraAttrs), 0]
+      },
+    },
+  }
 
-    return schema;
+  return schema
 }
 
 export function tableNodeTypes(schema: Schema) {
-    let result = schema.cached['tableNodeTypes'];
-    if (!result) {
-        result = schema.cached['tableNodeTypes'] = {};
-        for (const name in schema.nodes) {
-            const type = schema.nodes[name],
-                role = type?.spec['tableRole'];
-            if (role) result[role] = type;
-        }
+  let result = schema.cached.tableNodeTypes
+  if (!result) {
+    result = schema.cached.tableNodeTypes = {}
+    for (const name in schema.nodes) {
+      const type = schema.nodes[name]
+      const role = type?.spec.tableRole
+      if (role)
+        result[role] = type
     }
-    return result;
+  }
+  return result
 }
 
 export const schema = tableNodesSpecCreator({
-    tableGroup: 'block',
-    cellContent: 'paragraph',
-    cellAttributes: {
-        alignment: {
-            default: 'left',
-            getFromDOM: (dom) => (dom as HTMLElement).style.textAlign || 'left',
-            setDOMAttr: (value, attrs) => {
-                attrs['style'] = `text-align: ${value || 'left'}`;
-            },
-        },
+  tableGroup: 'block',
+  cellContent: 'paragraph',
+  cellAttributes: {
+    alignment: {
+      default: 'left',
+      getFromDOM: dom => (dom as HTMLElement).style.textAlign || 'left',
+      setDOMAttr: (value, attrs) => {
+        attrs.style = `text-align: ${value || 'left'}`
+      },
     },
-});
+  },
+})