@prosekit/extensions 0.8.0 → 0.9.1

package/dist/commit/style.css

@@ -1,4 +1,3 @@
-/* src/commit/style.css */
 .prosekit-commit-deletion {
   background-color: #e5534b80;
   text-decoration: line-through;
@@ -6,3 +5,4 @@
 .prosekit-commit-addition {
   background-color: #53e54b80;
 }
+

package/dist/enter-rule-RdhEA900.js

@@ -0,0 +1,96 @@
+import { OBJECT_REPLACEMENT_CHARACTER, defineFacet, defineFacetPayload, getNodeType, isTextSelection, maybeRun, pluginFacet } from "@prosekit/core";
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+import { keydownHandler } from "@prosekit/pm/keymap";
+
+//#region src/enter-rule/index.ts
+/**
+* Defines an enter rule. An enter rule applies when the text directly in front of
+* the cursor matches `regex` and user presses Enter. The `regex` should end
+* with `$`.
+*
+* @param options
+*
+* @public
+*/
+function defineEnterRule({ regex, handler, stop = false }) {
+	const rule = new EnterRule(regex, handler, stop);
+	return defineFacetPayload(enterRule, [rule]);
+}
+/**
+* Defines an enter rule that replaces the matched text with a block node.
+*
+* See also {@link defineEnterRule}.
+*
+* @param options
+*
+* @public
+*/
+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
+	});
+}
+/**
+* @internal
+*/
+var EnterRule = class {
+	constructor(regex, handler, stop) {
+		this.regex = regex;
+		this.handler = handler;
+		this.stop = stop;
+	}
+};
+const 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;
+}
+const MAX_MATCH = 200;
+
+//#endregion
+export { defineEnterRule, defineTextBlockEnterRule };

package/dist/gap-cursor/style.css

@@ -1,23 +1,26 @@
-/* src/gap-cursor/style.css */
 .ProseMirror-gapcursor {
   display: none;
-  pointer-events: none;
   position: relative;
+  pointer-events: none;
 }
+
 .ProseMirror-gapcursor:after {
-  content: "";
   display: block;
   position: absolute;
   top: -2px;
   width: 20px;
   border-top: 1px solid currentColor;
+  content: "";
   animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
 }
+
 @keyframes ProseMirror-cursor-blink {
   to {
     visibility: hidden;
   }
 }
+
 .ProseMirror-focused .ProseMirror-gapcursor {
   display: block;
 }
+

package/dist/input-rule-Gji4N7Oe.js

@@ -0,0 +1,93 @@
+import { defineFacet, defineFacetPayload, getMarkType, getNodeType, isMarkAbsent, maybeRun, pluginFacet } from "@prosekit/core";
+import { InputRule, inputRules, textblockTypeInputRule, wrappingInputRule } from "@prosekit/pm/inputrules";
+
+//#region src/input-rule/index.ts
+/**
+* Defines an input rule extension.
+*
+* @param rule - The ProseMirror input rule to add.
+*
+* @public
+*/
+function defineInputRule(rule) {
+	return defineInputRuleFacetPayload(() => rule);
+}
+/**
+* @internal
+*/
+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;
+}
+/**
+* Defines an input rule for automatically adding inline marks when a given
+* pattern is typed.
+*
+* @public
+*/
+function defineMarkInputRule(options) {
+	return defineInputRule(createMarkInputRule(options));
+}
+/**
+* Defines an input rule that changes the type of a textblock when the matched
+* text is typed into it.
+*
+* See also [textblockTypeInputRule](https://prosemirror.net/docs/ref/#inputrules.textblockTypeInputRule)
+*
+* @param options
+*
+* @public
+*/
+function defineTextBlockInputRule({ regex, type, attrs }) {
+	return defineInputRuleFacetPayload(({ schema }) => {
+		const nodeType = getNodeType(schema, type);
+		return textblockTypeInputRule(regex, nodeType, attrs);
+	});
+}
+/**
+* Defines an input rule for automatically wrapping a textblock when a given
+* string is typed.
+*
+* See also [wrappingInputRule](https://prosemirror.net/docs/ref/#inputrules.wrappingInputRule)
+*
+* @param options
+*
+* @public
+*/
+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]);
+}
+const inputRuleFacet = defineFacet({
+	reducer: (inputs) => {
+		return (context) => {
+			const rules = inputs.flatMap((callback) => callback(context));
+			return [inputRules({ rules })];
+		};
+	},
+	parent: pluginFacet
+});
+
+//#endregion
+export { createMarkInputRule, defineInputRule, defineMarkInputRule, defineTextBlockInputRule, defineWrappingInputRule };

package/dist/list/style.css

@@ -1,4 +1,4 @@
-/* ../../node_modules/.pnpm/prosemirror-flat-list@0.5.4/node_modules/prosemirror-flat-list/dist/style.css */
+/* src/style.css */
 .prosemirror-flat-list {
   padding: 0;
   margin-top: 0;
@@ -25,9 +25,6 @@
 .prosemirror-flat-list[data-list-kind=bullet] {
   list-style: disc;
 }
-.prosemirror-flat-list[data-list-kind=ordered] {
-  counter-increment: prosemirror-flat-list-counter;
-}
 .prosemirror-flat-list[data-list-kind=ordered] > * {
   contain: style;
 }
@@ -37,6 +34,9 @@
   font-variant-numeric: tabular-nums;
   content: counter(prosemirror-flat-list-counter, decimal) ". ";
 }
+.prosemirror-flat-list[data-list-kind=ordered] {
+  counter-increment: prosemirror-flat-list-counter;
+}
 .prosemirror-flat-list[data-list-kind=ordered]:first-child,
 :not(.prosemirror-flat-list[data-list-kind=ordered]) + .prosemirror-flat-list[data-list-kind=ordered] {
   counter-reset: prosemirror-flat-list-counter;
@@ -58,8 +58,8 @@
   width: 1.5em;
   width: 1lh;
 }
-.prosemirror-flat-list[data-list-kind=task] > .list-marker,
-.prosemirror-flat-list[data-list-kind=task] > .list-marker * {
+:is(.prosemirror-flat-list[data-list-kind=task] > .list-marker),
+:is(.prosemirror-flat-list[data-list-kind=task] > .list-marker) * {
   cursor: pointer;
 }
 .prosemirror-flat-list[data-list-kind=toggle] > .list-marker {
@@ -86,4 +86,4 @@
   display: none;
 }
 
-/* src/list/style.css */
+

package/dist/loro/style.css

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

package/dist/mark-rule-wEOcDt6i.js

@@ -0,0 +1,160 @@
+import { OBJECT_REPLACEMENT_CHARACTER, defineFacet, defineFacetPayload, getMarkType, maybeRun, pluginFacet } from "@prosekit/core";
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+
+//#region 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 [start$1, node] = stack.pop();
+		if (node.type.spec.code) continue;
+		if (node.type.isTextblock) {
+			ranges.push([start$1 + 1, start$1 + 1 + node.content.size]);
+			continue;
+		}
+		node.forEach((child, offset) => {
+			stack.push([start$1 + 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);
+}
+
+//#endregion
+//#region 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((mark$1) => mark$1.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((tr$1) => !tr$1.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;
+}
+
+//#endregion
+//#region src/mark-rule/mark-rule.ts
+/**
+* A mark rule is something that can automatically apply marks to text if it
+* matches a certain pattern, and remove them if it doesn't match anymore.
+*/
+function defineMarkRule(options) {
+	return defineFacetPayload(markRuleFacet, [options]);
+}
+const 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
+});
+
+//#endregion
+export { defineMarkRule };

package/dist/placeholder/style.css

@@ -1,8 +1,8 @@
-/* src/placeholder/style.css */
 .prosekit-placeholder::before {
   position: absolute;
-  opacity: 30%;
-  pointer-events: none;
   height: 0;
   content: attr(data-placeholder);
+  opacity: 30%;
+  pointer-events: none;
 }
+

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

@@ -1,3 +1,33 @@
-export { defineAutocomplete_alias_1 as defineAutocomplete } from './_tsup-dts-rollup.js';
-export { AutocompleteRule_alias_1 as AutocompleteRule } from './_tsup-dts-rollup.js';
-export { MatchHandler_alias_1 as MatchHandler } from './_tsup-dts-rollup.js';
+import { Extension } from "@prosekit/core";
+import { EditorState } from "@prosekit/pm/state";
+
+//#region src/autocomplete/autocomplete-rule.d.ts
+type MatchHandler = (options: {
+  state: EditorState;
+  match: RegExpExecArray;
+  from: number;
+  to: number;
+  ignoreMatch: () => void;
+  deleteMatch: () => void;
+}) => void;
+declare class AutocompleteRule {
+  readonly regex: RegExp;
+  readonly onMatch: MatchHandler;
+  readonly onLeave?: VoidFunction;
+  readonly canMatch: (options: {
+    state: EditorState;
+  }) => boolean;
+  constructor(options: {
+    regex: RegExp;
+    onEnter: MatchHandler;
+    onLeave?: VoidFunction;
+    canMatch?: (options: {
+      state: EditorState;
+    }) => boolean;
+  });
+}
+//#endregion
+//#region src/autocomplete/autocomplete.d.ts
+declare function defineAutocomplete(rule: AutocompleteRule): Extension;
+//#endregion
+export { AutocompleteRule, MatchHandler, defineAutocomplete };