@prosekit/extensions 0.8.0 → 0.9.0

package/dist/chunk-6UYLCVBX.js

@@ -1,185 +0,0 @@
-// src/mark-rule/mark-rule.ts
-import {
-  defineFacet,
-  defineFacetPayload,
-  pluginFacet
-} from "@prosekit/core";
-import {
-  PluginKey,
-  ProseMirrorPlugin
-} from "@prosekit/pm/state";
-
-// src/mark-rule/apply.ts
-import {
-  getMarkType,
-  maybeRun,
-  OBJECT_REPLACEMENT_CHARACTER
-} from "@prosekit/core";
-
-// src/mark-rule/range.ts
-function getSpanTextRanges($from, $to) {
-  const nodeRange = $from.blockRange($to);
-  if (!nodeRange) {
-    return [];
-  }
-  const stack = [];
-  let start = nodeRange.start;
-  for (let i = nodeRange.startIndex; i < nodeRange.endIndex; i++) {
-    const child = nodeRange.parent.child(i);
-    stack.push([start, child]);
-    start += child.nodeSize;
-  }
-  const ranges = [];
-  while (stack.length > 0) {
-    const [start2, node] = stack.pop();
-    if (node.type.spec.code) {
-      continue;
-    }
-    if (node.type.isTextblock) {
-      ranges.push([start2 + 1, start2 + 1 + node.content.size]);
-      continue;
-    }
-    node.forEach((child, offset) => {
-      stack.push([start2 + offset + 1, child]);
-    });
-  }
-  return ranges;
-}
-function getInlineTextRange($from, $to) {
-  return [$from.start(), $to.end()];
-}
-function getTextRanges(doc, from, to) {
-  const $from = doc.resolve(from);
-  const $to = doc.resolve(to);
-  if ($from.sameParent($to) && $from.parent.isTextblock) {
-    return [getInlineTextRange($from, $to)];
-  } else {
-    const nodeRange = $from.blockRange($to);
-    if (!nodeRange) {
-      return [];
-    }
-    return getSpanTextRanges($from, $to);
-  }
-}
-function getMapRange(transactions, oldState, newState) {
-  let lo = oldState.selection.from;
-  let hi = oldState.selection.to;
-  for (const tr of transactions) {
-    for (const map of tr.mapping.maps) {
-      lo = map.map(lo);
-      hi = map.map(hi);
-      map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
-        lo = Math.min(lo, hi, newStart);
-        hi = Math.max(lo, hi, newEnd);
-      });
-    }
-  }
-  lo = Math.min(lo, hi, newState.selection.from);
-  hi = Math.min(lo, hi, newState.selection.to);
-  return [lo, hi];
-}
-function getCheckRanges(transactions, oldState, newState) {
-  const [from, to] = getMapRange(transactions, oldState, newState);
-  return getTextRanges(newState.doc, from, to);
-}
-
-// src/mark-rule/apply.ts
-function getExpectedMarkings(rules, doc, from, to) {
-  const text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER);
-  const ranges = [];
-  for (const rule of rules) {
-    rule.regex.lastIndex = 0;
-    const matches = text.matchAll(rule.regex);
-    const markType = getMarkType(doc.type.schema, rule.type);
-    for (const match of matches) {
-      const index = match.index;
-      if (index == null) continue;
-      const attrs = maybeRun(rule.attrs, match);
-      const mark = markType.create(attrs);
-      ranges.push([from + index, from + index + match[0].length, mark]);
-    }
-  }
-  ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
-  const result = [];
-  let freeIndex = 0;
-  for (const range of ranges) {
-    if (range[0] >= freeIndex) {
-      result.push(range);
-      freeIndex = range[1];
-    }
-  }
-  return result;
-}
-function getReceivedMarkings(rules, doc, from, to) {
-  const result = [];
-  const schema = doc.type.schema;
-  const markTypes = rules.map((rule) => getMarkType(schema, rule.type));
-  doc.nodesBetween(from, to, (node, pos) => {
-    if (!node.isInline) {
-      return;
-    }
-    for (const markType of markTypes) {
-      const mark = node.marks.find((mark2) => mark2.type === markType);
-      if (mark) {
-        result.push([pos, pos + node.nodeSize, mark]);
-      }
-    }
-  });
-  return result;
-}
-function markRangeEquals(a, b) {
-  return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2]);
-}
-function markRangeDiffs(a, b) {
-  return a.filter((x) => !b.some((y) => markRangeEquals(x, y)));
-}
-function applyMarkRules(rules, transactions, oldState, newState) {
-  if (transactions.length === 0 || transactions.every((tr2) => !tr2.docChanged)) {
-    return null;
-  }
-  const ranges = getCheckRanges(transactions, oldState, newState);
-  const toRemove = [];
-  const toCreate = [];
-  for (const [from, to] of ranges) {
-    const expected = getExpectedMarkings(rules, newState.doc, from, to);
-    const received = getReceivedMarkings(rules, newState.doc, from, to);
-    toRemove.push(...markRangeDiffs(received, expected));
-    toCreate.push(...markRangeDiffs(expected, received));
-  }
-  if (toCreate.length === 0 && toRemove.length === 0) {
-    return null;
-  }
-  const tr = newState.tr;
-  for (const [from, to, mark] of toRemove) {
-    tr.removeMark(from, to, mark);
-  }
-  for (const [from, to, mark] of toCreate) {
-    tr.addMark(from, to, mark);
-  }
-  return tr;
-}
-
-// src/mark-rule/mark-rule.ts
-function defineMarkRule(options) {
-  return defineFacetPayload(markRuleFacet, [options]);
-}
-var markRuleFacet = defineFacet({
-  reduce: () => {
-    let rules = [];
-    const plugin = new ProseMirrorPlugin({
-      key: new PluginKey("prosekit-mark-rule"),
-      appendTransaction: (transactions, oldState, newState) => {
-        return applyMarkRules(rules, transactions, oldState, newState);
-      }
-    });
-    return function reducer(input) {
-      rules = input;
-      return plugin;
-    };
-  },
-  parent: pluginFacet
-});
-
-export {
-  defineMarkRule
-};

package/dist/chunk-D54VSLLS.js

@@ -1,105 +0,0 @@
-// src/enter-rule/index.ts
-import {
-  defineFacet,
-  defineFacetPayload,
-  getNodeType,
-  isTextSelection,
-  maybeRun,
-  OBJECT_REPLACEMENT_CHARACTER,
-  pluginFacet
-} from "@prosekit/core";
-import { keydownHandler } from "@prosekit/pm/keymap";
-import {
-  PluginKey,
-  ProseMirrorPlugin
-} from "@prosekit/pm/state";
-function defineEnterRule({
-  regex,
-  handler,
-  stop = false
-}) {
-  const rule = new EnterRule(regex, handler, stop);
-  return defineFacetPayload(enterRule, [rule]);
-}
-function defineTextBlockEnterRule({
-  regex,
-  type,
-  attrs,
-  stop = true
-}) {
-  return defineEnterRule({
-    regex,
-    handler: ({ state, from, to, match }) => {
-      const nodeType = getNodeType(state.schema, type);
-      const $start = state.doc.resolve(from);
-      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
-        return null;
-      }
-      const nodeAttrs = maybeRun(attrs, match);
-      return state.tr.delete(from, to).setBlockType(from, from, nodeType, nodeAttrs);
-    },
-    stop
-  });
-}
-var EnterRule = class {
-  constructor(regex, handler, stop) {
-    this.regex = regex;
-    this.handler = handler;
-    this.stop = stop;
-  }
-};
-var enterRule = defineFacet({
-  reduce: () => {
-    let rules = [];
-    const command = (state, dispatch, view) => {
-      if (!view) return false;
-      return execRules(view, rules, dispatch);
-    };
-    const handler = keydownHandler({ Enter: command });
-    const plugin = new ProseMirrorPlugin({
-      key: new PluginKey("prosekit-enter-rule"),
-      props: { handleKeyDown: handler }
-    });
-    return function reducer(inputs) {
-      rules = inputs;
-      return plugin;
-    };
-  },
-  parent: pluginFacet
-});
-function execRules(view, rules, dispatch) {
-  if (view.composing) return false;
-  const state = view.state;
-  const selection = state.selection;
-  if (!isTextSelection(selection)) return false;
-  const $cursor = selection.$cursor;
-  if (!$cursor || $cursor.parent.type.spec.code) return false;
-  const textBefore = $cursor.parent.textBetween(
-    Math.max(0, $cursor.parentOffset - MAX_MATCH),
-    $cursor.parentOffset,
-    null,
-    OBJECT_REPLACEMENT_CHARACTER
-  );
-  for (const rule of rules) {
-    rule.regex.lastIndex = 0;
-    const match = rule.regex.exec(textBefore);
-    const tr = match && rule.handler({
-      state,
-      from: $cursor.pos - match[0].length,
-      to: $cursor.pos,
-      match
-    });
-    if (!tr) continue;
-    dispatch?.(tr);
-    if (rule.stop) {
-      return true;
-    }
-  }
-  return false;
-}
-var MAX_MATCH = 200;
-
-export {
-  defineEnterRule,
-  defineTextBlockEnterRule
-};

package/dist/chunk-I2UMHK3L.js

@@ -1,99 +0,0 @@
-// src/input-rule/index.ts
-import {
-  defineFacet,
-  defineFacetPayload,
-  getMarkType,
-  getNodeType,
-  isMarkAbsent,
-  maybeRun,
-  pluginFacet
-} from "@prosekit/core";
-import {
-  InputRule,
-  inputRules,
-  textblockTypeInputRule,
-  wrappingInputRule
-} from "@prosekit/pm/inputrules";
-import "@prosekit/pm/state";
-function defineInputRule(rule) {
-  return defineInputRuleFacetPayload(() => rule);
-}
-function createMarkInputRule({
-  regex,
-  type,
-  attrs = null,
-  inCodeMark = false
-}) {
-  const rule = new InputRule(regex, (state, match, start, end) => {
-    const { tr, schema } = state;
-    const [fullText, markText] = match;
-    if (!markText) {
-      return null;
-    }
-    const markStart = start + fullText.indexOf(markText);
-    const markEnd = markStart + markText.length;
-    if (!(start <= markStart && markStart < markEnd && markEnd <= end)) {
-      return null;
-    }
-    const markType = getMarkType(schema, type);
-    const mark = markType.create(maybeRun(attrs, match));
-    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs)) {
-      return null;
-    }
-    const initialStoredMarks = tr.storedMarks ?? [];
-    tr.addMark(markStart, markEnd, mark);
-    if (markEnd < end) {
-      tr.delete(markEnd, end);
-    }
-    if (start < markStart) {
-      tr.delete(start, markStart);
-    }
-    tr.setStoredMarks(initialStoredMarks);
-    return tr;
-  }, { inCodeMark });
-  return rule;
-}
-function defineMarkInputRule(options) {
-  return defineInputRule(createMarkInputRule(options));
-}
-function defineTextBlockInputRule({
-  regex,
-  type,
-  attrs
-}) {
-  return defineInputRuleFacetPayload(({ schema }) => {
-    const nodeType = getNodeType(schema, type);
-    return textblockTypeInputRule(regex, nodeType, attrs);
-  });
-}
-function defineWrappingInputRule({
-  regex,
-  type,
-  attrs,
-  join
-}) {
-  return defineInputRuleFacetPayload(({ schema }) => {
-    const nodeType = getNodeType(schema, type);
-    return wrappingInputRule(regex, nodeType, attrs, join);
-  });
-}
-function defineInputRuleFacetPayload(input) {
-  return defineFacetPayload(inputRuleFacet, [input]);
-}
-var inputRuleFacet = defineFacet({
-  reducer: (inputs) => {
-    return (context) => {
-      const rules = inputs.flatMap((callback) => callback(context));
-      return [inputRules({ rules })];
-    };
-  },
-  parent: pluginFacet
-});
-
-export {
-  defineInputRule,
-  createMarkInputRule,
-  defineMarkInputRule,
-  defineTextBlockInputRule,
-  defineWrappingInputRule
-};

package/dist/chunk-QVFEYPQ6.js

@@ -1,306 +0,0 @@
-// src/table/table.ts
-import {
-  union
-} from "@prosekit/core";
-
-// src/table/table-commands.ts
-import {
-  defaultBlockAt,
-  defineCommands,
-  getNodeType,
-  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) {
-  if (anchorHit == null && headHit == null && isCellSelection(selection)) {
-    return [selection.$anchorCell, selection.$headCell];
-  }
-  const anchor = anchorHit ?? headHit ?? selection.anchor;
-  const head = headHit ?? anchorHit ?? 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 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 repeat(node, length) {
-  return Array(length).fill(node);
-}
-function insertTable(options) {
-  return (state, dispatch, view) => {
-    const { row, col, header = false } = options;
-    const table = createEmptyTable(state.schema, row, col, header);
-    return insertNode({ node: table })(state, dispatch, view);
-  };
-}
-var exitTable = (state, dispatch) => {
-  const { $head, $anchor } = state.selection;
-  if (!$head.sameParent($anchor)) {
-    return false;
-  }
-  let tableStart = -1;
-  let tableDepth = -1;
-  for (let depth = $head.depth; depth >= 0; depth--) {
-    const node2 = $head.node(depth);
-    if (node2.type.spec.tableRole === "table") {
-      tableStart = $head.before(depth);
-      tableDepth = depth;
-    }
-  }
-  if (tableStart < 0 || tableDepth <= 0) {
-    return false;
-  }
-  const above = $head.node(tableDepth - 1);
-  const after = $head.indexAfter(tableDepth - 1);
-  const type = defaultBlockAt(above.contentMatchAt(after));
-  const node = type?.createAndFill();
-  if (!type || !node || !above.canReplaceWith(after, after, type)) {
-    return false;
-  }
-  if (dispatch) {
-    const pos = $head.after(tableDepth);
-    const tr = state.tr.replaceWith(pos, pos, node);
-    tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
-    dispatch(tr.scrollIntoView());
-  }
-  return true;
-};
-function selectTableColumn(options) {
-  return (state, dispatch) => {
-    const range = findCellRange(state.selection, options?.anchor, 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?.anchor, 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) => {
-    const $cellPos = findCellPos(
-      state.doc,
-      options?.pos ?? 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?.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?.(tr);
-    }
-    return true;
-  };
-}
-function defineTableCommands() {
-  return defineCommands({
-    insertTable,
-    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
-  });
-}
-
-// src/table/table-plugins.ts
-import {
-  definePlugin
-} from "@prosekit/core";
-import {
-  columnResizing,
-  tableEditing
-} from "prosemirror-tables";
-function defineTablePlugins() {
-  return definePlugin([tableEditing(), columnResizing()]);
-}
-
-// src/table/table-spec.ts
-import {
-  defineNodeSpec
-} from "@prosekit/core";
-import { tableNodes } from "prosemirror-tables";
-var cellContent = "block+";
-var cellAttrs = {
-  colspan: { default: 1 },
-  rowspan: { default: 1 },
-  colwidth: { default: null }
-};
-var specs = tableNodes({
-  tableGroup: "block",
-  cellContent,
-  cellAttributes: {}
-});
-function defineTableSpec() {
-  return defineNodeSpec({
-    ...specs["table"],
-    content: "tableRow+",
-    name: "table"
-  });
-}
-function defineTableRowSpec() {
-  return defineNodeSpec({
-    ...specs["table_row"],
-    content: "(tableCell | tableHeaderCell)*",
-    name: "tableRow"
-  });
-}
-function defineTableCellSpec() {
-  return defineNodeSpec({
-    ...specs["table_cell"],
-    name: "tableCell",
-    attrs: cellAttrs
-  });
-}
-function defineTableHeaderCellSpec() {
-  return defineNodeSpec({
-    ...specs["table_header"],
-    name: "tableHeaderCell",
-    attrs: cellAttrs
-  });
-}
-
-// src/table/table.ts
-function defineTable() {
-  return union(
-    defineTableSpec(),
-    defineTableRowSpec(),
-    defineTableCellSpec(),
-    defineTableHeaderCellSpec(),
-    defineTablePlugins(),
-    defineTableCommands()
-  );
-}
-
-export {
-  isCellSelection,
-  findTable,
-  insertTable,
-  exitTable,
-  selectTableColumn,
-  selectTableRow,
-  selectTableCell,
-  selectTable,
-  defineTableCommands,
-  defineTablePlugins,
-  defineTableSpec,
-  defineTableRowSpec,
-  defineTableCellSpec,
-  defineTableHeaderCellSpec,
-  defineTable
-};