@lofcz/platejs-math 52.3.6 → 53.4.10

package/dist/BaseInlineEquationPlugin-BtcwMqRJ.js

@@ -0,0 +1,62 @@
+import { ElementApi, KEYS, bindFirst, createSlatePlugin } from "platejs";
+import "katex/dist/katex.min.css";
+
+//#region src/lib/transforms/insertEquation.ts
+const insertEquation = (editor, options) => {
+	editor.tf.insertNodes({
+		children: [{ text: "" }],
+		texExpression: "",
+		type: editor.getType(KEYS.equation)
+	}, options);
+};
+
+//#endregion
+//#region src/lib/transforms/insertInlineEquation.ts
+const insertInlineEquation = (editor, texExpression, options) => {
+	editor.tf.insertNodes({
+		children: [{ text: "" }],
+		texExpression: texExpression ?? editor.api.string(editor.selection),
+		type: editor.getType(KEYS.inlineEquation)
+	}, options);
+};
+
+//#endregion
+//#region src/lib/getEquationExpression.internal.ts
+const getEquationExpression = (element) => typeof element.texExpression === "string" || typeof element.texExpression === "number" || typeof element.texExpression === "boolean" ? String(element.texExpression) : "";
+
+//#endregion
+//#region src/lib/withEquation.internal.ts
+const withEquation = ({ editor, tf: { normalizeNode }, type }) => ({ transforms: { normalizeNode(entry) {
+	const [node, path] = entry;
+	if (ElementApi.isElement(node) && node.type === type && typeof node.texExpression !== "string") {
+		editor.tf.setNodes({ texExpression: getEquationExpression({ texExpression: node.texExpression }) }, { at: path });
+		return;
+	}
+	return normalizeNode(entry);
+} } });
+
+//#endregion
+//#region src/lib/BaseEquationPlugin.ts
+const BaseEquationPlugin = createSlatePlugin({
+	key: KEYS.equation,
+	node: {
+		isElement: true,
+		isVoid: true
+	},
+	parsers: { html: { deserializer: { toNodeProps: ({ element }) => ({ texExpression: element.getAttribute("data-slate-tex-expression") ?? "" }) } } }
+}).overrideEditor(withEquation).extendEditorTransforms(({ editor }) => ({ insert: { equation: bindFirst(insertEquation, editor) } }));
+
+//#endregion
+//#region src/lib/BaseInlineEquationPlugin.ts
+const BaseInlineEquationPlugin = createSlatePlugin({
+	key: KEYS.inlineEquation,
+	node: {
+		isElement: true,
+		isInline: true,
+		isVoid: true
+	},
+	parsers: { html: { deserializer: { toNodeProps: ({ element }) => ({ texExpression: element.getAttribute("data-slate-tex-expression") ?? "" }) } } }
+}).overrideEditor(withEquation).extendEditorTransforms(({ editor }) => ({ insert: { inlineEquation: bindFirst(insertInlineEquation, editor) } }));
+
+//#endregion
+export { insertEquation as a, insertInlineEquation as i, BaseEquationPlugin as n, getEquationExpression as r, BaseInlineEquationPlugin as t };

package/dist/index.d.ts

@@ -17,6 +17,20 @@ declare const BaseInlineEquationPlugin: platejs3.SlatePlugin<platejs3.PluginConf
   };
 }, {}>>;
 //#endregion
+//#region src/lib/MathRules.d.ts
+declare const MathRules: {
+  markdown: (options: {
+    variant: "$";
+    enabled?: ((context: platejs3.SelectionInputRuleContext<SlateEditor> | platejs3.InsertTextInputRuleContext<SlateEditor> | platejs3.InsertBreakInputRuleContext<SlateEditor> | platejs3.InsertDataInputRuleContext<SlateEditor>) => boolean) | undefined;
+    priority?: number | undefined;
+  } | {
+    on: "break" | "match";
+    variant: "$$";
+    enabled?: ((context: platejs3.SelectionInputRuleContext<SlateEditor> | platejs3.InsertTextInputRuleContext<SlateEditor> | platejs3.InsertBreakInputRuleContext<SlateEditor> | platejs3.InsertDataInputRuleContext<SlateEditor>) => boolean) | undefined;
+    priority?: number | undefined;
+  }) => platejs3.AnyInputRule<unknown>;
+};
+//#endregion
 //#region src/lib/transforms/insertEquation.d.ts
 declare const insertEquation: (editor: SlateEditor, options?: InsertNodesOptions) => void;
 //#endregion
@@ -32,4 +46,4 @@ declare const getEquationHtml: ({
   options?: KatexOptions;
 }) => string;
 //#endregion
-export { BaseEquationPlugin, BaseInlineEquationPlugin, getEquationHtml, insertEquation, insertInlineEquation };
+export { BaseEquationPlugin, BaseInlineEquationPlugin, MathRules, getEquationHtml, insertEquation, insertInlineEquation };

package/dist/index.js

@@ -1,8 +1,65 @@
-import { i as insertEquation, n as BaseEquationPlugin, r as insertInlineEquation, t as BaseInlineEquationPlugin } from "./BaseInlineEquationPlugin-1MXNHk1G.js";
+import { a as insertEquation, i as insertInlineEquation, n as BaseEquationPlugin, r as getEquationExpression, t as BaseInlineEquationPlugin } from "./BaseInlineEquationPlugin-BtcwMqRJ.js";
+import { KEYS, createRuleFactory, matchDelimitedInline } from "platejs";
 import katex from "katex";
 
+//#region src/lib/MathRules.ts
+const INLINE_BOUNDARY_RE = /[\s([{'"`]/;
+const INLINE_FOLLOW_RE = /[\s)\]}:;,.!?'"`]/;
+const isEquationInputBlocked = (editor) => editor.api.some({ match: { type: [
+	editor.getType(KEYS.codeBlock),
+	editor.getType(KEYS.equation),
+	editor.getType(KEYS.inlineEquation)
+] } });
+const getInlineEquationMatch = (context) => {
+	const match = matchDelimitedInline(context, {
+		boundaryRe: INLINE_BOUNDARY_RE,
+		followRe: INLINE_FOLLOW_RE,
+		open: "$",
+		requireClosingDelimiter: false,
+		trim: "reject"
+	});
+	if (!match) return;
+	return {
+		deleteRange: match.deleteRange,
+		texExpression: match.content
+	};
+};
+const MathRules = { markdown: createRuleFactory((options) => options.variant === "$$" ? {
+	type: "blockFence",
+	fence: "$$",
+	block: KEYS.p,
+	on: options.on,
+	enabled: ({ editor }) => !isEquationInputBlocked(editor),
+	priority: 100,
+	apply: ({ editor }, match) => {
+		const blockMatch = match;
+		editor.tf.removeNodes({ at: blockMatch.path });
+		insertEquation(editor, {
+			at: blockMatch.path,
+			select: true
+		});
+		return true;
+	}
+} : {
+	type: "insertText",
+	enabled: ({ editor }) => !isEquationInputBlocked(editor),
+	trigger: "$",
+	resolve: (context) => {
+		if (context.text !== "$" || context.options?.at) return;
+		return getInlineEquationMatch(context);
+	},
+	apply: ({ editor }, match) => {
+		const inlineMatch = match;
+		editor.tf.delete({ at: inlineMatch.deleteRange });
+		editor.tf.select(inlineMatch.deleteRange.anchor);
+		insertInlineEquation(editor, inlineMatch.texExpression);
+		return true;
+	}
+}) };
+
+//#endregion
 //#region src/lib/utils/getEquationHtml.ts
-const getEquationHtml = ({ element, options }) => katex.renderToString(element.texExpression, options);
+const getEquationHtml = ({ element, options }) => katex.renderToString(getEquationExpression(element), options);
 
 //#endregion
-export { BaseEquationPlugin, BaseInlineEquationPlugin, getEquationHtml, insertEquation, insertInlineEquation };
+export { BaseEquationPlugin, BaseInlineEquationPlugin, MathRules, getEquationHtml, insertEquation, insertInlineEquation };

package/dist/react/index.js

@@ -1,4 +1,4 @@
-import { n as BaseEquationPlugin, t as BaseInlineEquationPlugin } from "../BaseInlineEquationPlugin-1MXNHk1G.js";
+import { n as BaseEquationPlugin, r as getEquationExpression, t as BaseInlineEquationPlugin } from "../BaseInlineEquationPlugin-BtcwMqRJ.js";
 import { isHotkey } from "platejs";
 import katex from "katex";
 import { toPlatePlugin, useEditorRef, useElement } from "platejs/react";
@@ -16,7 +16,7 @@ const InlineEquationPlugin = toPlatePlugin(BaseInlineEquationPlugin);
 const useEquationElement = ({ element, katexRef, options }) => {
 	React.useEffect(() => {
 		if (!katexRef.current) return;
-		katex.render(element.texExpression, katexRef.current, options);
+		katex.render(getEquationExpression(element), katexRef.current, options);
 	}, [element.texExpression]);
 };
 
@@ -26,14 +26,14 @@ const useEquationInput = ({ isInline, open, onClose }) => {
 	const editor = useEditorRef();
 	const element = useElement();
 	const inputRef = useRef(null);
-	const [expressionInput, setExpressionInput] = React.useState(element.texExpression);
-	const initialExpressionRef = useRef(element.texExpression);
+	const [expressionInput, setExpressionInput] = React.useState(getEquationExpression(element));
+	const initialExpressionRef = useRef(getEquationExpression(element));
 	useEffect(() => {
 		if (open) setTimeout(() => {
 			if (inputRef.current) {
 				inputRef.current.focus();
 				inputRef.current.select();
-				if (isInline) initialExpressionRef.current = element.texExpression;
+				if (isInline) initialExpressionRef.current = getEquationExpression(element);
 			}
 		}, 0);
 	}, [open]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/platejs-math",
-  "version": "52.3.6",
+  "version": "53.4.10",
   "description": "Math plugin for Plate",
   "keywords": [
     "plate",
@@ -35,10 +35,10 @@
   "devDependencies": {
     "@types/katex": "0.16.7",
     "@plate/scripts": "1.0.0",
-    "platejs": "npm:@lofcz/platejs@52.3.6"
+    "platejs": "npm:@lofcz/platejs@53.4.9"
   },
   "peerDependencies": {
-    "platejs": ">=52.0.11",
+    "platejs": ">=53.0.0",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0"
   },

package/dist/BaseInlineEquationPlugin-1MXNHk1G.js

@@ -1,45 +0,0 @@
-import { KEYS, bindFirst, createSlatePlugin } from "platejs";
-import "katex/dist/katex.min.css";
-
-//#region src/lib/transforms/insertEquation.ts
-const insertEquation = (editor, options) => {
-	editor.tf.insertNodes({
-		children: [{ text: "" }],
-		texExpression: "",
-		type: editor.getType(KEYS.equation)
-	}, options);
-};
-
-//#endregion
-//#region src/lib/transforms/insertInlineEquation.ts
-const insertInlineEquation = (editor, texExpression, options) => {
-	editor.tf.insertNodes({
-		children: [{ text: "" }],
-		texExpression: texExpression ?? editor.api.string(editor.selection),
-		type: editor.getType(KEYS.inlineEquation)
-	}, options);
-};
-
-//#endregion
-//#region src/lib/BaseEquationPlugin.ts
-const BaseEquationPlugin = createSlatePlugin({
-	key: KEYS.equation,
-	node: {
-		isElement: true,
-		isVoid: true
-	}
-}).extendEditorTransforms(({ editor }) => ({ insert: { equation: bindFirst(insertEquation, editor) } }));
-
-//#endregion
-//#region src/lib/BaseInlineEquationPlugin.ts
-const BaseInlineEquationPlugin = createSlatePlugin({
-	key: KEYS.inlineEquation,
-	node: {
-		isElement: true,
-		isInline: true,
-		isVoid: true
-	}
-}).extendEditorTransforms(({ editor }) => ({ insert: { inlineEquation: bindFirst(insertInlineEquation, editor) } }));
-
-//#endregion
-export { insertEquation as i, BaseEquationPlugin as n, insertInlineEquation as r, BaseInlineEquationPlugin as t };