@bhsd/codemirror-mediawiki 2.28.0 → 2.29.0

package/dist/indent.js

@@ -0,0 +1,50 @@
+export const noDetectionLangs = new Set(['plain', 'mediawiki', 'html']);
+/**
+ * 检测文本的缩进方式
+ * @param text 文本内容
+ * @param defaultIndent 默认缩进方式
+ * @param lang 语言
+ */
+export const detectIndent = (text, defaultIndent, lang) => {
+    if (noDetectionLangs.has(lang)) {
+        return defaultIndent;
+    }
+    const lineSpaces = [];
+    let tabLines = 0;
+    for (const line of text.split('\n')) {
+        if (!line.trim()) {
+            continue;
+        }
+        let tabs = 0, spaces = 0;
+        for (const char of line) {
+            if (char === '\t') {
+                tabs++;
+            }
+            else if (char === ' ') {
+                spaces++;
+            }
+            else {
+                break;
+            }
+        }
+        if (tabs && tabs * 8 >= spaces) {
+            tabLines++;
+        }
+        if (spaces > 1 && spaces >= tabs * 2) {
+            lineSpaces.push(spaces);
+        }
+    }
+    const { length } = lineSpaces;
+    if (tabLines > length) {
+        return '\t';
+    }
+    else if (tabLines === length) {
+        return defaultIndent;
+    }
+    for (let i = Math.min(...lineSpaces, 8); i > 2; i--) {
+        if (lineSpaces.every(s => s % i === 0)) {
+            return ' '.repeat(i);
+        }
+    }
+    return '  ';
+};

package/dist/inlay.js

@@ -0,0 +1,68 @@
+import { StateField, StateEffect } from '@codemirror/state';
+import { Decoration, EditorView, WidgetType, ViewPlugin } from '@codemirror/view';
+import { getLSP } from '@bhsd/common';
+import { posToIndex } from './hover';
+class InlayHintWidget extends WidgetType {
+    constructor(label) {
+        super();
+        this.label = label;
+    }
+    toDOM() {
+        const element = document.createElement('span');
+        element.textContent = this.label;
+        element.className = 'cm-inlay-hint';
+        return element;
+    }
+}
+const stateEffect = StateEffect.define(), field = StateField.define({
+    create() {
+        return Decoration.none;
+    },
+    update(deco, { state: { doc }, effects }) {
+        const str = doc.toString();
+        for (const effect of effects) {
+            if (effect.is(stateEffect)) {
+                const { value: { text, inlayHints } } = effect;
+                if (str === text) {
+                    return inlayHints
+                        ? Decoration.set(inlayHints.reverse()
+                            .map(({ position, label }) => [posToIndex(doc, position), label])
+                            .sort(([a], [b]) => a - b)
+                            .map(([index, label]) => Decoration.widget({ widget: new InlayHintWidget(label) }).range(index)))
+                        : Decoration.none;
+                }
+            }
+        }
+        return deco;
+    },
+    provide(f) {
+        return EditorView.decorations.from(f);
+    },
+});
+const updateField = async ({ view, docChanged }) => {
+    if (docChanged) {
+        const text = view.state.doc.toString();
+        view.dispatch({
+            effects: stateEffect.of({
+                text,
+                inlayHints: await getLSP(view)?.provideInlayHints(text),
+            }),
+        });
+    }
+};
+export default (cm) => [
+    field,
+    ViewPlugin.fromClass(class {
+        constructor(view) {
+            const timer = setInterval(() => {
+                if (getLSP(view, false, cm.getWikiConfig)) {
+                    clearInterval(timer);
+                    void updateField({ view, docChanged: true });
+                }
+            }, 100);
+        }
+        update(update) {
+            void updateField(update);
+        }
+    }),
+];

package/dist/javascript.js

@@ -0,0 +1,5 @@
+import { javascript as js, javascriptLanguage, scopeCompletionSource } from '@codemirror/lang-javascript';
+export default () => [
+    js(),
+    javascriptLanguage.data.of({ autocomplete: scopeCompletionSource(globalThis) }),
+];

package/dist/keybindings.js

@@ -0,0 +1,35 @@
+export const keybindings = [
+    { key: 'Ctrl-8', pre: '<blockquote>', post: '</blockquote>', desc: 'blockquote' },
+    { key: 'Mod-.', pre: '<sup>', post: '</sup>', desc: 'sup' },
+    { key: 'Mod-,', pre: '<sub>', post: '</sub>', desc: 'sub' },
+    { key: 'Mod-Shift-6', pre: '<code>', post: '</code>', desc: 'code' },
+    { key: 'Ctrl-Shift-5', pre: '<s>', post: '</s>', desc: 's' },
+    { key: 'Mod-u', pre: '<u>', post: '</u>', desc: 'u' },
+    { key: 'Mod-k', pre: '[[', post: ']]', desc: 'link' },
+    { key: 'Mod-i', pre: "''", post: "''", desc: 'italic' },
+    { key: 'Mod-b', pre: "'''", post: "'''", desc: 'bold' },
+    { key: 'Mod-Shift-k', pre: '<ref>', post: '</ref>', desc: 'ref' },
+    { key: 'Mod-/', pre: '<!-- ', post: ' -->', desc: 'comment' },
+    { key: 'Ctrl-0', splitlines: true, desc: 'heading 0' },
+    ...new Array(6).fill(0).map((_, i) => ({
+        key: `Ctrl-${i + 1}`,
+        pre: `${'='.repeat(i + 1)} `,
+        post: ` ${'='.repeat(i + 1)}`,
+        splitlines: true,
+        desc: `heading ${i + 1}`,
+    })),
+    { key: 'Ctrl-7', pre: ' ', splitlines: true, desc: 'pre' },
+];
+/**
+ * 将文本各行包裹在指定的前后缀中
+ * @param text 跨行文本
+ * @param pre 前缀
+ * @param post 后缀
+ */
+export const encapsulateLines = (text, pre, post) => {
+    const lines = text.split('\n');
+    return lines.map(line => {
+        const str = (/^(={1,6})(.+)\1\s*$/u.exec(line)?.[2] ?? line).trim();
+        return pre === ' ' || lines.length === 1 || line.trim() ? pre + str + post : str;
+    }).join('\n');
+};

package/dist/keymap.js

@@ -0,0 +1,36 @@
+import { keymap } from '@codemirror/view';
+import { EditorSelection } from '@codemirror/state';
+import { keybindings, encapsulateLines } from './keybindings';
+/**
+ * 生成keymap
+ * @param opt 快捷键设置
+ * @param opt.key 键名
+ * @param opt.pre 前缀
+ * @param opt.post 后缀
+ * @param opt.splitlines 是否分行
+ */
+const getKeymap = ({ key, pre = '', post = '', splitlines }) => ({
+    key,
+    run(view) {
+        const { state } = view;
+        view.dispatch(state.changeByRange(({ from, to }) => {
+            if (splitlines) {
+                const start = state.doc.lineAt(from).from, end = state.doc.lineAt(to).to, insert = encapsulateLines(state.sliceDoc(start, end), pre, post);
+                return {
+                    range: EditorSelection.range(start, start + insert.length),
+                    changes: { from: start, to: end, insert },
+                };
+            }
+            const insert = pre + state.sliceDoc(from, to) + post, head = from + insert.length;
+            return {
+                range: from === to
+                    ? EditorSelection.range(from + pre.length, head - post.length)
+                    : EditorSelection.range(head, head),
+                changes: { from, to, insert },
+            };
+        }));
+        return true;
+    },
+    preventDefault: true,
+});
+export default keymap.of(keybindings.map(getKeymap));

package/dist/linter.d.ts

@@ -3,7 +3,7 @@ import type { Linter } from 'eslint';
 import type { Warning } from 'stylelint';
 import type { Diagnostic } from 'luacheck-browserify';
 export type Option = Record<string, unknown> | null | undefined;
-export type LiveOption = (runtime?: true) => Option;
+export type LiveOption = (runtime?: boolean) => Option;
 declare type getLinter<T> = () => (text: string) => T;
 declare type asyncLinter<T, S = Record<string, unknown>> = ((text: string, config?: Option) => T) & {
     config?: S;
@@ -19,25 +19,26 @@ declare interface MixedDiagnostic extends Omit<DiagnosticBase, 'range'> {
     from?: number;
     to?: number;
 }
+declare interface JsonError {
+    message: string;
+    severity: 'error';
+    line: string | undefined;
+    column: string | undefined;
+    position: string | undefined;
+}
 /**
  * 获取 Wikitext LSP
  * @param opt 选项
  * @param obj 对象
  */
 export declare const getWikiLinter: getAsyncLinter<Promise<MixedDiagnostic[]>, Option, object>;
+export declare const jsConfig: Linter.Config<Linter.RulesRecord, Linter.RulesRecord>;
 /** 获取 ESLint */
 export declare const getJsLinter: getAsyncLinter<Linter.LintMessage[]>;
 /** 获取 Stylelint */
 export declare const getCssLinter: getAsyncLinter<Promise<Warning[]>>;
 /** 获取 Luacheck */
 export declare const getLuaLinter: getAsyncLinter<Promise<Diagnostic[]>>;
-declare interface JsonError {
-    message: string;
-    severity: 'error';
-    line: string | undefined;
-    column: string | undefined;
-    position: string | undefined;
-}
 /** JSON.parse */
 export declare const getJsonLinter: getLinter<JsonError[]>;
 export {};

package/dist/linter.js

@@ -0,0 +1,134 @@
+/* eslint-disable unicorn/no-unreadable-iife */
+import { loadScript, getWikiparse, getLSP, sanitizeInlineStyle } from '@bhsd/common';
+import { styleLint } from '@bhsd/common/dist/stylelint';
+/**
+ * 计算位置
+ * @param range 范围
+ * @param line 行号
+ * @param column 列号
+ */
+const offsetAt = (range, line, column) => {
+    if (line === -2) {
+        return range[0];
+    }
+    return line === 0 ? range[1] : range[0] + column;
+};
+/**
+ * 获取 Wikitext LSP
+ * @param opt 选项
+ * @param obj 对象
+ */
+export const getWikiLinter = async (opt, obj) => {
+    await getWikiparse(opt?.['getConfig'], opt?.['i18n']);
+    const lsp = getLSP(obj, opt?.['include']);
+    return async (text, config) => {
+        const diagnostics = (await lsp.provideDiagnostics(text)).filter(({ code, severity }) => Number(config?.[code] ?? 2) > Number(severity === 2)), tokens = 'findStyleTokens' in lsp && config?.['invalid-css'] !== '0' ? await lsp.findStyleTokens() : [];
+        if (tokens.length === 0) {
+            return diagnostics;
+        }
+        const cssLint = await getCssLinter();
+        return [
+            ...diagnostics,
+            ...(await cssLint(tokens.map(({ childNodes, type, tag }, i) => `${type === 'ext-attr' ? 'div' : tag}#${i}{\n${sanitizeInlineStyle(childNodes[1].childNodes[0].data)
+                .replace(/\n/gu, ' ')}\n}`).join('\n'))).map(({ line, column, endLine, endColumn, rule, severity, text: message }) => {
+                const i = Math.ceil(line / 3), { range } = tokens[i - 1].childNodes[1].childNodes[0], from = offsetAt(range, line - 3 * i, column - 1);
+                return {
+                    from,
+                    to: endLine === undefined ? from : offsetAt(range, endLine - 3 * i, endColumn - 1),
+                    severity: severity === 'error' ? 1 : 2,
+                    source: 'Stylelint',
+                    code: rule,
+                    message,
+                };
+            }),
+        ];
+    };
+};
+export const jsConfig = /* #__PURE__ */ (() => ({
+    env: { browser: true, es2024: true, jquery: true },
+    globals: {
+        mw: 'readonly',
+        mediaWiki: 'readonly',
+        OO: 'readonly',
+        addOnloadHook: 'readonly',
+        importScriptURI: 'readonly',
+        importScript: 'readonly',
+        importStylesheet: 'readonly',
+        importStylesheetURI: 'readonly',
+    },
+}))();
+/** 获取 ESLint */
+export const getJsLinter = async () => {
+    await loadScript('npm/@bhsd/eslint-browserify', 'eslint');
+    /** @see https://www.npmjs.com/package/@codemirror/lang-javascript */
+    const esLinter = new eslint.Linter(), conf = {
+        env: { browser: true, es2024: true },
+        parserOptions: { ecmaVersion: 15, sourceType: 'module' },
+    }, recommended = {};
+    for (const [name, { meta }] of esLinter.getRules()) {
+        if (meta?.docs?.recommended) {
+            recommended[name] = 2;
+        }
+    }
+    const linter = (text, opt) => {
+        const config = { ...conf, ...opt };
+        if (!('rules' in config)
+            || config.extends === 'eslint:recommended'
+            || Array.isArray(config.extends) && config.extends.includes('eslint:recommended')) {
+            config.rules = { ...recommended, ...config.rules };
+        }
+        delete config.extends;
+        linter.config = config;
+        return esLinter.verify(text, config);
+    };
+    linter.fixer = (code, rule) => esLinter.verifyAndFix(code, rule ? { ...linter.config, rules: { [rule]: linter.config.rules?.[rule] ?? 2 } } : linter.config).output;
+    return linter;
+};
+/** 获取 Stylelint */
+export const getCssLinter = async () => {
+    await loadScript('npm/@bhsd/stylelint-browserify', 'stylelint');
+    const linter = async (code, opt) => {
+        const warnings = await styleLint(stylelint, code, opt);
+        if (opt && 'rules' in opt) {
+            linter.config = opt;
+        }
+        return warnings;
+    };
+    linter.fixer = (code, rule) => {
+        if (!linter.config) {
+            throw new Error('Fixer unavailable!');
+        }
+        return styleLint(stylelint, code, rule ? { extends: [], rules: { [rule]: linter.config.rules?.[rule] ?? true } } : linter.config, true);
+    };
+    return linter;
+};
+/** 获取 Luacheck */
+export const getLuaLinter = async () => {
+    await loadScript('npm/luacheck-browserify', 'luacheck');
+    // eslint-disable-next-line @typescript-eslint/await-thenable
+    const luachecker = await luacheck(undefined);
+    return async (text) => (await luachecker.queue(text)).filter(({ severity }) => severity);
+};
+/** JSON.parse */
+export const getJsonLinter = () => str => {
+    try {
+        if (str.trim()) {
+            JSON.parse(str);
+        }
+    }
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            const { message } = e, line = /\bline (\d+)/u.exec(message)?.[1], column = /\bcolumn (\d+)/u.exec(message)?.[1], position = /\bposition (\d+)/u.exec(message)?.[1];
+            return [
+                {
+                    message,
+                    severity: 'error',
+                    line,
+                    column,
+                    position,
+                },
+            ];
+        }
+    }
+    return [];
+};