@prosekit/extensions 0.0.0-next-20240724172520 → 0.0.0-next-20240901092634

package/dist/prosekit-extensions-table.d.ts

@@ -1,13 +1,25 @@
 export { defineTable } from './_tsup-dts-rollup';
 export { TableExtension } from './_tsup-dts-rollup';
-export { defineTableCellSpec } from './_tsup-dts-rollup';
 export { defineTableCommands } from './_tsup-dts-rollup';
-export { defineTableHeaderCellSpec } from './_tsup-dts-rollup';
+export { exitTable } from './_tsup-dts-rollup';
+export { insertTable } from './_tsup-dts-rollup';
+export { selectTable } from './_tsup-dts-rollup';
+export { selectTableCell } from './_tsup-dts-rollup';
+export { selectTableColumn } from './_tsup-dts-rollup';
+export { selectTableRow } from './_tsup-dts-rollup';
+export { InsertTableOptions } from './_tsup-dts-rollup';
+export { SelectTableCellOptions } from './_tsup-dts-rollup';
+export { SelectTableColumnOptions } from './_tsup-dts-rollup';
+export { SelectTableOptions } from './_tsup-dts-rollup';
+export { SelectTableRowOptions } from './_tsup-dts-rollup';
+export { TableCommandsExtension } from './_tsup-dts-rollup';
 export { defineTablePlugins } from './_tsup-dts-rollup';
+export { defineTableCellSpec } from './_tsup-dts-rollup';
+export { defineTableHeaderCellSpec } from './_tsup-dts-rollup';
 export { defineTableRowSpec } from './_tsup-dts-rollup';
 export { defineTableSpec } from './_tsup-dts-rollup';
 export { TableCellSpecExtension } from './_tsup-dts-rollup';
-export { TableCommandsExtension } from './_tsup-dts-rollup';
 export { TableHeaderCellSpecExtension } from './_tsup-dts-rollup';
 export { TableRowSpecExtension } from './_tsup-dts-rollup';
 export { TableSpecExtension } from './_tsup-dts-rollup';
+export { isCellSelection } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-table.js

@@ -1,4 +1,4 @@
-// src/table/index.ts
+// src/table/table.ts
 import { union } from "@prosekit/core";
 
 // src/table/table-commands.ts
@@ -9,31 +9,83 @@ import {
   insertNode
 } from "@prosekit/core";
 import { TextSelection } from "@prosekit/pm/state";
+import {
+  addColumnAfter,
+  addColumnBefore,
+  addRowAfter,
+  addRowBefore,
+  CellSelection as CellSelection2,
+  deleteCellSelection,
+  deleteColumn,
+  deleteRow,
+  deleteTable,
+  mergeCells,
+  splitCell,
+  TableMap
+} from "prosemirror-tables";
+
+// src/table/table-utils.ts
+import { findParentNode } from "@prosekit/core";
+import {
+  cellAround,
+  cellNear,
+  CellSelection,
+  inSameTable
+} from "prosemirror-tables";
+function isCellSelection(value) {
+  return value instanceof CellSelection;
+}
+function findTable($pos) {
+  return findParentNode((node) => node.type.spec.tableRole === "table", $pos);
+}
+function findCellRange(selection, anchorHit, headHit) {
+  var _a, _b;
+  if (anchorHit == null && headHit == null && isCellSelection(selection)) {
+    return [selection.$anchorCell, selection.$headCell];
+  }
+  const anchor = (_a = anchorHit != null ? anchorHit : headHit) != null ? _a : selection.anchor;
+  const head = (_b = headHit != null ? headHit : anchorHit) != null ? _b : selection.head;
+  const doc = selection.$head.doc;
+  const $anchorCell = findCellPos(doc, anchor);
+  const $headCell = findCellPos(doc, head);
+  if ($anchorCell && $headCell && inSameTable($anchorCell, $headCell)) {
+    return [$anchorCell, $headCell];
+  }
+}
+function findCellPos(doc, pos) {
+  const $pos = doc.resolve(pos);
+  return cellAround($pos) || cellNear($pos);
+}
+
+// src/table/table-commands.ts
 function createEmptyTable(schema, row, col, header) {
-  const table = getNodeType(schema, "table");
-  const tableRow = getNodeType(schema, "tableRow");
-  const tableCell = getNodeType(schema, "tableCell");
-  const tableHeaderCell = getNodeType(schema, "tableHeaderCell");
-  const createHeaderRow = () => {
-    return tableRow.createAndFill(
-      null,
-      Array.from({ length: col }, () => tableHeaderCell.createAndFill())
-    );
-  };
-  const createBodyRow = () => {
-    return tableRow.createAndFill(
-      null,
-      Array.from({ length: col }, () => tableCell.createAndFill())
-    );
-  };
-  const rows = [
-    ...Array.from({ length: header ? 1 : 0 }, createHeaderRow),
-    ...Array.from({ length: header ? row - 1 : row }, createBodyRow)
-  ];
-  return table.createAndFill(null, rows);
+  const tableType = getNodeType(schema, "table");
+  const tableRowType = getNodeType(schema, "tableRow");
+  const tableCellType = getNodeType(schema, "tableCell");
+  const tableHeaderCellType = getNodeType(schema, "tableHeaderCell");
+  if (header) {
+    const headerCell = tableHeaderCellType.createAndFill();
+    const headerCells = repeat(headerCell, col);
+    const headerRow = tableRowType.createAndFill(null, headerCells);
+    const bodyCell = tableCellType.createAndFill();
+    const bodyCells = repeat(bodyCell, col);
+    const bodyRow = tableRowType.createAndFill(null, bodyCells);
+    const bodyRows = repeat(bodyRow, row - 1);
+    return tableType.createAndFill(null, [headerRow, ...bodyRows]);
+  } else {
+    const bodyCell = tableCellType.createAndFill();
+    const bodyCells = repeat(bodyCell, col);
+    const bodyRow = tableRowType.createAndFill(null, bodyCells);
+    const bodyRows = repeat(bodyRow, row);
+    return tableType.createAndFill(null, bodyRows);
+  }
 }
-function insertTable({ row, col, header }) {
+function repeat(node, length) {
+  return Array(length).fill(node);
+}
+function insertTable(options) {
   return (state, dispatch, view) => {
+    const { row, col, header } = options;
     const table = createEmptyTable(state.schema, row, col, header);
     return insertNode({ node: table })(state, dispatch, view);
   };
@@ -70,10 +122,95 @@ var exitTable = (state, dispatch) => {
   }
   return true;
 };
+function selectTableColumn(options) {
+  return (state, dispatch) => {
+    const range = findCellRange(state.selection, options == null ? void 0 : options.anchor, options == null ? void 0 : options.head);
+    if (!range) {
+      return false;
+    }
+    if (dispatch) {
+      const [$anchorCell, $headCell] = range;
+      const selection = CellSelection2.colSelection($anchorCell, $headCell);
+      dispatch(state.tr.setSelection(selection));
+    }
+    return true;
+  };
+}
+function selectTableRow(options) {
+  return (state, dispatch) => {
+    const range = findCellRange(state.selection, options == null ? void 0 : options.anchor, options == null ? void 0 : options.head);
+    if (!range) {
+      return false;
+    }
+    if (dispatch) {
+      const [$anchorCell, $headCell] = range;
+      const selection = CellSelection2.rowSelection($anchorCell, $headCell);
+      dispatch(state.tr.setSelection(selection));
+    }
+    return true;
+  };
+}
+function selectTableCell(options) {
+  return (state, dispatch) => {
+    var _a;
+    const $cellPos = findCellPos(
+      state.doc,
+      (_a = options == null ? void 0 : options.pos) != null ? _a : state.selection.anchor
+    );
+    if (!$cellPos) {
+      return false;
+    }
+    if (dispatch) {
+      const selection = new CellSelection2($cellPos);
+      dispatch(state.tr.setSelection(selection));
+    }
+    return true;
+  };
+}
+function selectTable(options) {
+  return (state, dispatch) => {
+    const $pos = (options == null ? void 0 : options.pos) ? state.doc.resolve(options.pos) : state.selection.$anchor;
+    const table = findTable($pos);
+    if (!table) {
+      return false;
+    }
+    const map = TableMap.get(table.node);
+    if (map.map.length === 0) {
+      return false;
+    }
+    if (dispatch) {
+      let tr = state.tr;
+      const firstCellPosInTable = map.map[0];
+      const lastCellPosInTable = map.map[map.map.length - 1];
+      const firstCellPos = table.pos + firstCellPosInTable + 1;
+      const lastCellPos = table.pos + lastCellPosInTable + 1;
+      const $firstCellPos = tr.doc.resolve(firstCellPos);
+      const $lastCellPos = tr.doc.resolve(lastCellPos);
+      const selection = new CellSelection2($firstCellPos, $lastCellPos);
+      tr = tr.setSelection(selection);
+      dispatch == null ? void 0 : dispatch(tr);
+    }
+    return true;
+  };
+}
 function defineTableCommands() {
   return defineCommands({
     insertTable,
-    exitTable: () => exitTable
+    exitTable: () => exitTable,
+    selectTable,
+    selectTableCell,
+    selectTableColumn,
+    selectTableRow,
+    addTableColumnBefore: () => addColumnBefore,
+    addTableColumnAfter: () => addColumnAfter,
+    addTableRowAbove: () => addRowBefore,
+    addTableRowBelow: () => addRowAfter,
+    deleteTable: () => deleteTable,
+    deleteTableColumn: () => deleteColumn,
+    deleteTableRow: () => deleteRow,
+    deleteCellSelection: () => deleteCellSelection,
+    mergeTableCells: () => mergeCells,
+    splitTableCell: () => splitCell
   });
 }
 
@@ -86,100 +223,57 @@ function defineTablePlugins() {
 
 // src/table/table-spec.ts
 import { defineNodeSpec } from "@prosekit/core";
+import { tableNodes } from "prosemirror-tables";
 var cellContent = "block+";
-function getCellAttrs(dom) {
-  if (typeof dom === "string") {
-    return {};
-  }
-  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);
-  return {
-    colspan,
-    rowspan: Number(dom.getAttribute("rowspan") || 1),
-    colwidth: widths && widths.length == colspan ? widths : null
-  };
-}
-function setCellAttrs(node) {
-  const pmAttrs = node.attrs;
-  const domAttrs = {};
-  if (pmAttrs.colspan !== 1) {
-    domAttrs.colspan = pmAttrs.colspan;
-  }
-  if (pmAttrs.rowspan !== 1) {
-    domAttrs.rowspan = pmAttrs.rowspan;
-  }
-  if (pmAttrs.colwidth) {
-    domAttrs["data-colwidth"] = pmAttrs.colwidth.join(",");
-  }
-  return domAttrs;
-}
+var cellAttrs = {
+  colspan: { default: 1 },
+  rowspan: { default: 1 },
+  colwidth: { default: null }
+};
+var specs = tableNodes({
+  tableGroup: "block",
+  cellContent,
+  cellAttributes: {}
+});
 function defineTableSpec() {
   return defineNodeSpec({
-    name: "table",
-    tableRole: "table",
+    ...specs["table"],
     content: "tableRow+",
-    isolating: true,
-    group: "block",
-    parseDOM: [{ tag: "table" }],
-    toDOM() {
-      return ["table", ["tbody", 0]];
-    }
+    name: "table"
   });
 }
 function defineTableRowSpec() {
   return defineNodeSpec({
-    name: "tableRow",
-    tableRole: "row",
+    ...specs["table_row"],
     content: "(tableCell | tableHeaderCell)*",
-    parseDOM: [{ tag: "tr" }],
-    toDOM() {
-      return ["tr", 0];
-    }
+    name: "tableRow"
   });
 }
-var cellAttrs = {
-  colspan: { default: 1 },
-  rowspan: { default: 1 },
-  colwidth: { default: null }
-};
 function defineTableCellSpec() {
   return defineNodeSpec({
+    ...specs["table_cell"],
     name: "tableCell",
-    tableRole: "cell",
-    content: cellContent,
-    attrs: cellAttrs,
-    isolating: true,
-    parseDOM: [{ tag: "td", getAttrs: (dom) => getCellAttrs(dom) }],
-    toDOM(node) {
-      return ["td", setCellAttrs(node), 0];
-    }
+    attrs: cellAttrs
   });
 }
 function defineTableHeaderCellSpec() {
   return defineNodeSpec({
+    ...specs["table_header"],
     name: "tableHeaderCell",
-    tableRole: "header_cell",
-    content: cellContent,
-    attrs: cellAttrs,
-    isolating: true,
-    parseDOM: [{ tag: "th", getAttrs: (dom) => getCellAttrs(dom) }],
-    toDOM(node) {
-      return ["th", setCellAttrs(node), 0];
-    }
+    attrs: cellAttrs
   });
 }
 
-// src/table/index.ts
+// src/table/table.ts
 function defineTable() {
-  return union([
+  return union(
     defineTableSpec(),
     defineTableRowSpec(),
     defineTableCellSpec(),
     defineTableHeaderCellSpec(),
     defineTablePlugins(),
     defineTableCommands()
-  ]);
+  );
 }
 export {
   defineTable,
@@ -188,5 +282,12 @@ export {
   defineTableHeaderCellSpec,
   defineTablePlugins,
   defineTableRowSpec,
-  defineTableSpec
+  defineTableSpec,
+  exitTable,
+  insertTable,
+  isCellSelection,
+  selectTable,
+  selectTableCell,
+  selectTableColumn,
+  selectTableRow
 };

package/dist/prosekit-extensions-text-align.d.ts

@@ -3,4 +3,6 @@ export { defineTextAlignCommands } from './_tsup-dts-rollup';
 export { defineTextAlignKeymap } from './_tsup-dts-rollup';
 export { defineTextAlign } from './_tsup-dts-rollup';
 export { TextAlignOptions } from './_tsup-dts-rollup';
-export { TextAlignCommandTyping } from './_tsup-dts-rollup';
+export { TextAlignAttrsExtension } from './_tsup-dts-rollup';
+export { TextAlignCommandsExtension } from './_tsup-dts-rollup';
+export { TextAlignExtension } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-text-align.js

@@ -41,11 +41,11 @@ function defineTextAlignKeymap(types) {
   });
 }
 function defineTextAlign(options) {
-  return union([
+  return union(
     defineTextAlignAttrs(options.types, options.default || "left"),
     defineTextAlignKeymap(options.types),
     defineTextAlignCommands(options.types)
-  ]);
+  );
 }
 export {
   defineTextAlign,

package/dist/prosekit-extensions-underline.js

@@ -31,11 +31,11 @@ function defineUnderlineKeymap() {
   });
 }
 function defineUnderline() {
-  return union([
+  return union(
     defineUnderlineSpec(),
     defineUnderlineCommands(),
     defineUnderlineKeymap()
-  ]);
+  );
 }
 export {
   defineUnderline,

package/dist/prosekit-extensions-yjs.d.ts

@@ -0,0 +1,14 @@
+export { defineYjs } from './_tsup-dts-rollup';
+export { YjsOptions } from './_tsup-dts-rollup';
+export { YjsExtension } from './_tsup-dts-rollup';
+export { defineYjsCommands_alias_1 as defineYjsCommands } from './_tsup-dts-rollup';
+export { defineYjsCursorPlugin_alias_1 as defineYjsCursorPlugin } from './_tsup-dts-rollup';
+export { defineYjsKeymap } from './_tsup-dts-rollup';
+export { defineYjsSyncPlugin } from './_tsup-dts-rollup';
+export { defineYjsUndoPlugin } from './_tsup-dts-rollup';
+export { YjsCursorOptions_alias_1 as YjsCursorOptions } from './_tsup-dts-rollup';
+export { YjsCursorPluginOptions_alias_1 as YjsCursorPluginOptions } from './_tsup-dts-rollup';
+export { YjsSyncOptions } from './_tsup-dts-rollup';
+export { YjsSyncPluginOptions } from './_tsup-dts-rollup';
+export { YjsUndoOptions } from './_tsup-dts-rollup';
+export { YjsUndoPluginOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-yjs.js

@@ -0,0 +1,143 @@
+// src/yjs/index.ts
+import {
+  Priority,
+  union,
+  withPriority
+} from "@prosekit/core";
+
+// src/yjs/commands.ts
+import { defineCommands } from "@prosekit/core";
+
+// src/yjs/undo-plugin.ts
+import { definePlugin } from "@prosekit/core";
+import {
+  yUndoPluginKey,
+  yUndoPlugin as originalYUndoPlugin,
+  undo as yUndo,
+  redo as yRedo
+} from "y-prosemirror";
+function fixYUndoPlugin(yUndoPluginInstance) {
+  const originalUndoPluginView = yUndoPluginInstance.spec.view;
+  yUndoPluginInstance.spec.view = (view) => {
+    const { undoManager } = yUndoPluginKey.getState(view.state);
+    if (undoManager.restore) {
+      undoManager.restore();
+      undoManager.restore = () => {
+      };
+    }
+    const viewRet = originalUndoPluginView ? originalUndoPluginView(view) : void 0;
+    return {
+      destroy: () => {
+        const hasUndoManSelf = undoManager.trackedOrigins.has(undoManager);
+        const observers = undoManager._observers;
+        undoManager.restore = () => {
+          if (hasUndoManSelf) {
+            undoManager.trackedOrigins.add(undoManager);
+          }
+          undoManager.doc.on(
+            "afterTransaction",
+            undoManager.afterTransactionHandler
+          );
+          undoManager._observers = observers;
+        };
+        if (viewRet == null ? void 0 : viewRet.destroy) {
+          viewRet.destroy();
+        }
+      }
+    };
+  };
+}
+function yUndoPlugin(options) {
+  const yUndoPluginInstance = originalYUndoPlugin(options);
+  fixYUndoPlugin(yUndoPluginInstance);
+  return yUndoPluginInstance;
+}
+var undo = (state, dispatch) => {
+  const { undoManager } = yUndoPluginKey.getState(state);
+  if (undoManager.undoStack.length === 0) {
+    return false;
+  }
+  if (!dispatch) {
+    return true;
+  }
+  return yUndo(state);
+};
+var redo = (state, dispatch) => {
+  const { undoManager } = yUndoPluginKey.getState(state);
+  if (undoManager.redoStack.length === 0) {
+    return false;
+  }
+  if (!dispatch) {
+    return true;
+  }
+  return yRedo(state);
+};
+function defineYjsUndoPlugin(options) {
+  return definePlugin(yUndoPlugin(options));
+}
+
+// src/yjs/commands.ts
+var commands = {
+  undo: () => undo,
+  redo: () => redo
+};
+function defineYjsCommands() {
+  return defineCommands(commands);
+}
+
+// src/yjs/cursor-plugin.ts
+import { definePlugin as definePlugin2 } from "@prosekit/core";
+import { yCursorPlugin } from "y-prosemirror";
+function defineYjsCursorPlugin(options) {
+  const { awareness, ...rest } = options;
+  return definePlugin2(yCursorPlugin(awareness, rest));
+}
+
+// src/yjs/keymap.ts
+import {
+  defineKeymap,
+  isApple
+} from "@prosekit/core";
+var keymap = {
+  "Mod-z": undo,
+  "Shift-Mod-z": redo
+};
+if (!isApple) {
+  keymap["Mod-y"] = redo;
+}
+function defineYjsKeymap() {
+  return defineKeymap(keymap);
+}
+
+// src/yjs/sync-plugin.ts
+import { definePlugin as definePlugin3 } from "@prosekit/core";
+import { ySyncPlugin } from "y-prosemirror";
+function defineYjsSyncPlugin(options) {
+  const { fragment, ...rest } = options;
+  return definePlugin3(ySyncPlugin(fragment, rest));
+}
+
+// src/yjs/index.ts
+function defineYjs(options) {
+  var _a;
+  const { doc, awareness, sync, undo: undo2, cursor } = options;
+  const fragment = (_a = options.fragment) != null ? _a : doc.getXmlFragment("prosemirror");
+  return withPriority(
+    union([
+      defineYjsKeymap(),
+      defineYjsCommands(),
+      defineYjsCursorPlugin({ ...cursor, awareness }),
+      defineYjsUndoPlugin({ ...undo2 }),
+      defineYjsSyncPlugin({ ...sync, fragment })
+    ]),
+    Priority.high
+  );
+}
+export {
+  defineYjs,
+  defineYjsCommands,
+  defineYjsCursorPlugin,
+  defineYjsKeymap,
+  defineYjsSyncPlugin,
+  defineYjsUndoPlugin
+};

package/dist/shiki-highlighter-chunk-C5VVQ2TD.js

@@ -0,0 +1,50 @@
+// src/code-block/shiki-highlighter-chunk.ts
+import {
+  createHighlighter,
+  createJavaScriptRegexEngine
+} from "shiki/bundle/full";
+var highlighter;
+var loadedLangs = /* @__PURE__ */ new Set();
+var loadedThemes = /* @__PURE__ */ new Set();
+async function createAndCacheHighlighter({
+  ...options
+}) {
+  if (!highlighter) {
+    if (!options.engine) {
+      const engine = createJavaScriptRegexEngine();
+      options.engine = engine;
+    }
+    highlighter = await createHighlighter(options);
+  }
+}
+async function loadLanguages(langs) {
+  for (const lang of langs) {
+    if (!highlighter) break;
+    await highlighter.loadLanguage(lang);
+    loadedLangs.add(lang);
+  }
+}
+async function loadThemes(themes) {
+  for (const theme of themes) {
+    if (!highlighter) break;
+    await highlighter.loadTheme(theme);
+    loadedThemes.add(theme);
+  }
+}
+function createOrGetHighlighter(options) {
+  if (!highlighter) {
+    return { promise: createAndCacheHighlighter(options) };
+  }
+  const langs = options.langs.filter((lang) => !loadedLangs.has(lang));
+  if (langs.length > 0) {
+    return { promise: loadLanguages(langs) };
+  }
+  const themes = options.themes.filter((theme) => !loadedThemes.has(theme));
+  if (themes.length > 0) {
+    return { promise: loadThemes(themes) };
+  }
+  return { highlighter };
+}
+export {
+  createOrGetHighlighter
+};

package/dist/table/style.css

@@ -30,5 +30,10 @@
   cursor: col-resize;
 }
 .ProseMirror .selectedCell {
-  background-color: Highlight;
+  --color:
+    210,
+    100%,
+    56%;
+  background-color: hsla(var(--color), 20%);
+  border: 1px double hsl(var(--color));
 }

package/dist/yjs/style.css

@@ -0,0 +1,31 @@
+/* src/yjs/style.css */
+.ProseMirror .ProseMirror-yjs-cursor {
+  position: absolute;
+  border-left: black;
+  border-left-style: solid;
+  border-left-width: 2px;
+  border-color: orange;
+  height: 1em;
+  word-break: normal;
+  pointer-events: none;
+}
+.ProseMirror .ProseMirror-yjs-cursor > div {
+  position: relative;
+  top: -1.05em;
+  font-size: 13px;
+  background-color: rgb(250, 129, 0);
+  font-family: serif;
+  font-style: normal;
+  font-weight: normal;
+  line-height: normal;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+  color: white;
+  padding-left: 2px;
+  padding-right: 2px;
+}
+.ProseMirror > .ProseMirror-yjs-cursor:first-child {
+  margin-top: 16px;
+}