@milkdown/preset-gfm 6.1.4 → 6.3.0

package/src/table/plugin/util.ts

@@ -0,0 +1,107 @@
+/* Copyright 2021, Milkdown by Mirone. */
+import { Attrs, Node, ResolvedPos } from '@milkdown/prose/model';
+import { EditorState, NodeSelection } from '@milkdown/prose/state';
+
+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;
+}
+
+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;
+}
+
+export function pointsAtCell($pos: ResolvedPos): Node | 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);
+}
+
+export function inSameTable($a: ResolvedPos, $b: ResolvedPos) {
+    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);
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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);
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}

package/src/table/utils.ts

@@ -2,7 +2,10 @@
 import { cloneTr, findParentNode } from '@milkdown/prose';
 import { Node as ProsemirrorNode, Schema } from '@milkdown/prose/model';
 import { Selection, Transaction } from '@milkdown/prose/state';
-import { CellSelection, TableMap, tableNodeTypes, TableRect } from '@milkdown/prose/tables';
+
+import { CellSelection } from './plugin/cell-selection';
+import { tableNodeTypes } from './plugin/schema';
+import { Rect, TableMap } from './plugin/table-map';
 
 export type CellPos = {
     pos: number;
@@ -23,16 +26,19 @@ export const getCellsInColumn =
             return undefined;
         }
 
-        return map.cellsInRect({ left: columnIndex, right: columnIndex + 1, top: 0, bottom: map.height }).map((pos) => {
-            const node = table.node.nodeAt(pos);
-            if (!node) throw new Error();
-            const start = pos + table.start;
-            return {
-                pos: start,
-                start: start + 1,
-                node,
-            };
-        });
+        return map
+            .cellsInRect({ left: columnIndex, right: columnIndex + 1, top: 0, bottom: map.height })
+            .map((pos) => {
+                const node = table.node.nodeAt(pos);
+                if (!node) return;
+                const start = pos + table.start;
+                return {
+                    pos: start,
+                    start: start + 1,
+                    node,
+                };
+            })
+            .filter((x): x is CellPos => x != null);
     };
 
 export const getCellsInRow =
@@ -45,16 +51,19 @@ export const getCellsInRow =
             return undefined;
         }
 
-        return map.cellsInRect({ left: 0, right: map.width, top: rowIndex, bottom: rowIndex + 1 }).map((pos) => {
-            const node = table.node.nodeAt(pos);
-            if (!node) throw new Error();
-            const start = pos + table.start;
-            return {
-                pos: start,
-                start: start + 1,
-                node,
-            };
-        });
+        return map
+            .cellsInRect({ left: 0, right: map.width, top: rowIndex, bottom: rowIndex + 1 })
+            .map((pos) => {
+                const node = table.node.nodeAt(pos);
+                if (!node) return;
+                const start = pos + table.start;
+                return {
+                    pos: start,
+                    start: start + 1,
+                    node,
+                };
+            })
+            .filter((x): x is CellPos => x != null);
     };
 
 export const createTable = (schema: Schema, rowsCount = 3, colsCount = 3) => {
@@ -132,7 +141,7 @@ export const selectTable = (tr: Transaction) => {
     return tr;
 };
 
-export function addRowWithAlignment(tr: Transaction, { map, tableStart, table }: TableRect, row: number) {
+export function addRowWithAlignment(tr: Transaction, { map, tableStart, table }: Required<Rect>, row: number) {
     const rowPos = Array(row)
         .fill(0)
         .reduce((acc, _, i) => {

package/src/task-list-item.ts

@@ -1,8 +1,10 @@
 /* Copyright 2021, Milkdown by Mirone. */
 import { createCmd, createCmdKey, editorViewCtx, ThemeTaskListItemType } from '@milkdown/core';
+import { expectDomTypeError } from '@milkdown/exception';
 import { wrapIn } from '@milkdown/prose/commands';
 import { wrappingInputRule } from '@milkdown/prose/inputrules';
 import { liftListItem, sinkListItem, splitListItem } from '@milkdown/prose/schema-list';
+import { NodeView } from '@milkdown/prose/view';
 import { createNode, createShortcut } from '@milkdown/utils';
 
 import { SupportedKeys } from './supported-keys';
@@ -34,7 +36,7 @@ export const taskListItem = createNode<Keys>((utils) => {
                     tag: 'li[data-type="task-item"]',
                     getAttrs: (dom) => {
                         if (!(dom instanceof HTMLElement)) {
-                            throw new Error();
+                            throw expectDomTypeError(dom);
                         }
                         return { checked: dom.dataset['checked'] === 'true' };
                     },
@@ -130,7 +132,7 @@ export const taskListItem = createNode<Keys>((utils) => {
                 },
             });
 
-            if (!renderer) return {};
+            if (!renderer) return {} as NodeView;
 
             const { dom, contentDOM, onUpdate } = renderer;
             onUpdate(currNode);

package/lib/table/nodes/schema.d.ts

@@ -1,2 +0,0 @@
-export declare const schema: import("@milkdown/prose/tables").TableNodes;
-//# sourceMappingURL=schema.d.ts.map

package/lib/table/nodes/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/table/nodes/schema.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM,6CAYjB,CAAC"}

package/src/table/nodes/schema.ts

@@ -1,16 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-import { tableNodes as tableNodesSpecCreator } from '@milkdown/prose/tables';
-
-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'}`;
-            },
-        },
-    },
-});