tiny-markdown-editor 0.2.0 → 0.2.1

package/lib/TinyMDE.d.ts

@@ -1,8 +1,10 @@
+import { GrammarRule } from "./grammar";
 export interface EditorProps {
     element?: string | HTMLElement;
     editor?: string | HTMLElement;
     content?: string;
     textarea?: string | HTMLTextAreaElement;
+    customInlineGrammar?: Record<string, GrammarRule>;
 }
 export interface Position {
     row: number;
@@ -38,6 +40,8 @@ export declare class Editor {
     linkLabels: string[];
     lineDirty: boolean[];
     lastCommandState: Record<string, boolean | null> | null;
+    private customInlineGrammar;
+    private mergedInlineGrammar;
     listeners: {
         change: EventHandler<ChangeEvent>[];
         selection: EventHandler<SelectionEvent>[];

package/lib/TinyMDE.js

@@ -14,6 +14,8 @@ class Editor {
         this.linkLabels = [];
         this.lineDirty = [];
         this.lastCommandState = null;
+        this.customInlineGrammar = {};
+        this.mergedInlineGrammar = grammar_1.inlineGrammar;
         this.listeners = {
             change: [],
             selection: [],
@@ -33,6 +35,8 @@ class Editor {
         this.linkLabels = [];
         this.lineDirty = [];
         this.lastCommandState = null;
+        this.customInlineGrammar = props.customInlineGrammar || {};
+        this.mergedInlineGrammar = (0, grammar_1.createMergedInlineGrammar)(this.customInlineGrammar);
         this.listeners = {
             change: [],
             selection: [],
@@ -555,17 +559,31 @@ class Editor {
         outer: while (string) {
             // Process simple rules (non-delimiter)
             for (let rule of ["escape", "code", "autolink", "html"]) {
-                let cap = grammar_1.inlineGrammar[rule].regexp.exec(string);
-                if (cap) {
-                    string = string.substr(cap[0].length);
-                    offset += cap[0].length;
-                    processed += grammar_1.inlineGrammar[rule].replacement.replace(/\$([1-9])/g, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
-                    continue outer;
+                if (this.mergedInlineGrammar[rule]) {
+                    let cap = this.mergedInlineGrammar[rule].regexp.exec(string);
+                    if (cap) {
+                        string = string.substr(cap[0].length);
+                        offset += cap[0].length;
+                        processed += this.mergedInlineGrammar[rule].replacement.replace(/\$([1-9])/g, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
+                        continue outer;
+                    }
+                }
+            }
+            // Process custom inline grammar rules
+            for (let rule in this.customInlineGrammar) {
+                if (rule !== "escape" && rule !== "code" && rule !== "autolink" && rule !== "html" && rule !== "linkOpen" && rule !== "imageOpen" && rule !== "linkLabel" && rule !== "default") {
+                    let cap = this.mergedInlineGrammar[rule].regexp.exec(string);
+                    if (cap) {
+                        string = string.substr(cap[0].length);
+                        offset += cap[0].length;
+                        processed += this.mergedInlineGrammar[rule].replacement.replace(/\$([1-9])/g, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
+                        continue outer;
+                    }
                 }
             }
             // Check for links / images
-            let potentialLink = string.match(grammar_1.inlineGrammar.linkOpen.regexp);
-            let potentialImage = string.match(grammar_1.inlineGrammar.imageOpen.regexp);
+            let potentialLink = string.match(this.mergedInlineGrammar.linkOpen.regexp);
+            let potentialImage = string.match(this.mergedInlineGrammar.imageOpen.regexp);
             if (potentialImage || potentialLink) {
                 let result = this.parseLinkOrImage(string, !!potentialImage);
                 if (result) {
@@ -673,11 +691,11 @@ class Editor {
                 continue outer;
             }
             // Process 'default' rule
-            cap = grammar_1.inlineGrammar.default.regexp.exec(string);
+            cap = this.mergedInlineGrammar.default.regexp.exec(string);
             if (cap) {
                 string = string.substr(cap[0].length);
                 offset += cap[0].length;
-                processed += grammar_1.inlineGrammar.default.replacement.replace(/\$([1-9])/g, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
+                processed += this.mergedInlineGrammar.default.replacement.replace(/\$([1-9])/g, (str, p1) => (0, grammar_1.htmlescape)(cap[p1]));
                 continue outer;
             }
             throw "Infinite loop!";
@@ -924,20 +942,20 @@ class Editor {
             let string = originalString.substr(currentOffset);
             // Capture any escapes and code blocks at current position
             for (let rule of ["escape", "code", "autolink", "html"]) {
-                let cap = grammar_1.inlineGrammar[rule].regexp.exec(string);
+                let cap = this.mergedInlineGrammar[rule].regexp.exec(string);
                 if (cap) {
                     currentOffset += cap[0].length;
                     continue textOuter;
                 }
             }
             // Check for image
-            if (string.match(grammar_1.inlineGrammar.imageOpen.regexp)) {
+            if (string.match(this.mergedInlineGrammar.imageOpen.regexp)) {
                 bracketLevel++;
                 currentOffset += 2;
                 continue textOuter;
             }
             // Check for link
-            if (string.match(grammar_1.inlineGrammar.linkOpen.regexp)) {
+            if (string.match(this.mergedInlineGrammar.linkOpen.regexp)) {
                 bracketLevel++;
                 if (!isImage) {
                     if (this.parseLinkOrImage(string, false)) {
@@ -967,12 +985,12 @@ class Editor {
         // REFERENCE LINKS
         if (nextChar === "[") {
             let string = originalString.substr(currentOffset);
-            let cap = grammar_1.inlineGrammar.linkLabel.regexp.exec(string);
+            let cap = this.mergedInlineGrammar.linkLabel.regexp.exec(string);
             if (cap) {
                 currentOffset += cap[0].length;
                 linkLabel.push(cap[1], cap[2], cap[3]);
-                if (cap[grammar_1.inlineGrammar.linkLabel.labelPlaceholder]) {
-                    linkRef = cap[grammar_1.inlineGrammar.linkLabel.labelPlaceholder];
+                if (cap[this.mergedInlineGrammar.linkLabel.labelPlaceholder]) {
+                    linkRef = cap[this.mergedInlineGrammar.linkLabel.labelPlaceholder];
                 }
                 else {
                     linkRef = linkText.trim();
@@ -1033,7 +1051,7 @@ class Editor {
                     continue inlineOuter;
                 }
                 // Process backslash escapes
-                cap = grammar_1.inlineGrammar.escape.regexp.exec(string);
+                cap = this.mergedInlineGrammar.escape.regexp.exec(string);
                 if (cap) {
                     switch (linkDetails.length) {
                         case 0:

package/lib/grammar.d.ts

@@ -49,6 +49,13 @@ export declare const htmlBlockGrammar: HTMLBlockRule[];
  * In the regular expressions, replacements from the object 'replacements' will be processed before compiling into the property regexp.
  */
 export declare const inlineGrammar: Record<string, GrammarRule>;
+/**
+ * Creates a merged inline grammar by combining the default inline grammar with custom rules.
+ * Custom rules are processed and their regexp patterns are expanded with replacements.
+ * @param customRules - Object containing custom inline grammar rules
+ * @returns Merged inline grammar object
+ */
+export declare function createMergedInlineGrammar(customRules?: Record<string, GrammarRule>): Record<string, GrammarRule>;
 /**
  * Escapes HTML special characters (<, >, and &) in the string.
  * @param {string} string The raw string to be escaped

package/lib/grammar.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commands = exports.inlineGrammar = exports.htmlBlockGrammar = exports.lineGrammar = exports.punctuationTrailing = exports.punctuationLeading = void 0;
+exports.createMergedInlineGrammar = createMergedInlineGrammar;
 exports.htmlescape = htmlescape;
 const replacements = {
     ASCIIPunctuation: /[!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~\\]/,
@@ -178,6 +179,32 @@ for (let rule of exports.htmlBlockGrammar) {
     }
     rule.start = new RegExp(re, rule.start.flags);
 }
+/**
+ * Creates a merged inline grammar by combining the default inline grammar with custom rules.
+ * Custom rules are processed and their regexp patterns are expanded with replacements.
+ * @param customRules - Object containing custom inline grammar rules
+ * @returns Merged inline grammar object
+ */
+function createMergedInlineGrammar(customRules = {}) {
+    const merged = { ...exports.inlineGrammar };
+    // Process custom rules
+    for (const [ruleName, rule] of Object.entries(customRules)) {
+        // Copy the rule to avoid modifying the original
+        const processedRule = { ...rule };
+        // Process replacements in the regexp
+        let regexpSource = rule.regexp.source;
+        const replacementRegexp = new RegExp(Object.keys(replacements).join('|'));
+        // Replace while there is something to replace
+        while (regexpSource.match(replacementRegexp)) {
+            regexpSource = regexpSource.replace(replacementRegexp, (match) => {
+                return replacements[match].source;
+            });
+        }
+        processedRule.regexp = new RegExp(regexpSource, rule.regexp.flags);
+        merged[ruleName] = processedRule;
+    }
+    return merged;
+}
 /**
  * Escapes HTML special characters (<, >, and &) in the string.
  * @param {string} string The raw string to be escaped

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-markdown-editor",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "TinyMDE: A tiny, ultra low dependency, embeddable HTML/JavaScript Markdown editor.",
   "main": "lib/index.js",
   "files": [