@milkdown/preset-gfm 6.5.2 → 6.5.4

package/src/table/plugin/table-view.ts

@@ -1,76 +1,80 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { Node } from '@milkdown/prose/model';
-import { NodeView } from '@milkdown/prose/view';
+import type { Node } from '@milkdown/prose/model'
+import type { NodeView } from '@milkdown/prose/view'
 
-/* Copyright 2021, Milkdown by Mirone. */
 export class TableView implements NodeView {
-    public dom: HTMLElement;
-    public contentDOM: HTMLElement;
-    public table: HTMLTableElement;
-    public colgroup: HTMLTableColElement;
+  public dom: HTMLElement
+  public contentDOM: HTMLElement
+  public table: HTMLTableElement
+  public colgroup: HTMLTableColElement
 
-    constructor(public node: Node, public cellMinWidth: number) {
-        this.node = node;
-        this.cellMinWidth = cellMinWidth;
-        this.dom = document.createElement('div');
-        this.dom.className = 'tableWrapper';
-        this.table = this.dom.appendChild(document.createElement('table'));
-        this.colgroup = this.table.appendChild(document.createElement('colgroup'));
-        updateColumns(node, this.colgroup, this.table, cellMinWidth);
-        this.contentDOM = this.table.appendChild(document.createElement('tbody'));
-    }
+  constructor(public node: Node, public cellMinWidth: number) {
+    this.node = node
+    this.cellMinWidth = cellMinWidth
+    this.dom = document.createElement('div')
+    this.dom.className = 'tableWrapper'
+    this.table = this.dom.appendChild(document.createElement('table'))
+    this.colgroup = this.table.appendChild(document.createElement('colgroup'))
+    updateColumns(node, this.colgroup, this.table, cellMinWidth)
+    this.contentDOM = this.table.appendChild(document.createElement('tbody'))
+  }
 
-    update(node: Node) {
-        if (node.type != this.node.type) return false;
-        this.node = node;
-        updateColumns(node, this.colgroup, this.table, this.cellMinWidth);
-        return true;
-    }
+  update(node: Node) {
+    if (node.type != this.node.type)
+      return false
+    this.node = node
+    updateColumns(node, this.colgroup, this.table, this.cellMinWidth)
+    return true
+  }
 
-    ignoreMutation(record: MutationRecord) {
-        return record.type == 'attributes' && (record.target == this.table || this.colgroup.contains(record.target));
-    }
+  ignoreMutation(record: MutationRecord) {
+    return record.type == 'attributes' && (record.target == this.table || this.colgroup.contains(record.target))
+  }
 }
 
 export function updateColumns(
-    node: Node,
-    colgroup: HTMLTableColElement,
-    table: HTMLTableElement,
-    cellMinWidth: number,
-    overrideCol?: number,
-    overrideValue?: number,
+  node: Node,
+  colgroup: HTMLTableColElement,
+  table: HTMLTableElement,
+  cellMinWidth: number,
+  overrideCol?: number,
+  overrideValue?: number,
 ) {
-    let totalWidth = 0,
-        fixedWidth = true;
-    let nextDOM = colgroup.firstChild;
-    const row = node.firstChild as Node;
-    for (let i = 0, col = 0; i < row.childCount; i++) {
-        const { colspan, colwidth } = row.child(i).attrs;
-        for (let j = 0; j < colspan; j++, col++) {
-            const hasWidth = overrideCol == col ? overrideValue : colwidth && colwidth[j];
-            const cssWidth = hasWidth ? hasWidth + 'px' : '';
-            totalWidth += hasWidth || cellMinWidth;
-            if (!hasWidth) fixedWidth = false;
-            if (!nextDOM) {
-                colgroup.appendChild(document.createElement('col')).style.width = cssWidth;
-            } else {
-                if ((nextDOM as HTMLElement).style.width != cssWidth) (nextDOM as HTMLElement).style.width = cssWidth;
-                nextDOM = nextDOM.nextSibling;
-            }
-        }
+  let totalWidth = 0
+  let fixedWidth = true
+  let nextDOM = colgroup.firstChild
+  const row = node.firstChild as Node
+  for (let i = 0, col = 0; i < row.childCount; i++) {
+    const { colspan, colwidth } = row.child(i).attrs
+    for (let j = 0; j < colspan; j++, col++) {
+      const hasWidth = overrideCol == col ? overrideValue : colwidth && colwidth[j]
+      const cssWidth = hasWidth ? `${hasWidth}px` : ''
+      totalWidth += hasWidth || cellMinWidth
+      if (!hasWidth)
+        fixedWidth = false
+      if (!nextDOM) {
+        colgroup.appendChild(document.createElement('col')).style.width = cssWidth
+      }
+      else {
+        if ((nextDOM as HTMLElement).style.width != cssWidth)
+          (nextDOM as HTMLElement).style.width = cssWidth
+        nextDOM = nextDOM.nextSibling
+      }
     }
+  }
 
-    while (nextDOM) {
-        const after = nextDOM.nextSibling;
-        nextDOM.parentNode?.removeChild(nextDOM);
-        nextDOM = after;
-    }
+  while (nextDOM) {
+    const after = nextDOM.nextSibling
+    nextDOM.parentNode?.removeChild(nextDOM)
+    nextDOM = after
+  }
 
-    if (fixedWidth) {
-        table.style.width = totalWidth + 'px';
-        table.style.minWidth = '';
-    } else {
-        table.style.width = '';
-        table.style.minWidth = totalWidth + 'px';
-    }
+  if (fixedWidth) {
+    table.style.width = `${totalWidth}px`
+    table.style.minWidth = ''
+  }
+  else {
+    table.style.width = ''
+    table.style.minWidth = `${totalWidth}px`
+  }
 }

package/src/table/plugin/types.ts

@@ -1,16 +1,16 @@
 /* Copyright 2021, Milkdown by Mirone. */
 
-export type getFromDOM<T> = (dom: Element) => T;
-export type setDOMAttr = <Value>(value: Value, attrs: Record<string, unknown>) => void;
+export type getFromDOM<T> = (dom: Element) => T
+export type setDOMAttr = <Value>(value: Value, attrs: Record<string, unknown>) => void
 
 export interface CellAttributes<T = unknown> {
-    default: T;
-    getFromDOM?: getFromDOM<T>;
-    setDOMAttr?: setDOMAttr;
+  default: T
+  getFromDOM?: getFromDOM<T>
+  setDOMAttr?: setDOMAttr
 }
 
 export interface TableNodesOptions {
-    tableGroup?: string;
-    cellContent: string;
-    cellAttributes: { [key: string]: CellAttributes };
+  tableGroup?: string
+  cellContent: string
+  cellAttributes: { [key: string]: CellAttributes }
 }

package/src/table/plugin/util.ts

@@ -1,107 +1,119 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { Attrs, Node, ResolvedPos } from '@milkdown/prose/model';
-import { EditorState, NodeSelection } from '@milkdown/prose/state';
+import type { Attrs, Node, ResolvedPos } from '@milkdown/prose/model'
+import type { EditorState, NodeSelection } from '@milkdown/prose/state'
 
-import { CellSelection } from './cell-selection';
-import { tableNodeTypes } from './schema';
-import { TableMap } from './table-map';
+import { CellSelection } from './cell-selection'
+import { tableNodeTypes } from './schema'
+import { TableMap } from './table-map'
 
 export function cellAround($pos: ResolvedPos) {
-    for (let d = $pos.depth - 1; d > 0; d--)
-        if ($pos.node(d).type.spec['tableRole'] == 'row') return $pos.node(0).resolve($pos.before(d + 1));
-    return undefined;
+  for (let d = $pos.depth - 1; d > 0; d--) {
+    if ($pos.node(d).type.spec.tableRole == 'row')
+      return $pos.node(0).resolve($pos.before(d + 1))
+  }
+  return undefined
 }
 
 export function cellWrapping($pos: ResolvedPos) {
-    for (let d = $pos.depth; d > 0; d--) {
-        // Sometimes the cell can be in the same depth.
-        const role = $pos.node(d).type.spec['tableRole'];
-        if (role === 'cell' || role === 'header_cell') return $pos.node(d);
-    }
-    return null;
+  for (let d = $pos.depth; d > 0; d--) {
+    // Sometimes the cell can be in the same depth.
+    const role = $pos.node(d).type.spec.tableRole
+    if (role === 'cell' || role === 'header_cell')
+      return $pos.node(d)
+  }
+  return null
 }
 
 export function pointsAtCell($pos: ResolvedPos): Node | null {
-    if ($pos.parent.type.spec['tableRole'] == 'row') return $pos.nodeAfter;
-    return null;
+  if ($pos.parent.type.spec.tableRole == 'row')
+    return $pos.nodeAfter
+  return null
 }
 
 export function moveCellForward($pos: ResolvedPos) {
-    return $pos.node(0).resolve($pos.pos + ($pos.nodeAfter as Node).nodeSize);
+  return $pos.node(0).resolve($pos.pos + ($pos.nodeAfter as Node).nodeSize)
 }
 
 export function inSameTable($a: ResolvedPos, $b: ResolvedPos) {
-    return $a.depth == $b.depth && $a.pos >= $b.start(-1) && $a.pos <= $b.end(-1);
+  return $a.depth == $b.depth && $a.pos >= $b.start(-1) && $a.pos <= $b.end(-1)
 }
 
 export function nextCell($pos: ResolvedPos, axis: string, dir: number) {
-    const start = $pos.start(-1),
-        map = TableMap.get($pos.node(-1));
-    const moved = map.nextCell($pos.pos - start, axis, dir);
-    return moved == null ? null : $pos.node(0).resolve(start + moved);
+  const start = $pos.start(-1)
+  const map = TableMap.get($pos.node(-1))
+  const moved = map.nextCell($pos.pos - start, axis, dir)
+  return moved == null ? null : $pos.node(0).resolve(start + moved)
 }
 
 export function setAttr<T>(attrs: Attrs, name: string, value: T) {
-    const result: Record<string, unknown> = {};
-    for (const prop in attrs) result[prop] = attrs[prop];
-    result[name] = value;
-    return result as Attrs;
+  const result: Record<string, unknown> = {}
+  for (const prop in attrs) result[prop] = attrs[prop]
+  result[name] = value
+  return result as Attrs
 }
 
 export function removeColSpan(attrs: Attrs, pos: number, n = 1) {
-    const result = setAttr(attrs, 'colspan', attrs['colspan'] - n) as Record<string, unknown>;
-    if (result['colwidth']) {
-        const widths = result['colwidth'] as number[];
-        result['colwidth'] = widths.slice();
-        widths.splice(pos, n);
-        if (!widths.some((w) => w > 0)) result['colwidth'] = null;
-    }
-    return result;
+  const result = setAttr(attrs, 'colspan', attrs.colspan - n) as Record<string, unknown>
+  if (result.colwidth) {
+    const widths = result.colwidth as number[]
+    result.colwidth = widths.slice()
+    widths.splice(pos, n)
+    if (!widths.some(w => w > 0))
+      result.colwidth = null
+  }
+  return result
 }
 
 export function isInTable(state: EditorState) {
-    const $head = state.selection.$head;
-    for (let d = $head.depth; d > 0; d--) if ($head.node(d).type.spec['tableRole'] == 'row') return true;
-    return false;
+  const $head = state.selection.$head
+  for (let d = $head.depth; d > 0; d--) {
+    if ($head.node(d).type.spec.tableRole == 'row')
+      return true
+  }
+  return false
 }
 
 export function selectionCell(state: EditorState) {
-    const sel = state.selection;
-    if (sel instanceof CellSelection) {
-        return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
-    } else if ((sel as NodeSelection).node && (sel as NodeSelection).node.type.spec['tableRole'] == 'cell') {
-        return sel.$anchor;
-    }
-    return cellAround(sel.$head) || cellNear(sel.$head);
+  const sel = state.selection
+  if (sel instanceof CellSelection)
+    return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell
+  else if ((sel as NodeSelection).node && (sel as NodeSelection).node.type.spec.tableRole == 'cell')
+    return sel.$anchor
+
+  return cellAround(sel.$head) || cellNear(sel.$head)
 }
 
 function cellNear($pos: ResolvedPos) {
-    for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
-        const role = after.type.spec['tableRole'];
-        if (role == 'cell' || role == 'header_cell') return $pos.doc.resolve(pos);
-    }
-    for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
-        const role = before.type.spec['tableRole'];
-        if (role == 'cell' || role == 'header_cell') return $pos.doc.resolve(pos - before.nodeSize);
-    }
-    return;
+  for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
+    const role = after.type.spec.tableRole
+    if (role == 'cell' || role == 'header_cell')
+      return $pos.doc.resolve(pos)
+  }
+  for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
+    const role = before.type.spec.tableRole
+    if (role == 'cell' || role == 'header_cell')
+      return $pos.doc.resolve(pos - before.nodeSize)
+  }
+
+  return undefined
 }
 
 export function addColSpan(attrs: Attrs, pos: number, n = 1) {
-    const result = setAttr(attrs, 'colspan', attrs['colspan'] + n) as Record<string, unknown>;
-    if (result['colwidth']) {
-        const widths = result['colwidth'] as number[];
-        result['colwidth'] = widths.slice();
-        for (let i = 0; i < n; i++) widths.splice(pos, 0, 0);
-    }
-    return result as Attrs;
+  const result = setAttr(attrs, 'colspan', attrs.colspan + n) as Record<string, unknown>
+  if (result.colwidth) {
+    const widths = result.colwidth as number[]
+    result.colwidth = widths.slice()
+    for (let i = 0; i < n; i++) widths.splice(pos, 0, 0)
+  }
+  return result as Attrs
 }
 
 export function columnIsHeader(map: TableMap, table: Node, col: number) {
-    const headerCell = tableNodeTypes(table.type.schema).header_cell;
-    for (let row = 0; row < map.height; row++) {
-        const pos = map.map[col + row * map.width] as number;
-        if ((table.nodeAt(pos) as Node).type != headerCell) return false;
-    }
-    return true;
+  const headerCell = tableNodeTypes(table.type.schema).header_cell
+  for (let row = 0; row < map.height; row++) {
+    const pos = map.map[col + row * map.width] as number
+    if ((table.nodeAt(pos) as Node).type != headerCell)
+      return false
+  }
+  return true
 }