@bhsd/codemirror-mediawiki 2.28.2 → 2.29.0

package/dist/openLinks.js

@@ -0,0 +1,97 @@
+import { EditorView } from '@codemirror/view';
+import { ensureSyntaxTree } from '@codemirror/language';
+import { tokens } from './config';
+import { hasTag } from './mediawiki';
+const { vendor, userAgent, maxTouchPoints, platform } = navigator;
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+export const isMac = vendor?.includes('Apple Computer')
+    && (userAgent.includes('Mobile/') || maxTouchPoints > 2)
+    || platform.includes('Mac');
+const modKey = isMac ? 'metaKey' : 'ctrlKey', key = isMac ? 'Meta' : 'Control', tags = ['extLinkProtocol', 'extLink', 'freeExtLinkProtocol', 'freeExtLink', 'magicLink', 'pageName'], links = ['extlink-protocol', 'extlink', 'free-extlink-protocol', 'free-extlink', 'magic-link'], wikiLinks = [
+    'template-name',
+    'link-pagename',
+    'parserfunction.cm-mw-pagename',
+    'exttag-attribute-value.cm-mw-pagename',
+    'file-text.cm-mw-pagename',
+];
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+globalThis.document?.addEventListener('keydown', e => {
+    if (e.key === key) {
+        for (const ele of document.querySelectorAll('.cm-content')) {
+            ele.style.setProperty('--codemirror-cursor', 'pointer');
+        }
+    }
+});
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+globalThis.document?.addEventListener('keyup', e => {
+    if (e.key === key) {
+        for (const ele of document.querySelectorAll('.cm-content')) {
+            ele.style.removeProperty('--codemirror-cursor');
+        }
+    }
+});
+const wrapURL = (url) => url.startsWith('//') ? location.protocol + url : url;
+export const mouseEventListener = (e, view, langConfig) => {
+    if (!e[modKey]
+        || !(e.target instanceof Element && getComputedStyle(e.target).textDecorationLine === 'underline')) {
+        return undefined;
+    }
+    const position = view.posAtCoords(e);
+    if (!position) {
+        return undefined;
+    }
+    const { state } = view, tree = ensureSyntaxTree(state, position);
+    if (!tree) {
+        return undefined;
+    }
+    let node = tree.resolve(position, -1);
+    if (node.name.includes(tokens.linkToSection)) {
+        node = node.prevSibling;
+    }
+    else if (!hasTag(new Set(node.name.split('_')), tags)) {
+        node = tree.resolve(position, 1);
+    }
+    const { name, from, to } = node;
+    if (name.includes(tokens.pageName) && typeof langConfig?.titleParser === 'function') {
+        return langConfig.titleParser(state, node);
+    }
+    else if (name.includes('-extlink-protocol')) {
+        return wrapURL(state.sliceDoc(from, node.nextSibling.to));
+    }
+    else if (/-extlink(?:_|$)/u.test(name)) {
+        return wrapURL(state.sliceDoc(node.prevSibling.from, to));
+    }
+    else if (name.includes(tokens.magicLink)) {
+        const link = state.sliceDoc(from, to);
+        if (link.startsWith('RFC')) {
+            return `https://datatracker.ietf.org/doc/html/rfc${link.slice(3).trim()}`;
+        }
+        else if (link.startsWith('PMID')) {
+            return `https://pubmed.ncbi.nlm.nih.gov/${link.slice(4).trim()}`;
+        }
+        else if (typeof langConfig?.isbnParser === 'function') {
+            return langConfig.isbnParser(link);
+        }
+    }
+    return undefined;
+};
+export default ({ langConfig }) => [
+    EditorView.domEventHandlers({
+        mousedown(e, view) {
+            if (e.button !== 0) {
+                return undefined;
+            }
+            const url = mouseEventListener(e, view, langConfig);
+            if (url) {
+                open(url, '_blank');
+                return true;
+            }
+            return undefined;
+        },
+    }),
+    EditorView.theme({
+        [[...links, ...langConfig?.titleParser ? wikiLinks : []].map(type => `.cm-mw-${type}`).join()]: {
+            cursor: 'var(--codemirror-cursor)',
+        },
+    }),
+];

package/dist/ref.js

@@ -0,0 +1,85 @@
+import { hoverTooltip, EditorView } from '@codemirror/view';
+import { ensureSyntaxTree } from '@codemirror/language';
+import { getLSP } from '@bhsd/common';
+import { getTag } from './matchTag';
+import { tokens } from './config';
+import { indexToPos, posToIndex } from './hover';
+const trees = new WeakMap();
+/**
+ * 获取节点内容
+ * @param state
+ * @param node 语法树节点
+ * @param node.from 起始位置
+ * @param node.to 结束位置
+ */
+const getName = (state, { from, to }) => state.sliceDoc(from, to).trim();
+export default (cm) => [
+    hoverTooltip(async (view, pos, side) => {
+        const { state } = view, node = ensureSyntaxTree(state, pos)?.resolve(pos, side);
+        if (node && /-exttag-(?!bracket)/u.test(node.name)) {
+            const tag = getTag(state, node);
+            if (!tag) {
+                return null;
+            }
+            const { name, selfClosing, first, last, to } = tag;
+            if (name === 'ref' && selfClosing) {
+                let prevSibling = last, nextSibling = null;
+                while (prevSibling && prevSibling.from > first.to) {
+                    const key = getName(state, prevSibling);
+                    if (prevSibling.name.split('_').includes(tokens.extTagAttribute)
+                        && /(?:^|\s)name(?:$|[\s=])/iu.test(key)) {
+                        if (/(?:^|\s)name\s*=/iu.test(key)) {
+                            ({ nextSibling } = prevSibling);
+                        }
+                        break;
+                    }
+                    ({ prevSibling } = prevSibling);
+                }
+                if (nextSibling?.name.includes(tokens.extTagAttributeValue)) {
+                    let target = getName(state, nextSibling);
+                    const quote = target.charAt(0);
+                    if (quote === '"' || quote === "'") {
+                        target = target.slice(1, target.slice(-1) === quote ? -1 : undefined).trim();
+                    }
+                    if (target) {
+                        const { doc } = state, ref = await getLSP(view, false, cm.getWikiConfig)
+                            ?.provideDefinition(doc.toString(), indexToPos(doc, first.to));
+                        return {
+                            pos,
+                            end: to,
+                            above: true,
+                            create() {
+                                const dom = document.createElement('div');
+                                dom.className = 'cm-tooltip-ref';
+                                dom.style.font = getComputedStyle(view.contentDOM).font;
+                                if (ref) {
+                                    const { range: { start, end } } = ref[0], anchor = posToIndex(doc, start), head = posToIndex(doc, end);
+                                    dom.textContent = state.sliceDoc(anchor, head);
+                                    dom.addEventListener('click', () => {
+                                        view.dispatch({
+                                            selection: { anchor, head },
+                                            scrollIntoView: true,
+                                        });
+                                    });
+                                }
+                                else {
+                                    dom.textContent = state.phrase('No definition found');
+                                }
+                                return { dom };
+                            },
+                        };
+                    }
+                }
+            }
+        }
+        return null;
+    }),
+    EditorView.updateListener.of(({ view, docChanged }) => {
+        if (docChanged) {
+            const tree = trees.get(view);
+            if (tree) {
+                tree.docChanged = true;
+            }
+        }
+    }),
+];

package/dist/signature.js

@@ -0,0 +1,69 @@
+import { EditorView, showTooltip } from '@codemirror/view';
+import { StateField, StateEffect } from '@codemirror/state';
+import { getLSP } from '@bhsd/common';
+import { indexToPos, createTooltipView } from './hover';
+const stateEffect = StateEffect.define(), field = StateField.define({
+    create() {
+        return undefined;
+    },
+    update(oldValue, { state: { doc, selection: { main: { head } } }, effects }) {
+        const text = doc.toString();
+        for (const effect of effects) {
+            if (effect.is(stateEffect)) {
+                const { value } = effect;
+                if (head === value.cursor && text === value.text) {
+                    return value;
+                }
+            }
+        }
+        return oldValue;
+    },
+});
+export default (cm) => [
+    field,
+    EditorView.updateListener.of(({ view, state, docChanged, selectionSet }) => {
+        if (docChanged || selectionSet && state.field(field)?.signatureHelp?.signatures.length) {
+            const { doc, selection: { main } } = state, { head: cursor } = main, text = doc.toString();
+            if (!main.empty) {
+                view.dispatch({
+                    effects: stateEffect.of({ text, cursor }),
+                });
+                return;
+            }
+            (async () => {
+                view.dispatch({
+                    effects: stateEffect.of({
+                        text,
+                        cursor,
+                        signatureHelp: await getLSP(view, false, cm.getWikiConfig)
+                            ?.provideSignatureHelp(text, indexToPos(doc, cursor)),
+                    }),
+                });
+            })();
+        }
+    }),
+    showTooltip.from(field, (value) => {
+        if (!value) {
+            return null;
+        }
+        const { cursor, signatureHelp } = value;
+        if (!signatureHelp || signatureHelp.signatures.length === 0) {
+            return null;
+        }
+        const { signatures, activeParameter: active } = signatureHelp;
+        return {
+            pos: cursor,
+            above: true,
+            create(view) {
+                return createTooltipView(view, signatures.map(({ label, parameters, activeParameter = active }) => {
+                    if (activeParameter < 0 || activeParameter >= parameters.length) {
+                        return label;
+                    }
+                    const colon = label.indexOf(':'), parts = label.slice(colon + 1, -2).split('|');
+                    parts[activeParameter] = `<b>${parts[activeParameter]}</b>`;
+                    return `${label.slice(0, colon)}:${parts.join('|')}}}`;
+                }).join('<br>'));
+            },
+        };
+    }),
+];

package/dist/static.js

@@ -0,0 +1,46 @@
+export const tagModes = {
+    onlyinclude: 'mediawiki',
+    includeonly: 'mediawiki',
+    noinclude: 'mediawiki',
+    pre: 'text/pre',
+    nowiki: 'text/nowiki',
+    indicator: 'mediawiki',
+    poem: 'mediawiki',
+    ref: 'mediawiki',
+    references: 'text/references',
+    gallery: 'text/gallery',
+    poll: 'mediawiki',
+    tabs: 'mediawiki',
+    tab: 'mediawiki',
+    choose: 'text/choose',
+    option: 'mediawiki',
+    combobox: 'text/combobox',
+    combooption: 'mediawiki',
+    inputbox: 'text/inputbox',
+    templatedata: 'json',
+    mapframe: 'json',
+    maplink: 'json',
+    graph: 'json',
+};
+export const getStaticMwConfig = ({ variable, parserFunction: [p0, p1, ...p2], protocol, nsid, functionHook, variants, redirection, ext, doubleUnderscore: [d0, d1, d2, d3], img, }, modes) => ({
+    tags: Object.fromEntries(ext.map(s => [s, true])),
+    tagModes: modes,
+    doubleUnderscore: [
+        Object.fromEntries((d2 && d0.length === 0 ? Object.keys(d2) : d0).map(s => [`__${s}__`, true])),
+        Object.fromEntries((d3 && d1.length === 0 ? Object.keys(d3) : d1).map(s => [`__${s}__`, true])),
+    ],
+    functionHooks: functionHook,
+    variableIDs: variable,
+    functionSynonyms: [
+        {
+            ...p0,
+            ...Object.fromEntries(p2.flat().map(s => [s, s])),
+        },
+        Array.isArray(p1) ? Object.fromEntries(p1.map(s => [s, s.toLowerCase()])) : { ...p1 },
+    ],
+    urlProtocols: `${protocol}|//`,
+    nsid,
+    img: Object.fromEntries(Object.entries(img).map(([k, v]) => [k, `img_${v}`])),
+    variants,
+    redirection,
+});

package/dist/statusBar.js

@@ -0,0 +1,138 @@
+import { showPanel } from '@codemirror/view';
+import { nextDiagnostic, setDiagnosticsEffect } from '@codemirror/lint';
+function getLintMarker(view, severity, menu) {
+    const marker = document.createElement('div'), icon = document.createElement('div');
+    marker.className = `cm-status-${severity}`;
+    if (severity === 'fix') {
+        icon.className = 'cm-status-fix-disabled';
+        marker.title = 'Fix all';
+        marker.append(icon);
+        if (menu) {
+            marker.addEventListener('click', ({ clientX, clientY }) => {
+                if (icon.className === 'cm-status-fix-enabled') {
+                    const { bottom, left } = view.dom.getBoundingClientRect();
+                    menu.style.bottom = `${bottom - clientY + 5}px`;
+                    menu.style.left = `${clientX - 20 - left}px`;
+                    menu.style.display = 'block';
+                    menu.focus();
+                }
+            });
+        }
+    }
+    else {
+        icon.className = `cm-lint-marker-${severity}`;
+        const count = document.createElement('div');
+        count.textContent = '0';
+        marker.append(icon, count);
+        marker.addEventListener('click', () => {
+            if (marker.parentElement?.classList.contains('cm-status-worker-enabled')) {
+                nextDiagnostic(view);
+                view.focus();
+            }
+        });
+    }
+    return marker;
+}
+const updateDiagnosticsCount = (diagnostics, s, marker) => {
+    marker.lastChild.textContent = String(diagnostics.filter(({ severity }) => severity === s).length);
+};
+const hasFix = (diagnostic) => diagnostic.actions?.some(({ name }) => name === 'fix');
+const updateDiagnosticMessage = (view, allDiagnostics, main, msg, menu) => {
+    const diagnostics = allDiagnostics.filter(({ from, to }) => from <= main.to && to >= main.from), diagnostic = diagnostics.find(({ from, to }) => from <= main.head && to >= main.head) ?? diagnostics[0];
+    if (diagnostic) {
+        msg.textContent = diagnostic.message;
+        if (diagnostic.actions) {
+            msg.append(...diagnostic.actions.map(({ name, apply }) => {
+                const button = document.createElement('button');
+                button.type = 'button';
+                button.className = 'cm-diagnosticAction';
+                button.textContent = name;
+                button.addEventListener('click', e => {
+                    e.preventDefault();
+                    apply(view, diagnostic.from, diagnostic.to);
+                });
+                return button;
+            }));
+        }
+    }
+    else {
+        msg.textContent = '';
+    }
+    if (menu) {
+        menu.replaceChildren(...[
+            ...new Set(diagnostics.filter(hasFix)
+                .map(({ message }) => / \(([^()]+)\)$/u.exec(message)?.[1])
+                .filter(Boolean)),
+        ].map(rule => {
+            const option = document.createElement('div');
+            option.textContent = `Fix all ${rule} problems`;
+            option.dataset['rule'] = rule;
+            return option;
+        }), menu.lastChild);
+    }
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export default (fixer) => showPanel.of(view => {
+    let diagnostics = [], menu;
+    if (fixer) {
+        const optionAll = document.createElement('div');
+        optionAll.textContent = 'Fix all auto-fixable problems';
+        menu = document.createElement('div');
+        menu.className = 'cm-status-fix-menu';
+        menu.tabIndex = -1;
+        menu.append(optionAll);
+        menu.addEventListener('click', ({ target }) => {
+            if (target === menu) {
+                return;
+            }
+            (async () => {
+                const { doc } = view.state, output = await fixer(doc, target.dataset['rule']);
+                if (output !== doc.toString()) {
+                    view.dispatch({
+                        changes: { from: 0, to: doc.length, insert: output },
+                    });
+                }
+                view.focus();
+            })();
+        });
+        menu.addEventListener('focusout', () => {
+            menu.style.display = 'none';
+        });
+        view.dom.append(menu);
+    }
+    const dom = document.createElement('div'), worker = document.createElement('div'), message = document.createElement('div'), position = document.createElement('div'), error = getLintMarker(view, 'error'), warning = getLintMarker(view, 'warning'), fix = getLintMarker(view, 'fix', menu);
+    worker.className = 'cm-status-worker';
+    worker.append(error, warning, fix);
+    message.className = 'cm-status-message';
+    position.className = 'cm-status-line';
+    position.textContent = '0:0';
+    dom.className = 'cm-panel cm-panel-status';
+    dom.append(worker, message, position);
+    return {
+        dom,
+        update({ state: { selection: { main }, doc }, transactions, docChanged, selectionSet }) {
+            for (const tr of transactions) {
+                for (const effect of tr.effects) {
+                    if (effect.is(setDiagnosticsEffect)) {
+                        diagnostics = effect.value;
+                        const fixable = Boolean(fixer) && diagnostics.some(hasFix), { classList } = fix.firstChild;
+                        classList.toggle('cm-status-fix-enabled', fixable);
+                        classList.toggle('cm-status-fix-disabled', !fixable);
+                        worker.classList.toggle('cm-status-worker-enabled', diagnostics.length > 0);
+                        updateDiagnosticsCount(diagnostics, 'error', error);
+                        updateDiagnosticsCount(diagnostics, 'warning', warning);
+                        updateDiagnosticMessage(view, diagnostics, main, message, menu);
+                    }
+                }
+            }
+            if (docChanged || selectionSet) {
+                updateDiagnosticMessage(view, diagnostics, main, message, menu);
+                const { number, from } = doc.lineAt(main.head);
+                position.textContent = `${number}:${main.head - from}`;
+                if (!main.empty) {
+                    position.textContent += ` (${main.to - main.from})`;
+                }
+            }
+        },
+    };
+});