@richscripts/richtexteditor 2.4.0

package/richtexteditor/plugins/localdraft.js

@@ -0,0 +1,213 @@
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
+// 2026-06-06 Local draft autosave + crash recovery. Complements the core
+// server-oriented config.autoSave by persisting the document to localStorage as
+// you type, so a refresh / crash / accidental navigation never loses work — the
+// next load offers to restore the unsaved draft (Gmail / Notion style).
+//
+// Opt-in: enable by setting config.localDraft to `true` or to an options object:
+//   config.localDraft = {
+//     key: "my-doc",          // storage key (default: editor id or page path)
+//     intervalMs: 2500,       // debounce between saves (default 2500)
+//     ttlMs: 1209600000,      // drop drafts older than this (default 14 days)
+//     promptRestore: true     // show the built-in restore bar (default true)
+//   }
+//
+// The host app can also drive it via the API and clear the draft after a real
+// save: editor.saveLocalDraft(), editor.hasLocalDraft(), editor.getLocalDraft(),
+// editor.restoreLocalDraft(), editor.clearLocalDraft().
+RTE_DefaultConfig.plugin_localdraft = RTE_Plugin_LocalDraft;
+if (typeof RTE_DefaultConfig.localDraft === "undefined") RTE_DefaultConfig.localDraft = false;
+
+function RTE_Plugin_LocalDraft() {
+    var obj = this;
+    var config, editor;
+    var opts = null, key = null, timer = null, baseline = "", bar = null, attached = false, boundDoc = null;
+
+    obj.PluginName = "LocalDraft";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+
+        // Public API works regardless of the opt-in flag.
+        editor.saveLocalDraft = function () { return save(true); };
+        editor.hasLocalDraft = function () { return !!read(); };
+        editor.getLocalDraft = function () { return read(); };
+        editor.clearLocalDraft = function () { try { store().removeItem(resolveKey()); } catch (e) {} hideBar(); return true; };
+        editor.restoreLocalDraft = function () {
+            var d = read(); if (!d) return false;
+            try { editor.setHTMLCode(d.html); } catch (e) { return false; }
+            try { if (typeof editor.fireChange === "function") editor.fireChange(); } catch (e) {}
+            hideBar();
+            return true;
+        };
+
+        if (!config.localDraft) return;   // disabled — API still available
+        opts = (typeof config.localDraft === "object") ? config.localDraft : {};
+        key = resolveKey();
+
+        // Capture the initial (server-provided) content as the baseline so we
+        // only offer a restore when the draft actually differs from it.
+        var startup = function () {
+            if (attached) return;   // fires from both "ready" and the timeout — run once
+            baseline = safeGetHTML();
+            maybeOfferRestore();
+            attach();
+        };
+        try { editor.attachEvent("ready", startup); } catch (e) {}
+        // The editor recreates its document/body after init and on aftersethtml;
+        // re-bind the doc-level input listener each time so autosave never goes
+        // deaf to plain typing on a stale document.
+        try { editor.attachEvent("ready", bindDoc); } catch (e) {}
+        try { editor.attachEvent("aftersethtml", bindDoc); } catch (e) {}
+        setTimeout(startup, 0);
+    };
+
+    var changeHandler = function () { schedule(); };
+
+    function bindDoc() {
+        if (!config || !config.localDraft) return;
+        var doc = editor.getDocument();
+        if (doc && doc !== boundDoc) {
+            try { doc.addEventListener("input", changeHandler, true); } catch (e) {}
+            boundDoc = doc;
+        }
+    }
+
+    function attach() {
+        if (attached) return;   // startup can fire from both "ready" and the timeout
+        attached = true;
+        try { editor.attachEvent("change", changeHandler); } catch (e) {}
+        try { editor.attachEvent("keyup", changeHandler); } catch (e) {}
+        bindDoc();
+        // Last-chance save when the page is hidden / unloaded.
+        try {
+            window.addEventListener("beforeunload", function () { save(false); }, false);
+            window.addEventListener("pagehide", function () { save(false); }, false);
+        } catch (e) {}
+    }
+
+    function intervalMs() { var n = opts && +opts.intervalMs; return (n && n > 250) ? n : 2500; }
+    function ttlMs() { var n = opts && +opts.ttlMs; return (n && n > 0) ? n : 14 * 24 * 60 * 60 * 1000; }
+
+    function resolveKey() {
+        if (opts && opts.key) return "rte-draft:" + opts.key;
+        var id = "";
+        try { var ed = editor.getEditable(); id = (ed && (ed.id || (ed.getAttribute && ed.getAttribute("data-rte-id")))) || ""; } catch (e) {}
+        if (!id) { try { id = location.pathname; } catch (e) { id = "default"; } }
+        return "rte-draft:" + id;
+    }
+
+    function store() { return window.localStorage; }
+
+    function schedule() {
+        if (timer) return;
+        timer = setTimeout(function () { timer = null; save(false); }, intervalMs());
+    }
+
+    function safeGetHTML() {
+        try { return editor.getHTMLCode() || ""; } catch (e) { return ""; }
+    }
+
+    function save(force) {
+        if (!config || !config.localDraft) return false;
+        var html = safeGetHTML();
+        // Don't persist an empty doc or one identical to the server baseline.
+        if (!force && (html === baseline || isBlank(html))) return false;
+        var rec = { html: html, t: nowMs() };
+        try { store().setItem(resolveKey(), JSON.stringify(rec)); return true; }
+        catch (e) { return false; }
+    }
+
+    function read() {
+        try {
+            var raw = store().getItem(resolveKey());
+            if (!raw) return null;
+            var rec = JSON.parse(raw);
+            if (!rec || typeof rec.html !== "string") return null;
+            if (rec.t && (nowMs() - rec.t) > ttlMs()) { try { store().removeItem(resolveKey()); } catch (e) {} return null; }
+            return rec;
+        } catch (e) { return null; }
+    }
+
+    function isBlank(html) {
+        if (!html) return true;
+        var t = html.replace(/<[^>]*>/g, "").replace(/&nbsp;/gi, " ").replace(/\s+/g, "");
+        return t.length === 0;
+    }
+
+    function nowMs() {
+        // Date.now is available in the browser; guard just in case.
+        try { return Date.now(); } catch (e) { return 0; }
+    }
+
+    function maybeOfferRestore() {
+        if (opts && opts.promptRestore === false) return;
+        var d = read();
+        if (!d) return;
+        if (d.html === baseline || isBlank(d.html)) return;
+        showBar(d);
+    }
+
+    // --- Compact restore bar in the host page ---
+    function showBar(draft) {
+        hideBar();
+        var host = hostElement();
+        if (!host || !host.parentNode) return;
+        var when = friendlyTime(draft.t);
+        bar = document.createElement("div");
+        bar.className = "rte-localdraft-bar";
+        bar.setAttribute("data-rte-localdraft", "1");
+        // Announce the recovery offer to assistive tech.
+        bar.setAttribute("role", "status");
+        bar.setAttribute("aria-live", "polite");
+        var msg = document.createElement("span");
+        msg.className = "rte-localdraft-message";
+        msg.textContent = "An unsaved draft" + (when ? (" from " + when) : "") + " was found.";
+        var restore = mkBtn("Restore", "primary");
+        var discard = mkBtn("Discard", "secondary");
+        restore.onclick = function () { editor.restoreLocalDraft(); };
+        discard.onclick = function () { editor.clearLocalDraft(); };
+        bar.appendChild(msg); bar.appendChild(restore); bar.appendChild(discard);
+        host.parentNode.insertBefore(bar, host);
+    }
+    function mkBtn(label, tone) {
+        var b = document.createElement("button");
+        b.type = "button"; b.textContent = label;
+        b.className = "rte-localdraft-button is-" + tone;
+        return b;
+    }
+    function hideBar() { if (bar && bar.parentNode) { bar.parentNode.removeChild(bar); } bar = null; }
+
+    function hostElement() {
+        // The editor's top-level wrapper in the host page (the iframe's container).
+        try {
+            var doc = editor.getDocument();
+            var frame = doc && doc.defaultView && doc.defaultView.frameElement;
+            if (frame) {
+                var n = frame;
+                // climb to the editor's outer container if present
+                for (var i = 0; i < 4 && n.parentNode; i++) {
+                    if (n.parentNode && /rte[_-](outer|container|wrapper)/i.test(n.parentNode.className || "")) return n.parentNode;
+                    n = n.parentNode;
+                }
+                return frame;
+            }
+        } catch (e) {}
+        try { return editor.getEditable(); } catch (e) { return null; }
+    }
+
+    function friendlyTime(t) {
+        if (!t) return "";
+        try {
+            var d = new Date(t);
+            var diff = (nowMs() - t) / 1000;
+            if (diff < 60) return "just now";
+            if (diff < 3600) return Math.round(diff / 60) + " min ago";
+            if (diff < 86400) return Math.round(diff / 3600) + " hr ago";
+            return d.toLocaleString();
+        } catch (e) { return ""; }
+    }
+}

package/richtexteditor/plugins/markdownexport.js

@@ -0,0 +1,110 @@
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
+// 2026-06-06 Markdown export surface. The core already ships an HTML→Markdown
+// engine (editor.toMarkdown()); this plugin makes it discoverable the way Notion
+// "Copy as Markdown" / Obsidian do: a one-click copy-to-clipboard and a
+// download-as-.md, exposed as slash commands + a public API. No content is
+// modified — these are read-only exporters.
+RTE_DefaultConfig.plugin_markdownexport = RTE_Plugin_MarkdownExport;
+if (typeof RTE_DefaultConfig.markdownExportEnabled === "undefined") RTE_DefaultConfig.markdownExportEnabled = true;
+
+function RTE_Plugin_MarkdownExport() {
+    var obj = this;
+    var config, editor;
+
+    obj.PluginName = "MarkdownExport";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+
+        // getMarkdown(): friendly alias for the core toMarkdown() engine.
+        editor.getMarkdown = function () {
+            if (typeof editor.toMarkdown === "function") return editor.toMarkdown();
+            // Fallback: very small HTML→text if the core engine is unavailable.
+            var ed = editor.getEditable();
+            return ed ? (ed.innerText || ed.textContent || "") : "";
+        };
+
+        // copyAsMarkdown(): write the document's Markdown to the clipboard.
+        // Returns a Promise<boolean>. Must run from a user gesture (the slash
+        // command click qualifies).
+        editor.copyAsMarkdown = function () {
+            var md = editor.getMarkdown();
+            return writeClipboard(md);
+        };
+
+        // downloadMarkdown(filename): save the Markdown as a .md file.
+        editor.downloadMarkdown = function (filename) {
+            var md = editor.getMarkdown();
+            var base = sanitizeName(filename);
+            var name = base ? (base + ".md") : defaultName();
+            return triggerDownload(md, name);
+        };
+    };
+
+    function defaultName() {
+        // Derive from the first heading/line if possible.
+        try {
+            var ed = editor.getEditable();
+            if (ed) {
+                var h = ed.querySelector("h1,h2,h3");
+                var base = h ? h.textContent : (ed.textContent || "");
+                base = (base || "").trim().split("\n")[0].slice(0, 60);
+                var clean = sanitizeName(base);
+                if (clean) return clean + ".md";
+            }
+        } catch (e) {}
+        return "document.md";
+    }
+
+    function sanitizeName(s) {
+        if (!s) return "";
+        s = String(s).replace(/\.md$/i, "");
+        s = s.replace(/[\\/:*?"<>|\u0000-\u001f]+/g, " ").replace(/\s+/g, " ").trim();
+        s = s.replace(/[ .]+$/, "");
+        return s;
+    }
+
+    function writeClipboard(text) {
+        try {
+            if (navigator.clipboard && navigator.clipboard.writeText) {
+                return navigator.clipboard.writeText(text).then(function () { return true; }, function () { return legacyCopy(text); });
+            }
+        } catch (e) {}
+        return Promise.resolve(legacyCopy(text));
+    }
+
+    function legacyCopy(text) {
+        try {
+            var doc = document;
+            var ta = doc.createElement("textarea");
+            ta.value = text;
+            ta.style.position = "fixed"; ta.style.top = "-1000px"; ta.style.opacity = "0";
+            doc.body.appendChild(ta);
+            ta.focus(); ta.select();
+            var ok = false;
+            try { ok = doc.execCommand("copy"); } catch (e) { ok = false; }
+            doc.body.removeChild(ta);
+            return ok;
+        } catch (e) { return false; }
+    }
+
+    function triggerDownload(text, filename) {
+        try {
+            var blob = new Blob([text], { type: "text/markdown;charset=utf-8" });
+            var url = (window.URL || window.webkitURL).createObjectURL(blob);
+            var a = document.createElement("a");
+            a.href = url; a.download = filename;
+            a.style.display = "none";
+            document.body.appendChild(a);
+            a.click();
+            setTimeout(function () {
+                try { document.body.removeChild(a); } catch (e) {}
+                try { (window.URL || window.webkitURL).revokeObjectURL(url); } catch (e) {}
+            }, 0);
+            return true;
+        } catch (e) { return false; }
+    }
+}

package/richtexteditor/plugins/mathdialog.js

@@ -0,0 +1,153 @@
+if (!window.RTE_DefaultConfig) window.RTE_DefaultConfig = {};
+
+// 2026-06-04 Equation-editor dialog. Closes the "no equation editor UI" gap
+// vs CKEditor Math / Google Docs equation editor. Builds on the editor's
+// existing inline-math infrastructure (editor.applyMathMarkup / renderMath /
+// the .rte-math-inline markup) — this plugin only adds the authoring UX: a
+// TeX input with a live KaTeX/MathJax preview, plus edit-in-place when the
+// caret is already inside an equation. No renderer is bundled; the host page
+// supplies KaTeX or MathJax exactly as for inline `$...$` rendering.
+RTE_DefaultConfig.plugin_mathdialog = RTE_Plugin_MathDialog;
+
+RTE_DefaultConfig.mathDialogSamples = RTE_DefaultConfig.mathDialogSamples || [
+    "x^2 + y^2 = z^2",
+    "\\frac{a}{b}",
+    "\\sqrt{x}",
+    "\\sum_{i=1}^{n} i",
+    "\\int_0^1 x\\,dx",
+    "\\alpha\\beta\\gamma"
+];
+
+function RTE_Plugin_MathDialog() {
+    var obj = this;
+    var config;
+    var editor;
+
+    obj.PluginName = "MathDialog";
+
+    obj.InitConfig = function (argconfig) { config = argconfig; };
+
+    obj.InitEditor = function (argeditor) {
+        editor = argeditor;
+        editor.attachEvent("exec_command_insertmath", function (state) {
+            state.returnValue = true;
+            obj.OpenMathDialog();
+        });
+    };
+
+    function append(parent, tag, cssText, className) {
+        var el = parent.ownerDocument.createElement(tag);
+        if (cssText) el.style.cssText = cssText;
+        if (className) el.className = className;
+        parent.appendChild(el);
+        return el;
+    }
+
+    // If the current selection sits inside an existing inline-math span, return
+    // it so we can edit in place rather than insert a new equation.
+    function findMathSpanAtSelection() {
+        try {
+            var sel = editor.getSelection();
+            if (!sel || sel.rangeCount === 0) return null;
+            var node = sel.getRangeAt(0).startContainer;
+            var editable = editor.getEditable();
+            while (node && node !== editable) {
+                if (node.nodeType === 1 && node.classList && node.classList.contains("rte-math-inline")) return node;
+                node = node.parentNode;
+            }
+        } catch (e) { /* ignore */ }
+        return null;
+    }
+
+    // Resolve a math renderer from the dialog's (host) window or its parent.
+    function getRenderer(win) {
+        var katex = win.katex || (win.parent && win.parent.katex);
+        if (katex && typeof katex.render === "function") return { kind: "katex", katex: katex };
+        var MathJax = win.MathJax || (win.parent && win.parent.MathJax);
+        if (MathJax && MathJax.typesetPromise) return { kind: "mathjax", MathJax: MathJax };
+        return null;
+    }
+
+    obj.OpenMathDialog = function () {
+        var existing = findMathSpanAtSelection();
+        var initialTex = existing ? (existing.getAttribute("data-tex") || "") : "";
+
+        var dlg = editor.createDialog(
+            (editor.getLangText && editor.getLangText("insertmathtitle")) || "Insert / edit equation",
+            "rte-dialog-math"
+        );
+        var close = typeof dlg.close === "function" ? function () { dlg.close(); } : function () { editor.closeCurrentPopup(); };
+        var win = dlg.ownerDocument.defaultView || window;
+
+        var wrap = append(dlg, "div", "padding:14px;min-width:420px;font:13px -apple-system,Segoe UI,sans-serif");
+
+        append(wrap, "div", "font-weight:600;margin-bottom:4px", "").innerText =
+            (editor.getLangText && editor.getLangText("insertmathlabel")) || "TeX / LaTeX";
+        var ta = append(wrap, "textarea",
+            "width:100%;box-sizing:border-box;min-height:72px;padding:8px 10px;border:1px solid #cbd5e1;border-radius:8px;font:13px ui-monospace,Consolas,monospace;resize:vertical");
+        ta.value = initialTex;
+        ta.placeholder = "e.g.  x^2 + y^2 = z^2";
+
+        // Sample chips
+        var samples = append(wrap, "div", "display:flex;flex-wrap:wrap;gap:6px;margin:8px 0");
+        (config.mathDialogSamples || []).forEach(function (s) {
+            var chip = append(samples, "button", "font:11px ui-monospace,monospace;padding:3px 8px;border:1px solid #e2e8f0;border-radius:6px;background:#f8fafc;cursor:pointer", "");
+            chip.type = "button";
+            chip.textContent = s;
+            chip.onclick = function () { ta.value = s; updatePreview(); ta.focus(); };
+        });
+
+        append(wrap, "div", "font-weight:600;margin:10px 0 4px", "").innerText =
+            (editor.getLangText && editor.getLangText("insertmathpreview")) || "Preview";
+        var preview = append(wrap, "div",
+            "min-height:48px;padding:10px 12px;border:1px solid #e2e8f0;border-radius:8px;background:#fff;overflow:auto;text-align:center");
+        var rendererNote = append(wrap, "div", "font-size:11px;color:#94a3b8;margin-top:4px", "");
+
+        var renderer = getRenderer(win);
+        if (!renderer) {
+            rendererNote.innerText = "No KaTeX/MathJax detected on the page — the equation is stored as markup and will render wherever a math renderer is loaded.";
+        }
+
+        function updatePreview() {
+            var tex = ta.value;
+            if (!tex.trim()) { preview.textContent = ""; return; }
+            if (renderer && renderer.kind === "katex") {
+                try { renderer.katex.render(tex, preview, { throwOnError: false, displayMode: false }); }
+                catch (e) { preview.textContent = "⚠ " + (e && e.message ? e.message : "render error"); }
+            } else if (renderer && renderer.kind === "mathjax") {
+                preview.textContent = "\\(" + tex + "\\)";
+                try { renderer.MathJax.typesetPromise([preview]); } catch (e) { /* ignore */ }
+            } else {
+                preview.textContent = "$" + tex + "$";
+            }
+        }
+        ta.oninput = updatePreview;
+        setTimeout(function () { ta.focus(); updatePreview(); }, 0);
+
+        var footer = append(wrap, "div", "display:flex;justify-content:flex-end;gap:8px;margin-top:14px");
+        var cancel = append(footer, "button", "padding:6px 14px;border:1px solid #cbd5e1;border-radius:8px;background:#fff;cursor:pointer", "");
+        cancel.type = "button"; cancel.textContent = "Cancel"; cancel.onclick = close;
+        var ok = append(footer, "button", "padding:6px 14px;border:1px solid #1d67ba;border-radius:8px;background:#1d67ba;color:#fff;cursor:pointer", "");
+        ok.type = "button"; ok.textContent = existing ? "Update" : "Insert";
+
+        ok.onclick = function () {
+            var tex = ta.value.trim();
+            if (!tex) { close(); return; }
+            if (existing) {
+                // Edit in place: update the existing span's data-tex + text, re-render.
+                existing.setAttribute("data-tex", tex);
+                existing.textContent = "$" + tex + "$";
+                close();
+                if (editor.renderMath) editor.renderMath();
+                editor.focus();
+                return;
+            }
+            var safeTex = String(tex).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+            var safeText = String("$" + tex + "$").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+            editor.insertHTML('<span class="rte-math-inline" data-tex="' + safeTex + '">' + safeText + "</span>​");
+            close();
+            if (editor.renderMath) editor.renderMath();
+            editor.focus();
+        };
+    };
+}