@kerebron/editor-kits 0.4.1

package/esm/extension-codejar/src/CodeJar.js

@@ -0,0 +1,585 @@
+import * as dntShim from "../../_dnt.shims.js";
+const globalWindow = dntShim.dntGlobalThis;
+function visit(editor, visitor) {
+    const queue = [];
+    if (editor.firstChild)
+        queue.push(editor.firstChild);
+    let el = queue.pop();
+    while (el) {
+        if (visitor(el) === 'stop')
+            break;
+        if (el.nextSibling)
+            queue.push(el.nextSibling);
+        if (el.firstChild)
+            queue.push(el.firstChild);
+        el = queue.pop();
+    }
+}
+function isCtrl(event) {
+    return event.metaKey || event.ctrlKey;
+}
+function isUndo(event) {
+    return isCtrl(event) && !event.shiftKey && getKeyCode(event) === 'Z';
+}
+function isRedo(event) {
+    return isCtrl(event) && event.shiftKey && getKeyCode(event) === 'Z';
+}
+function isCopy(event) {
+    return isCtrl(event) && getKeyCode(event) === 'C';
+}
+function getKeyCode(event) {
+    let key = event.key || event.keyCode || event.which;
+    if (!key)
+        return undefined;
+    return (typeof key === 'string' ? key : String.fromCharCode(key))
+        .toUpperCase();
+}
+function insert(text) {
+    text = text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+    document.execCommand('insertHTML', false, text);
+}
+function debounce(cb, wait) {
+    let timeout = 0;
+    return (...args) => {
+        clearTimeout(timeout);
+        timeout = globalThis.setTimeout(() => cb(...args), wait);
+    };
+}
+function findPadding(text) {
+    // Find beginning of previous line.
+    let i = text.length - 1;
+    while (i >= 0 && text[i] !== '\n')
+        i--;
+    i++;
+    // Find padding of the line.
+    let j = i;
+    while (j < text.length && /[ \t]/.test(text[j]))
+        j++;
+    return [text.substring(i, j) || '', i, j];
+}
+export class CodeJar extends EventTarget {
+    constructor(editor, highlight, opt = {}) {
+        super();
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: editor
+        });
+        Object.defineProperty(this, "highlight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: highlight
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "history", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "at", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        Object.defineProperty(this, "onUpdateCbk", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => void 0
+        });
+        Object.defineProperty(this, "focus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "prev", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // code content prior keydown event
+        this.options = {
+            tab: '\t',
+            indentOn: /[({\[]$/,
+            moveToNewLine: /^[)}\]]/,
+            spellcheck: false,
+            catchTab: true,
+            preserveIdent: true,
+            addClosing: true,
+            history: true,
+            window: globalWindow,
+            autoclose: {
+                open: '',
+                close: '',
+            },
+            ...opt,
+        };
+        const window = this.options.window;
+        const document = window.document;
+        editor.setAttribute('contenteditable', 'plaintext-only');
+        editor.setAttribute('spellcheck', this.options.spellcheck ? 'true' : 'false');
+        editor.style.outline = 'none';
+        editor.style.overflowWrap = 'break-word';
+        editor.style.overflowY = 'auto';
+        editor.style.whiteSpace = 'pre-wrap';
+        const matchFirefoxVersion = window.navigator.userAgent.match(/Firefox\/([0-9]+)\./);
+        const firefoxVersion = matchFirefoxVersion
+            ? parseInt(matchFirefoxVersion[1])
+            : 0;
+        let isLegacy = false; // true if plaintext-only is not supported
+        if (editor.contentEditable !== 'plaintext-only' || firefoxVersion >= 136) {
+            isLegacy = true;
+        }
+        if (isLegacy)
+            editor.setAttribute('contenteditable', 'true');
+        const debounceHighlight = debounce(() => {
+            const pos = this.save();
+            this.doHighlight(editor, pos);
+            this.restore(pos);
+        }, 30);
+        let recording = false;
+        const shouldRecord = (event) => {
+            return !isUndo(event) && !isRedo(event) &&
+                event.key !== 'Meta' &&
+                event.key !== 'Control' &&
+                event.key !== 'Alt' &&
+                !event.key.startsWith('Arrow');
+        };
+        const debounceRecordHistory = debounce((event) => {
+            if (shouldRecord(event)) {
+                this.recordHistory();
+                recording = false;
+            }
+        }, 300);
+        const on = (type, fn) => {
+            this.listeners.push([type, fn]);
+            this.editor.addEventListener(type, fn);
+        };
+        on('keydown', (event) => {
+            if (event.defaultPrevented)
+                return;
+            this.prev = this.toString();
+            if (this.options.preserveIdent)
+                handleNewLine(event);
+            else
+                legacyNewLineFix(event);
+            if (this.options.catchTab)
+                handleTabCharacters(event);
+            if (this.options.addClosing)
+                handleSelfClosingCharacters(event);
+            if (this.options.history) {
+                handleUndoRedo(event);
+                if (shouldRecord(event) && !recording) {
+                    this.recordHistory();
+                    recording = true;
+                }
+            }
+            if (isLegacy && !isCopy(event))
+                this.restore(this.save());
+        });
+        on('keyup', (event) => {
+            if (event.defaultPrevented)
+                return;
+            if (event.isComposing)
+                return;
+            if (this.prev !== this.toString())
+                debounceHighlight();
+            debounceRecordHistory(event);
+            this.onUpdateCbk(this.toString());
+        });
+        on('focus', (_event) => {
+            this.focus = true;
+        });
+        on('blur', (_event) => {
+            this.focus = false;
+        });
+        on('paste', (event) => {
+            this.recordHistory();
+            handlePaste(event);
+            this.recordHistory();
+            this.onUpdateCbk(this.toString());
+        });
+        on('cut', (event) => {
+            this.recordHistory();
+            handleCut(event);
+            this.recordHistory();
+            this.onUpdateCbk(this.toString());
+        });
+        const beforeCursor = () => {
+            const s = this.getSelection();
+            const r0 = s.getRangeAt(0);
+            const r = document.createRange();
+            r.selectNodeContents(editor);
+            r.setEnd(r0.startContainer, r0.startOffset);
+            return r.toString();
+        };
+        const afterCursor = () => {
+            const s = this.getSelection();
+            const r0 = s.getRangeAt(0);
+            const r = document.createRange();
+            r.selectNodeContents(editor);
+            r.setStart(r0.endContainer, r0.endOffset);
+            return r.toString();
+        };
+        const handleNewLine = (event) => {
+            if (event.key === 'Enter') {
+                const before = beforeCursor();
+                const after = afterCursor();
+                let [padding] = findPadding(before);
+                let newLinePadding = padding;
+                // If last symbol is "{" ident new line
+                if (this.options.indentOn.test(before)) {
+                    newLinePadding += this.options.tab;
+                }
+                // Preserve padding
+                if (newLinePadding.length > 0) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    insert('\n' + newLinePadding);
+                }
+                else {
+                    legacyNewLineFix(event);
+                }
+                // Place adjacent "}" on next line
+                if (newLinePadding !== padding && this.options.moveToNewLine.test(after)) {
+                    const pos = this.save();
+                    insert('\n' + padding);
+                    this.restore(pos);
+                }
+            }
+        };
+        const legacyNewLineFix = (event) => {
+            // Firefox does not support plaintext-only mode
+            // and puts <div><br></div> on Enter. Let's help.
+            if (isLegacy && event.key === 'Enter') {
+                event.preventDefault();
+                event.stopPropagation();
+                if (afterCursor() == '') {
+                    insert('\n ');
+                    const pos = this.save();
+                    pos.start = --pos.end;
+                    this.restore(pos);
+                }
+                else {
+                    insert('\n');
+                }
+            }
+        };
+        const handleSelfClosingCharacters = (event) => {
+            const open = this.options.autoclose.open;
+            const close = this.options.autoclose.close;
+            if (open.includes(event.key)) {
+                event.preventDefault();
+                const pos = this.save();
+                const wrapText = pos.start == pos.end
+                    ? ''
+                    : this.getSelection().toString();
+                const text = event.key + wrapText +
+                    (close[open.indexOf(event.key)] ?? '');
+                insert(text);
+                pos.start++;
+                pos.end++;
+                this.restore(pos);
+            }
+        };
+        const handleTabCharacters = (event) => {
+            if (event.key === 'Tab') {
+                event.preventDefault();
+                if (event.shiftKey) {
+                    const before = beforeCursor();
+                    let [padding, start] = findPadding(before);
+                    if (padding.length > 0) {
+                        const pos = this.save();
+                        // Remove full length tab or just remaining padding
+                        const len = Math.min(this.options.tab.length, padding.length);
+                        this.restore({ start, end: start + len });
+                        document.execCommand('delete');
+                        pos.start -= len;
+                        pos.end -= len;
+                        this.restore(pos);
+                    }
+                }
+                else {
+                    insert(this.options.tab);
+                }
+            }
+        };
+        const handleUndoRedo = (event) => {
+            if (isUndo(event)) {
+                event.preventDefault();
+                this.at--;
+                const record = this.history[this.at];
+                if (record) {
+                    editor.innerHTML = record.html;
+                    this.restore(record.pos);
+                }
+                if (this.at < 0)
+                    this.at = 0;
+            }
+            if (isRedo(event)) {
+                event.preventDefault();
+                this.at++;
+                const record = this.history[this.at];
+                if (record) {
+                    editor.innerHTML = record.html;
+                    this.restore(record.pos);
+                }
+                if (this.at >= history.length)
+                    this.at--;
+            }
+        };
+        const handlePaste = (event) => {
+            if (event.defaultPrevented)
+                return;
+            event.preventDefault();
+            const originalEvent = event.originalEvent ?? event;
+            const text = originalEvent.clipboardData.getData('text/plain').replace(/\r\n?/g, '\n');
+            const pos = this.save();
+            insert(text);
+            this.doHighlight(editor);
+            this.restore({
+                start: Math.min(pos.start, pos.end) + text.length,
+                end: Math.min(pos.start, pos.end) + text.length,
+                dir: '<-',
+            });
+        };
+        const handleCut = (event) => {
+            const pos = this.save();
+            const selection = this.getSelection();
+            const originalEvent = event.originalEvent ?? event;
+            originalEvent.clipboardData.setData('text/plain', selection.toString());
+            document.execCommand('delete');
+            this.doHighlight(editor);
+            this.restore({
+                start: Math.min(pos.start, pos.end),
+                end: Math.min(pos.start, pos.end),
+                dir: '<-',
+            });
+            event.preventDefault();
+        };
+    }
+    getSelection() {
+        return this.editor.getRootNode().getSelection();
+    }
+    doHighlight(editor, pos) {
+        this.highlight(editor, pos);
+    }
+    uneditable(node) {
+        while (node && node !== this.editor) {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+                const el = node;
+                if (el.getAttribute('contenteditable') == 'false') {
+                    return el;
+                }
+            }
+            node = node.parentNode;
+        }
+    }
+    toString() {
+        return this.editor.textContent || '';
+    }
+    updateOptions(newOptions) {
+        Object.assign(this.options, newOptions);
+    }
+    updateCode(code, callOnUpdate = true) {
+        this.editor.textContent = code;
+        this.doHighlight(this.editor);
+        callOnUpdate && this.onUpdateCbk(code);
+    }
+    onUpdate(callback) {
+        this.onUpdateCbk = callback;
+    }
+    save() {
+        const s = this.getSelection();
+        const pos = { start: 0, end: 0, dir: undefined };
+        if (!s) {
+            return pos;
+        }
+        let { anchorNode, anchorOffset, focusNode, focusOffset } = s;
+        if (!anchorNode)
+            throw new Error('No anchorNode');
+        if (!focusNode)
+            throw new Error('No focusNode');
+        // If the anchor and focus are the editor element, return either a full
+        // highlight or a start/end cursor position depending on the selection
+        if (anchorNode === this.editor && focusNode === this.editor) {
+            pos.start = (anchorOffset > 0 && this.editor.textContent)
+                ? this.editor.textContent.length
+                : 0;
+            pos.end = (focusOffset > 0 && this.editor.textContent)
+                ? this.editor.textContent.length
+                : 0;
+            pos.dir = (focusOffset >= anchorOffset) ? '->' : '<-';
+            return pos;
+        }
+        // Selection anchor and focus are expected to be text nodes,
+        // so normalize them.
+        if (anchorNode.nodeType === Node.ELEMENT_NODE) {
+            const node = document.createTextNode('');
+            anchorNode.insertBefore(node, anchorNode.childNodes[anchorOffset]);
+            anchorNode = node;
+            anchorOffset = 0;
+        }
+        if (focusNode.nodeType === Node.ELEMENT_NODE) {
+            const node = document.createTextNode('');
+            focusNode.insertBefore(node, focusNode.childNodes[focusOffset]);
+            focusNode = node;
+            focusOffset = 0;
+        }
+        visit(this.editor, (el) => {
+            if (el === anchorNode && el === focusNode) {
+                pos.start += anchorOffset;
+                pos.end += focusOffset;
+                pos.dir = anchorOffset <= focusOffset ? '->' : '<-';
+                return 'stop';
+            }
+            if (el === anchorNode) {
+                pos.start += anchorOffset;
+                if (!pos.dir) {
+                    pos.dir = '->';
+                }
+                else {
+                    return 'stop';
+                }
+            }
+            else if (el === focusNode) {
+                pos.end += focusOffset;
+                if (!pos.dir) {
+                    pos.dir = '<-';
+                }
+                else {
+                    return 'stop';
+                }
+            }
+            if (el.nodeType === Node.TEXT_NODE) {
+                if (pos.dir != '->')
+                    pos.start += el.nodeValue.length;
+                if (pos.dir != '<-')
+                    pos.end += el.nodeValue.length;
+            }
+        });
+        this.editor.normalize(); // collapse empty text nodes
+        return pos;
+    }
+    restore(pos) {
+        const s = this.getSelection();
+        if (!s) {
+            return;
+        }
+        let startNode, startOffset = 0;
+        let endNode, endOffset = 0;
+        if (!pos.dir)
+            pos.dir = '->';
+        if (pos.start < 0)
+            pos.start = 0;
+        if (pos.end < 0)
+            pos.end = 0;
+        // Flip start and end if the direction reversed
+        if (pos.dir == '<-') {
+            const { start, end } = pos;
+            pos.start = end;
+            pos.end = start;
+        }
+        let current = 0;
+        visit(this.editor, (el) => {
+            if (el.nodeType !== Node.TEXT_NODE)
+                return;
+            const len = (el.nodeValue || '').length;
+            if (current + len > pos.start) {
+                if (!startNode) {
+                    startNode = el;
+                    startOffset = pos.start - current;
+                }
+                if (current + len > pos.end) {
+                    endNode = el;
+                    endOffset = pos.end - current;
+                    return 'stop';
+                }
+            }
+            current += len;
+        });
+        if (!startNode) {
+            startNode = this.editor;
+            startOffset = this.editor.childNodes.length;
+        }
+        if (!endNode) {
+            endNode = this.editor;
+            endOffset = this.editor.childNodes.length;
+        }
+        // Flip back the selection
+        if (pos.dir == '<-') {
+            [startNode, startOffset, endNode, endOffset] = [
+                endNode,
+                endOffset,
+                startNode,
+                startOffset,
+            ];
+        }
+        {
+            // If nodes not editable, create a text node.
+            const startEl = this.uneditable(startNode);
+            if (startEl) {
+                const node = document.createTextNode('');
+                startEl.parentNode?.insertBefore(node, startEl);
+                startNode = node;
+                startOffset = 0;
+            }
+            const endEl = this.uneditable(endNode);
+            if (endEl) {
+                const node = document.createTextNode('');
+                endEl.parentNode?.insertBefore(node, endEl);
+                endNode = node;
+                endOffset = 0;
+            }
+        }
+        s.setBaseAndExtent(startNode, startOffset, endNode, endOffset);
+        this.editor.normalize(); // collapse empty text nodes
+    }
+    recordHistory() {
+        if (!focus)
+            return;
+        const html = this.editor.innerHTML;
+        const pos = this.save();
+        const lastRecord = this.history[this.at];
+        if (lastRecord) {
+            if (lastRecord.html === html &&
+                lastRecord.pos.start === pos.start &&
+                lastRecord.pos.end === pos.end)
+                return;
+        }
+        this.at++;
+        this.history[this.at] = { html, pos };
+        this.history.splice(this.at + 1);
+        const maxHistory = 300;
+        if (this.at > maxHistory) {
+            this.at = maxHistory;
+            this.history.splice(0, 1);
+        }
+    }
+    destroy() {
+        for (let [type, fn] of this.listeners) {
+            this.editor.removeEventListener(type, fn);
+        }
+    }
+}

package/esm/extension-codejar/src/Decorator.d.ts

@@ -0,0 +1,11 @@
+export interface DecorationInline {
+    startIndex: number;
+    endIndex: number;
+    className: string;
+    title?: string;
+}
+export declare class Decorator {
+    decorationGroups: Record<string, DecorationInline[]>;
+    highlight(code: string): string;
+}
+//# sourceMappingURL=Decorator.d.ts.map

package/esm/extension-codejar/src/Decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decorator.d.ts","sourceRoot":"","sources":["../../../src/extension-codejar/src/Decorator.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,SAAS;IACb,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAM;IAEjE,SAAS,CAAC,IAAI,EAAE,MAAM;CAiDvB"}

package/esm/extension-codejar/src/Decorator.js

@@ -0,0 +1,52 @@
+export class Decorator {
+    constructor() {
+        Object.defineProperty(this, "decorationGroups", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    highlight(code) {
+        const decorations = [];
+        for (const groupName in this.decorationGroups) {
+            const group = this.decorationGroups[groupName];
+            decorations.push(...group);
+        }
+        const cutIndexes = new Set();
+        for (const d of decorations) {
+            cutIndexes.add(d.startIndex);
+            cutIndexes.add(d.endIndex);
+        }
+        cutIndexes.add(0);
+        cutIndexes.add(code.length);
+        const cutIndexesArr = Array.from(cutIndexes);
+        cutIndexesArr.sort((a, b) => a - b);
+        let html = '';
+        let lastIndex = 0;
+        for (const currentIdx of cutIndexesArr) {
+            const text = code.substring(lastIndex, currentIdx);
+            const activeDecors = decorations.filter((d) => lastIndex >= d.startIndex && currentIdx <= d.endIndex);
+            for (const decor of activeDecors) {
+                if (decor.title) {
+                    html += `<span class="${decor.className}" title="${escapeHtml(decor.title || '')}">`;
+                }
+                else {
+                    html += `<span class="${decor.className}">`;
+                }
+            }
+            html += escapeHtml(text);
+            for (const decor of activeDecors) {
+                html += '</span>';
+            }
+            lastIndex = currentIdx;
+        }
+        return html;
+    }
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}

package/esm/extension-codejar/src/ExtensionCodeJar.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from 'prosemirror-model';
+import { AnyExtensionOrReq, type Converter, type CoreEditor, Extension } from '../../editor/src/mod.js';
+export * from './NodeCodeJar.js';
+export interface ExtensionCodeJarConfig {
+    readOnly?: boolean;
+    languageWhitelist?: string[];
+}
+export declare class ExtensionCodeJar extends Extension {
+    protected config: ExtensionCodeJarConfig;
+    name: string;
+    requires: AnyExtensionOrReq[];
+    constructor(config?: ExtensionCodeJarConfig);
+    getConverters(editor: CoreEditor, schema: Schema): Record<string, Converter>;
+}
+//# sourceMappingURL=ExtensionCodeJar.d.ts.map

package/esm/extension-codejar/src/ExtensionCodeJar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionCodeJar.d.ts","sourceRoot":"","sources":["../../../src/extension-codejar/src/ExtensionCodeJar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EACL,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,SAAS,EACV,MAAM,yBAAyB,CAAC;AAIjC,cAAc,kBAAkB,CAAC;AAEjC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,qBAAa,gBAAiB,SAAQ,SAAS;cAId,MAAM,EAAE,sBAAsB;IAHpD,IAAI,SAAc;IAC3B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;gBAEC,MAAM,GAAE,sBAA2B;IAWzD,aAAa,CACpB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;CA+C7B"}