@prosekit/extensions 0.7.11 → 0.7.13

package/dist/_tsup-dts-rollup.d.ts

@@ -8,7 +8,10 @@ import { bundledLanguagesInfo } from 'shiki';
 import { BundledTheme } from 'shiki';
 import { BundledThemeInfo } from 'shiki';
 import { bundledThemesInfo } from 'shiki';
+import { CellSelection } from 'prosemirror-tables';
 import { Command } from '@prosekit/pm/state';
+import { CursorAwareness } from 'loro-prosemirror';
+import type { DecorationAttrs } from '@prosekit/pm/view';
 import { DedentListOptions } from 'prosemirror-flat-list';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
 import { DocExtension } from '@prosekit/core';
@@ -17,6 +20,7 @@ import { Extension } from '@prosekit/core';
 import { ExtensionTyping } from '@prosekit/core';
 import { ExtractMarkActions } from '@prosekit/core';
 import { ExtractNodeActions } from '@prosekit/core';
+import { FindParentNodeResult } from '@prosekit/core';
 import { GapCursor } from 'prosemirror-gapcursor';
 import { getSingletonHighlighter } from 'shiki/bundle/full';
 import type { Highlighter } from 'shiki';
@@ -26,6 +30,9 @@ import { InputRule } from '@prosekit/pm/inputrules';
 import type { IsEqual } from 'type-fest';
 import { ListAttributes } from 'prosemirror-flat-list';
 import { ListDOMSerializer } from 'prosemirror-flat-list';
+import type { LoroDocType } from 'loro-prosemirror';
+import { LoroSyncPluginProps } from 'loro-prosemirror';
+import { LoroUndoPluginProps } from 'loro-prosemirror';
 import { MarkType } from '@prosekit/pm/model';
 import { Node as Node_2 } from 'prosemirror-model';
 import { NodeAction } from '@prosekit/core';
@@ -34,10 +41,13 @@ import { NodeJSON } from '@prosekit/core';
 import type { NodeType } from '@prosekit/pm/model';
 import { Options } from 'tsup';
 import { Parser } from 'prosemirror-highlight';
+import type { PeerID } from 'loro-crdt';
 import { PlainExtension } from '@prosekit/core';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { PluginKey } from '@prosekit/pm/state';
 import { ProseMirrorNode } from '@prosekit/pm/model';
+import type { ResolvedPos } from '@prosekit/pm/model';
+import type { Selection as Selection_2 } from '@prosekit/pm/state';
 import { SimplifyDeeper } from '@prosekit/core';
 import type { SpecialLanguage } from 'shiki';
 import { StepJSON } from '@prosekit/core';
@@ -663,6 +673,31 @@ declare function defineListSpec(): ListSpecExtension;
 export { defineListSpec }
 export { defineListSpec as defineListSpec_alias_1 }
 
+/**
+ * @public
+ */
+export declare function defineLoro(options: LoroOptions): LoroExtension;
+
+declare function defineLoroCommands(): LoroCommandsExtension;
+export { defineLoroCommands }
+export { defineLoroCommands as defineLoroCommands_alias_1 }
+
+declare function defineLoroCursorPlugin(options: LoroCursorOptions): PlainExtension;
+export { defineLoroCursorPlugin }
+export { defineLoroCursorPlugin as defineLoroCursorPlugin_alias_1 }
+
+declare function defineLoroKeymap(): PlainExtension;
+export { defineLoroKeymap }
+export { defineLoroKeymap as defineLoroKeymap_alias_1 }
+
+declare function defineLoroSyncPlugin(options: LoroSyncPluginProps): PlainExtension;
+export { defineLoroSyncPlugin }
+export { defineLoroSyncPlugin as defineLoroSyncPlugin_alias_1 }
+
+declare function defineLoroUndoPlugin(options: LoroUndoPluginProps): PlainExtension;
+export { defineLoroUndoPlugin }
+export { defineLoroUndoPlugin as defineLoroUndoPlugin_alias_1 }
+
 /**
  * Defines an input rule for automatically adding inline marks when a given
  * pattern is typed.
@@ -779,7 +814,9 @@ export declare function defineStrikeSpec(): StrikeSpecExtension;
 /**
  * @public
  */
-export declare function defineTable(): TableExtension;
+declare function defineTable(): TableExtension;
+export { defineTable }
+export { defineTable as defineTable_alias_1 }
 
 /**
  * @internal
@@ -1054,7 +1091,27 @@ export declare type EnterRuleOptions = {
  *
  * @public
  */
-export declare const exitTable: Command;
+declare const exitTable: Command;
+export { exitTable }
+export { exitTable as exitTable_alias_1 }
+
+/**
+ * Try to find a resolved pos of a cell by using the given pos as a hit point.
+ *
+ * @internal
+ */
+export declare function findCellPos(doc: ProseMirrorNode, pos: number): ResolvedPos | undefined;
+
+/**
+ * Try to find the anchor and head cell in the same table by using the given
+ * anchor and head as hit points, or fallback to the selection's anchor and
+ * head.
+ *
+ * @internal
+ */
+export declare function findCellRange(selection: Selection_2, anchorHit?: number, headHit?: number): [ResolvedPos, ResolvedPos] | undefined;
+
+export declare function findTable($pos: ResolvedPos): FindParentNodeResult | undefined;
 
 export { GapCursor }
 
@@ -1164,22 +1221,39 @@ export declare type ImageSpecExtension = Extension<{
 
 export { IndentListOptions }
 
+export declare function inputText(input: string): Promise<void>;
+
 /**
  * Insert a table node with the given number of rows and columns, and optionally
  * a header row.
  *
+ * @param options
+ *
  * @public
  */
-export declare function insertTable({ row, col, header }: InsertTableOptions): Command;
+declare function insertTable(options: InsertTableOptions): Command;
+export { insertTable }
+export { insertTable as insertTable_alias_1 }
 
 /**
  * @public
  */
-export declare interface InsertTableOptions {
+declare interface InsertTableOptions {
     row: number;
     col: number;
     header: boolean;
 }
+export { InsertTableOptions }
+export { InsertTableOptions as InsertTableOptions_alias_1 }
+
+/**
+ * Checks if the given object is a `CellSelection` instance.
+ *
+ * @public
+ */
+declare function isCellSelection(value: unknown): value is CellSelection;
+export { isCellSelection }
+export { isCellSelection as isCellSelection_alias_1 }
 
 /**
  * @internal
@@ -1309,6 +1383,57 @@ declare type ListSpecExtension = Extension<{
 export { ListSpecExtension }
 export { ListSpecExtension as ListSpecExtension_alias_1 }
 
+/**
+ * @internal
+ */
+export declare type LoroCommandsExtension = Extension<{
+    Commands: {
+        undo: [];
+        redo: [];
+    };
+}>;
+
+declare interface LoroCursorOptions {
+    awareness: CursorAwareness;
+    getSelection?: (state: EditorState) => Selection_2;
+    createCursor?: (user: PeerID) => Element;
+    createSelection?: (user: PeerID) => DecorationAttrs;
+}
+export { LoroCursorOptions }
+export { LoroCursorOptions as LoroCursorOptions_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type LoroExtension = Union<[LoroCommandsExtension, PlainExtension]>;
+
+export declare interface LoroOptions {
+    /**
+     * The Loro instance handles the state of shared data.
+     */
+    doc: LoroDocType;
+    /**
+     * The Awareness instance.
+     */
+    awareness: CursorAwareness;
+    /**
+     * Extra options for `LoroSyncPlugin`.
+     */
+    sync?: Omit<LoroSyncPluginProps, 'doc'>;
+    /**
+     * Extra options for the `LoroUndoPlugin`.
+     */
+    undo?: Omit<LoroUndoPluginProps, 'doc'>;
+    /**
+     * Extra options for `LoroCursorPlugin`.
+     */
+    cursor?: Omit<LoroCursorOptions, 'awareness'>;
+}
+
+export { LoroSyncPluginProps }
+
+export { LoroUndoPluginProps }
+
 /**
  * Options for {@link defineMarkInputRule}.
  *
@@ -1468,6 +1593,96 @@ export declare interface SearchQueryOptions {
     wholeWord?: boolean;
 }
 
+/**
+ * @public
+ */
+declare function selectTable(options?: SelectTableOptions): Command;
+export { selectTable }
+export { selectTable as selectTable_alias_1 }
+
+/**
+ * @public
+ */
+declare function selectTableCell(options?: SelectTableCellOptions): Command;
+export { selectTableCell }
+export { selectTableCell as selectTableCell_alias_1 }
+
+/**
+ * @public
+ */
+declare interface SelectTableCellOptions {
+    /**
+     * A hit position of the table cell to select from. By default, the selection
+     * anchor will be used.
+     */
+    pos?: number;
+}
+export { SelectTableCellOptions }
+export { SelectTableCellOptions as SelectTableCellOptions_alias_1 }
+
+/**
+ * @public
+ */
+declare function selectTableColumn(options?: SelectTableColumnOptions): Command;
+export { selectTableColumn }
+export { selectTableColumn as selectTableColumn_alias_1 }
+
+/**
+ * @public
+ */
+declare interface SelectTableColumnOptions {
+    /**
+     * A hit position of the table cell to select from. By default, the selection
+     * anchor will be used.
+     */
+    anchor?: number;
+    /**
+     * A hit position of the table cell to select to. By default, the selection
+     * head will be used.
+     */
+    head?: number;
+}
+export { SelectTableColumnOptions }
+export { SelectTableColumnOptions as SelectTableColumnOptions_alias_1 }
+
+/**
+ * @public
+ */
+declare interface SelectTableOptions {
+    /**
+     * A hit position of the table to select from. By default, the selection
+     * anchor will be used.
+     */
+    pos?: number;
+}
+export { SelectTableOptions }
+export { SelectTableOptions as SelectTableOptions_alias_1 }
+
+/**
+ * @public
+ */
+declare function selectTableRow(options?: SelectTableRowOptions): Command;
+export { selectTableRow }
+export { selectTableRow as selectTableRow_alias_1 }
+
+/**
+ * @public
+ */
+declare interface SelectTableRowOptions {
+    /**
+     * A hit position of the table cell to select from. By default, the selection
+     * anchor will be used.
+     */
+    anchor?: number;
+    /**
+     * A hit position of the table cell to select to. By default, the selection
+     * head will be used.
+     */
+    head?: number;
+}
+export { SelectTableRowOptions }
+export { SelectTableRowOptions as SelectTableRowOptions_alias_1 }
+
 /**
  * @internal
  */
@@ -1619,6 +1834,20 @@ declare type TableCommandsExtension = Extension<{
     Commands: {
         insertTable: [InsertTableOptions];
         exitTable: [];
+        selectTable: [options?: SelectTableOptions];
+        selectTableCell: [options?: SelectTableCellOptions];
+        selectTableColumn: [options?: SelectTableColumnOptions];
+        selectTableRow: [options?: SelectTableRowOptions];
+        addTableColumnBefore: [];
+        addTableColumnAfter: [];
+        addTableRowAbove: [];
+        addTableRowBelow: [];
+        deleteTable: [];
+        deleteTableColumn: [];
+        deleteTableRow: [];
+        deleteCellSelection: [];
+        mergeTableCells: [];
+        splitTableCell: [];
     };
 }>;
 export { TableCommandsExtension }
@@ -1627,13 +1856,15 @@ export { TableCommandsExtension as TableCommandsExtension_alias_1 }
 /**
  * @internal
  */
-export declare type TableExtension = Union<[
+declare type TableExtension = Union<[
 TableSpecExtension,
 TableRowSpecExtension,
 TableCellSpecExtension,
 TableHeaderCellSpecExtension,
 TableCommandsExtension
 ]>;
+export { TableExtension }
+export { TableExtension as TableExtension_alias_1 }
 
 /**
  * @internal

package/dist/loro/style.css

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

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

@@ -0,0 +1,11 @@
+export { defineLoro } from './_tsup-dts-rollup';
+export { LoroOptions } from './_tsup-dts-rollup';
+export { LoroExtension } from './_tsup-dts-rollup';
+export { defineLoroCommands_alias_1 as defineLoroCommands } from './_tsup-dts-rollup';
+export { defineLoroCursorPlugin_alias_1 as defineLoroCursorPlugin } from './_tsup-dts-rollup';
+export { defineLoroKeymap } from './_tsup-dts-rollup';
+export { defineLoroSyncPlugin } from './_tsup-dts-rollup';
+export { defineLoroUndoPlugin } from './_tsup-dts-rollup';
+export { LoroCursorOptions_alias_1 as LoroCursorOptions } from './_tsup-dts-rollup';
+export { LoroSyncPluginProps } from './_tsup-dts-rollup';
+export { LoroUndoPluginProps } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-loro.js

@@ -0,0 +1,79 @@
+// src/loro/index.ts
+import {
+  Priority,
+  union,
+  withPriority
+} from "@prosekit/core";
+
+// src/loro/commands.ts
+import { defineCommands } from "@prosekit/core";
+import { redo, undo } from "loro-prosemirror";
+var commands = {
+  undo: () => undo,
+  redo: () => redo
+};
+function defineLoroCommands() {
+  return defineCommands(commands);
+}
+
+// src/loro/cursor-plugin.ts
+import { definePlugin } from "@prosekit/core";
+import { LoroCursorPlugin } from "loro-prosemirror";
+function defineLoroCursorPlugin(options) {
+  const { awareness, ...rest } = options;
+  return definePlugin(LoroCursorPlugin(awareness, rest));
+}
+
+// src/loro/keymap.ts
+import {
+  defineKeymap,
+  isApple
+} from "@prosekit/core";
+import { redo as redo2, undo as undo2 } from "loro-prosemirror";
+var keymap = {
+  "Mod-z": undo2,
+  "Shift-Mod-z": redo2
+};
+if (!isApple) {
+  keymap["Mod-y"] = redo2;
+}
+function defineLoroKeymap() {
+  return defineKeymap(keymap);
+}
+
+// src/loro/sync-plugin.ts
+import { definePlugin as definePlugin2 } from "@prosekit/core";
+import { LoroSyncPlugin } from "loro-prosemirror";
+function defineLoroSyncPlugin(options) {
+  return definePlugin2(LoroSyncPlugin(options));
+}
+
+// src/loro/undo-plugin.ts
+import { definePlugin as definePlugin3 } from "@prosekit/core";
+import { LoroUndoPlugin } from "loro-prosemirror";
+function defineLoroUndoPlugin(options) {
+  return definePlugin3(LoroUndoPlugin(options));
+}
+
+// src/loro/index.ts
+function defineLoro(options) {
+  const { doc, awareness, sync, undo: undo3, cursor } = options;
+  return withPriority(
+    union([
+      defineLoroKeymap(),
+      defineLoroCommands(),
+      defineLoroCursorPlugin({ ...cursor, awareness }),
+      defineLoroUndoPlugin({ ...undo3, doc }),
+      defineLoroSyncPlugin({ ...sync, doc })
+    ]),
+    Priority.high
+  );
+}
+export {
+  defineLoro,
+  defineLoroCommands,
+  defineLoroCursorPlugin,
+  defineLoroKeymap,
+  defineLoroSyncPlugin,
+  defineLoroUndoPlugin
+};

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
   });
 }
 
@@ -170,7 +307,7 @@ function defineTableHeaderCellSpec() {
   });
 }
 
-// src/table/index.ts
+// src/table/table.ts
 function defineTable() {
   return union(
     defineTableSpec(),
@@ -188,5 +325,12 @@ export {
   defineTableHeaderCellSpec,
   defineTablePlugins,
   defineTableRowSpec,
-  defineTableSpec
+  defineTableSpec,
+  exitTable,
+  insertTable,
+  isCellSelection,
+  selectTable,
+  selectTableCell,
+  selectTableColumn,
+  selectTableRow
 };

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -114,6 +114,14 @@
     "./list/style.css": {
       "default": "./dist/list/style.css"
     },
+    "./loro": {
+      "types": "./dist/prosekit-extensions-loro.d.ts",
+      "import": "./dist/prosekit-extensions-loro.js",
+      "default": "./dist/prosekit-extensions-loro.js"
+    },
+    "./loro/style.css": {
+      "default": "./dist/loro/style.css"
+    },
     "./mark-rule": {
       "types": "./dist/prosekit-extensions-mark-rule.d.ts",
       "import": "./dist/prosekit-extensions-mark-rule.js",
@@ -200,16 +208,24 @@
     "prosemirror-gapcursor": "^1.3.2",
     "prosemirror-highlight": "^0.8.0",
     "prosemirror-search": "^1.0.0",
-    "prosemirror-tables": "^1.4.0",
+    "prosemirror-tables": "^1.5.0",
     "shiki": "^1.14.1",
     "@prosekit/core": "^0.7.9",
     "@prosekit/pm": "^0.1.8"
   },
   "peerDependencies": {
+    "loro-crdt": ">= 0.16.7",
+    "loro-prosemirror": ">= 0.0.7",
     "y-prosemirror": ">= 1.2.9",
     "yjs": ">= 13.6.18"
   },
   "peerDependenciesMeta": {
+    "loro-crdt": {
+      "optional": true
+    },
+    "loro-prosemirror": {
+      "optional": true
+    },
     "y-prosemirror": {
       "optional": true
     },
@@ -219,6 +235,8 @@
   },
   "devDependencies": {
     "@vitest/browser": "^2.0.5",
+    "loro-crdt": "^0.16.7",
+    "loro-prosemirror": "^0.0.7",
     "tsup": "^8.2.4",
     "type-fest": "^4.25.0",
     "typescript": "^5.5.4",
@@ -283,6 +301,9 @@
       "list": [
         "./dist/prosekit-extensions-list.d.ts"
       ],
+      "loro": [
+        "./dist/prosekit-extensions-loro.d.ts"
+      ],
       "mark-rule": [
         "./dist/prosekit-extensions-mark-rule.d.ts"
       ],