@bhsd/codemirror-mediawiki 3.0.3 → 3.2.0

package/dist/index.js

@@ -0,0 +1,340 @@
+import { keymap, highlightSpecialChars, highlightActiveLine, highlightWhitespace, highlightTrailingWhitespace, scrollPastEnd, drawSelection, rectangularSelection, crosshairCursor, } from '@codemirror/view';
+import { EditorState } from '@codemirror/state';
+import { highlightSelectionMatches } from '@codemirror/search';
+import { closeBrackets, autocompletion, acceptCompletion, completionKeymap, startCompletion, } from '@codemirror/autocomplete';
+import { json } from '@codemirror/lang-json';
+import { autoCloseTags } from '@codemirror/lang-html';
+import { getLSP } from '@bhsd/browser';
+import { colorPicker as cssColorPicker, colorPickerTheme, makeColorPicker } from '@bhsd/codemirror-css-color-picker';
+import colorPicker, { discoverColors } from './color';
+import { mediawiki } from './mediawiki';
+import escape from './escape';
+import codeFolding, { mediaWikiFold, foldHandler } from './fold';
+import tagMatchingState from './matchTag';
+import refHover from './ref';
+import magicWordHover from './hover';
+import signatureHelp from './signature';
+import inlayHints from './inlay';
+import { getWikiLintSource, getJsLintSource, getCssLintSource, getJsonLintSource, getLuaLintSource, getVueLintSource, getHTMLLintSource, } from './lintsource';
+import openLinks from './openLinks';
+import { tagModes, getStaticMwConfig } from './static';
+import bidiIsolation from './bidi';
+import toolKeymap from './keymap';
+import bracketMatching from './matchBrackets';
+import statusBar from './statusBar';
+import { detectIndent } from './indent';
+import javascript from './javascript';
+import css from './css';
+import lua from './lua';
+import vue from './vue';
+import html from './html';
+import { CodeMirror6, avail, languages, linterRegistry, destroyListeners, plain, optionalFunctions } from './codemirror';
+export { CodeMirror6 };
+/**
+ * 注册通用扩展
+ * @param name 扩展名
+ * @param ext 扩展
+ */
+const registerExtension = (name, ext) => {
+    avail[name] ??= [];
+    const addon = avail[name];
+    addon[0] = ext;
+};
+/** Register the `highlightSpecialChars` extension */
+export const registerHighlightSpecialChars = () => {
+    registerExtension('highlightSpecialChars', highlightSpecialChars);
+};
+/** Register the `highlightActiveLine` extension */
+export const registerHighlightActiveLine = () => {
+    registerExtension('highlightActiveLine', highlightActiveLine);
+};
+/** Register the `highlightWhitespace` extension */
+export const registerHighlightWhitespace = () => {
+    registerExtension('highlightWhitespace', highlightWhitespace);
+};
+/** Register the `highlightTrailingWhitespace` extension */
+export const registerHighlightTrailingWhitespace = () => {
+    registerExtension('highlightTrailingWhitespace', highlightTrailingWhitespace);
+};
+/** Register the `highlightSelectionMatches` extension */
+export const registerHighlightSelectionMatches = () => {
+    registerExtension('highlightSelectionMatches', highlightSelectionMatches);
+};
+/** Register the `bracketMatching` extension */
+export const registerBracketMatching = () => {
+    registerExtension('bracketMatching', ([config, e = []] = []) => [
+        bracketMatching(config),
+        e,
+    ]);
+};
+/** Register the `closeBrackets` extension */
+export const registerCloseBrackets = () => {
+    registerExtension('closeBrackets', (e = []) => [closeBrackets(), e]);
+};
+/** Register the `scrollPastEnd` extension */
+export const registerScrollPastEnd = () => {
+    registerExtension('scrollPastEnd', scrollPastEnd);
+};
+/** Register the `allowMultipleSelections` extension */
+export const registerAllowMultipleSelections = () => {
+    registerExtension('allowMultipleSelections', () => [
+        EditorState.allowMultipleSelections.of(true),
+        drawSelection(),
+        rectangularSelection(),
+        crosshairCursor(),
+    ]);
+};
+/** Register the `autocompletion` extension */
+export const registerAutocompletion = () => {
+    registerExtension('autocompletion', () => [
+        autocompletion({ defaultKeymap: false }),
+        keymap.of([
+            ...completionKeymap.filter(({ run }) => run !== startCompletion),
+            { key: 'Shift-Enter', run: startCompletion },
+            { key: 'Tab', run: acceptCompletion },
+        ]),
+    ]);
+};
+/** Register the `codeFolding` extension */
+export const registerCodeFolding = () => {
+    registerExtension('codeFolding', codeFolding);
+};
+/** Register the `colorPicker` extension */
+export const registerColorPicker = () => {
+    registerExtension('colorPicker', colorPicker);
+};
+/** 注册所有通用扩展（除`colorPicker`） */
+const registerExtensions = () => {
+    highlightSpecialChars();
+    registerHighlightActiveLine();
+    registerHighlightWhitespace();
+    registerHighlightTrailingWhitespace();
+    registerHighlightSelectionMatches();
+    registerBracketMatching();
+    registerCloseBrackets();
+    registerScrollPastEnd();
+    registerAllowMultipleSelections();
+    registerAutocompletion();
+    registerCodeFolding();
+};
+/** Register all common extensions */
+export const registerCommonExtensions = () => {
+    registerExtensions();
+    registerColorPicker();
+};
+function mediawikiOnly(ext) {
+    return typeof ext === 'function'
+        ? [(enable, cm) => enable ? ext(cm) : [], { mediawiki: true }]
+        : [(e = []) => e, { mediawiki: ext }];
+}
+/**
+ * 注册特定语言的扩展
+ * @param lang 语言
+ * @param name 扩展名
+ * @param ext 扩展
+ */
+const registerLangExtension = (lang, name, ext) => {
+    avail[name] ??= [() => []];
+    const addon = avail[name];
+    addon[1] ??= {};
+    addon[1][lang] = ext;
+};
+/** Register MediaWiki language support */
+export const registerMediaWiki = () => {
+    registerCommonExtensions();
+    registerMediaWikiCore();
+    registerOpenLinks();
+    registerEscape();
+    registerRefHover();
+    registerHover();
+    registerSignatureHelp();
+    registerInlayHints();
+    registerColorPickerForMediaWiki();
+    registerBracketMatchingForMediaWiki();
+    registerCodeFoldingForMediaWiki();
+};
+/**
+ * 注册MediaWiki专用扩展
+ * @param name 扩展名
+ * @param ext 扩展
+ */
+const registerExtensionForMediaWiki = (name, ext) => {
+    avail[name] ??= mediawikiOnly(ext);
+};
+/** Register the `openLinks` extension */
+export const registerOpenLinks = () => {
+    registerExtensionForMediaWiki('openLinks', openLinks);
+};
+/** Register the `escape` extension */
+export const registerEscape = () => {
+    registerExtensionForMediaWiki('escape', escape);
+};
+/** Register the `refHover` extension */
+export const registerRefHover = () => {
+    registerExtensionForMediaWiki('refHover', refHover);
+};
+/** Register the `hover` extension */
+export const registerHover = () => {
+    registerExtensionForMediaWiki('hover', magicWordHover);
+};
+/** Register the `signatureHelp` extension */
+export const registerSignatureHelp = () => {
+    registerExtensionForMediaWiki('signatureHelp', signatureHelp);
+};
+/** Register the `inlayHints` extension */
+export const registerInlayHints = () => {
+    registerExtensionForMediaWiki('inlayHints', inlayHints);
+};
+/** Register the `colorPicker` extension for MediaWiki */
+export const registerColorPickerForMediaWiki = () => {
+    registerLangExtension('mediawiki', 'colorPicker', [
+        [makeColorPicker({ discoverColors }), colorPickerTheme],
+        { marginLeft: '0.6ch' },
+    ]);
+};
+/** Register the `bracketMatching` extension for MediaWiki */
+export const registerBracketMatchingForMediaWiki = () => {
+    registerLangExtension('mediawiki', 'bracketMatching', [
+        { brackets: '()[]{}（）【】［］｛｝' },
+        tagMatchingState,
+    ]);
+};
+/** Register the `codeFolding` extension for MediaWiki */
+export const registerCodeFoldingForMediaWiki = () => {
+    registerLangExtension('mediawiki', 'codeFolding', mediaWikiFold);
+    optionalFunctions.foldHandler = foldHandler;
+};
+/**
+ * 注册LintSource
+ * @param lang 语言
+ * @param lintSource
+ */
+const registerLintSource = (lang, lintSource) => {
+    linterRegistry[lang] = lintSource;
+    optionalFunctions.statusBar = statusBar;
+};
+/** Register MediaWiki core language support */
+export const registerMediaWikiCore = () => {
+    CodeMirror6.getMwConfig = (config) => getStaticMwConfig(config, tagModes);
+    languages['mediawiki'] = (config) => [
+        mediawiki(config),
+        plain(),
+        bidiIsolation,
+        toolKeymap,
+    ];
+    registerLintSource('mediawiki', getWikiLintSource);
+    destroyListeners.push(view => getLSP(view)?.destroy());
+};
+/** Register mixed MediaWiki-HTML language support */
+export const registerHTML = () => {
+    registerCommonExtensions();
+    registerHTMLCore();
+    registerCloseBracketsForHTML();
+    registerColorPickerForHTML();
+};
+/** Register the `closeBrackets` extension for mixed MediaWiki-HTML */
+export const registerCloseBracketsForHTML = () => {
+    registerLangExtension('html', 'closeBrackets', autoCloseTags);
+};
+/** Register the `colorPicker` extension for mixed MediaWiki-HTML */
+export const registerColorPickerForHTML = () => {
+    registerLangExtension('html', 'colorPicker', [cssColorPicker]);
+};
+/** Register mixed MediaWiki-HTML core language support */
+export const registerHTMLCore = () => {
+    languages['html'] = html;
+    registerLintSource('html', getHTMLLintSource);
+    optionalFunctions.detectIndent = detectIndent;
+};
+/** Register JavaScript language support */
+export const registerJavaScript = () => {
+    registerExtensions();
+    registerJavaScriptCore();
+};
+/** Register JavaScript core language support */
+export const registerJavaScriptCore = () => {
+    languages['javascript'] = javascript;
+    registerLintSource('javascript', getJsLintSource);
+    optionalFunctions.detectIndent = detectIndent;
+};
+/** Register CSS language support */
+export const registerCSS = () => {
+    registerCommonExtensions();
+    registerCSSCore();
+    registerColorPickerForCSS();
+};
+/** Register the `colorPicker` extension for CSS */
+export const registerColorPickerForCSS = () => {
+    registerLangExtension('css', 'colorPicker', [cssColorPicker]);
+};
+/** Register CSS core language support */
+export const registerCSSCore = () => {
+    languages['css'] = css;
+    registerLintSource('css', getCssLintSource);
+    optionalFunctions.detectIndent = detectIndent;
+};
+/** Register JSON language support */
+export const registerJSON = () => {
+    registerExtensions();
+    registerJSONCore();
+};
+/** Register JSON core language support */
+export const registerJSONCore = () => {
+    languages['json'] = json;
+    registerLintSource('json', getJsonLintSource);
+    optionalFunctions.detectIndent = detectIndent;
+};
+/** Register Lua language support */
+export const registerLua = () => {
+    registerExtensions();
+    registerLuaCore();
+};
+/** Register Lua core language support */
+export const registerLuaCore = () => {
+    languages['lua'] = lua;
+    registerLintSource('lua', getLuaLintSource);
+    optionalFunctions.detectIndent = detectIndent;
+};
+/** Register Vue language support */
+export const registerVue = () => {
+    registerCommonExtensions();
+    registerVueCore();
+    registerCloseBracketsForVue();
+    registerColorPickerForVue();
+};
+/** Register the `closeBrackets` extension for Vue */
+export const registerCloseBracketsForVue = () => {
+    registerLangExtension('vue', 'closeBrackets', autoCloseTags);
+};
+/** Register the `colorPicker` extension for Vue */
+export const registerColorPickerForVue = () => {
+    registerLangExtension('vue', 'colorPicker', [cssColorPicker]);
+};
+/** Register Vue core language support */
+export const registerVueCore = () => {
+    languages['vue'] = vue;
+    registerLintSource('vue', getVueLintSource);
+    optionalFunctions.detectIndent = detectIndent;
+};
+/**
+ * Register a custom language support
+ * @param name language name
+ * @param lang language support
+ * @param lintSource optional linter
+ */
+export const registerLanguage = (name, lang, lintSource) => {
+    registerCommonExtensions();
+    registerLanguageCore(name, lang, lintSource);
+};
+/**
+ * Register a custom language support without common extensions
+ * @param name language name
+ * @param lang language support
+ * @param lintSource optional linter
+ */
+export const registerLanguageCore = (name, lang, lintSource) => {
+    languages[name] = lang;
+    if (lintSource) {
+        registerLintSource(name, lintSource);
+    }
+};

package/dist/linter.js

@@ -34,6 +34,11 @@ const indexToPos = (code, index) => {
     const lines = code.slice(0, index).split('\n');
     return { line: lines.length - 1, character: lines[lines.length - 1].length };
 };
+/**
+ * 判断是否为 Stylelint 设置
+ * @param config 设置
+ */
+const isStylelintConfig = (config) => Boolean(config && ('extends' in config || 'rules' in config));
 /**
  * 获取 Wikitext LSP
  * @param opt 选项
@@ -42,16 +47,21 @@ const indexToPos = (code, index) => {
 export const getWikiLinter = async (opt, obj) => {
     await getWikiparse(opt?.['getConfig'], opt?.['i18n']);
     const lsp = getLSP(obj, opt?.['include']), cssLint = await getCssLinter();
-    return async (text, config) => {
+    const linter = async (text, config) => {
         const defaultSeverity = config?.['defaultSeverity'] ?? 2, diagnostics = (await lsp.provideDiagnostics(text)).filter(({ code, severity }) => Number(config?.[code] ?? defaultSeverity) > Number(severity === 2)), tokens = 'findStyleTokens' in lsp && config?.['invalid-css'] !== '0' ? await lsp.findStyleTokens() : [];
         if (tokens.length === 0) {
             return diagnostics;
         }
         const lines = tokens.map((token, i) => `${getPrefix(token, i)}${sanitizeInlineStyle(token.childNodes[1].childNodes[0].data)
-            .replace(/\n/gu, ' ')}\n}`);
+            .replace(/\n/gu, ' ')}\n}`), cssConfig = config?.['css'], isConfig = isStylelintConfig(cssConfig), rules = {};
+        for (const [key, value] of Object.entries((isConfig ? cssConfig.rules : cssConfig) ?? {})) {
+            if (!value) {
+                rules[key] = value;
+            }
+        }
         return [
             ...diagnostics,
-            ...(await cssLint(lines.join('\n'), config?.['css']))
+            ...(await cssLint(lines.join('\n'), isConfig ? { ...cssConfig, rules } : rules))
                 .map(({ line, column, endLine, endColumn, rule, severity, text: message, fix }) => {
                 const i = Math.ceil(line / 3), { length } = getPrefix(tokens[i - 1], i), { range } = tokens[i - 1].childNodes[1].childNodes[0], from = offsetAt(range, line - 3 * i, column - 1), diagnostic = {
                     from,
@@ -79,6 +89,10 @@ export const getWikiLinter = async (opt, obj) => {
             }),
         ];
     };
+    if ('resolveCodeAction' in lsp) {
+        linter.fixer = async (_, rule) => (await lsp.resolveCodeAction(rule)).edit.changes[''][0].newText;
+    }
+    return linter;
 };
 export const jsConfig = /* #__PURE__ */ (() => ({
     env: { browser: true, es2024: true, jquery: true },
@@ -131,9 +145,7 @@ export const getCssLinter = async (cdn = 'npm/@bhsd/stylelint-browserify') => {
     await loadScript(cdn, 'stylelint');
     const linter = async (code, opt) => {
         const warnings = await styleLint(stylelint, code, opt);
-        if (opt && 'rules' in opt) {
-            linter.config = opt;
-        }
+        linter.config = opt && !isStylelintConfig(opt) ? { rules: opt } : opt;
         return warnings;
     };
     linter.fixer = (code, rule) => {

package/dist/lintsource.d.ts

@@ -1,14 +1,16 @@
 import type { EditorView } from '@codemirror/view';
 import type { EditorState, Text } from '@codemirror/state';
+import type { Language } from '@codemirror/language';
 import type { Diagnostic } from '@codemirror/lint';
 import type { Option, LiveOption } from './linter';
 export type LintSource = ((state: EditorState) => Diagnostic[] | Promise<Diagnostic[]>) & {
     fixer?: (doc: Text, rule?: string) => string | Promise<string>;
 };
-export type LintSourceGetter = (opt?: Option | LiveOption, view?: EditorView) => LintSource | Promise<LintSource>;
+export type LintSourceGetter = (opt?: Option | LiveOption, view?: EditorView, nestedMWLanguage?: Language) => LintSource | Promise<LintSource>;
 export declare const getWikiLintSource: LintSourceGetter;
 export declare const getJsLintSource: LintSourceGetter;
 export declare const getCssLintSource: LintSourceGetter;
 export declare const getVueLintSource: LintSourceGetter;
+export declare const getHTMLLintSource: LintSourceGetter;
 export declare const getJsonLintSource: LintSourceGetter;
 export declare const getLuaLintSource: LintSourceGetter;

package/dist/lintsource.js

@@ -25,29 +25,6 @@ const pos = (doc, line, column, from = 0) => {
         character: (line === 1 ? from - lineDesc.from : 0) + column - 1,
     });
 };
-export const getWikiLintSource = async (opt, v) => {
-    const wikiLint = await getWikiLinter(await getOpt(opt), v);
-    return async ({ doc }) => (await wikiLint(doc.toString(), await getOpt(opt, true)))
-        .map(({ severity, code, message, range: r, from, to, data = [], source }) => ({
-        source: source,
-        from: from ?? posToIndex(doc, r.start),
-        to: to ?? posToIndex(doc, r.end),
-        severity: severity === 2 ? 'warning' : 'error',
-        message: source === 'Stylelint' ? message : `${message} (${code})`,
-        actions: data.map(({ title, range, newText }) => ({
-            name: title,
-            apply(view) {
-                view.dispatch({
-                    changes: {
-                        from: posToIndex(doc, range.start),
-                        to: posToIndex(doc, range.end),
-                        insert: newText,
-                    },
-                });
-            },
-        })),
-    }));
-};
 const getRange = (doc, line, column, endLine, endColumn, f = 0, t = Infinity) => {
     const start = pos(doc, line, column, f);
     return {
@@ -55,6 +32,35 @@ const getRange = (doc, line, column, endLine, endColumn, f = 0, t = Infinity) =>
         to: endLine === undefined ? Math.min(t, start + 1) : pos(doc, endLine, endColumn, f),
     };
 };
+const wikiLintSource = async (wikiLint, text, opt, doc, f = 0, t) => (await wikiLint(text, opt))
+    .map(({ severity, code, message, range: r, from, to, data = [], source }) => ({
+    source: source,
+    severity: severity === 2 ? 'warning' : 'error',
+    message: source === 'Stylelint' ? message : `${message} (${code})`,
+    actions: data.map(({ title, range, newText }) => ({
+        name: title,
+        apply(view) {
+            view.dispatch({
+                changes: {
+                    from: posToIndex(doc, range.start),
+                    to: posToIndex(doc, range.end),
+                    insert: newText,
+                },
+            });
+        },
+    })),
+    ...from === undefined
+        ? getRange(doc, r.start.line + 1, r.start.character + 1, r.end.line + 1, r.end.character + 1, f, t)
+        : { from: from + f, to: (to ?? from) + f },
+}));
+export const getWikiLintSource = async (opt, v) => {
+    const wikiLint = await getWikiLinter(await getOpt(opt), v);
+    const lintSource = async ({ doc }) => wikiLintSource(wikiLint, doc.toString(), await getOpt(opt, true), doc);
+    if (wikiLint.fixer) {
+        lintSource.fixer = (_, rule) => wikiLint.fixer('', rule);
+    }
+    return lintSource;
+};
 const jsLintSource = (esLint, code, opt, doc, f = 0, t) => esLint(code, opt)
     .map(({ ruleId, message, severity, line, column, endLine, endColumn, fix, suggestions = [] }) => {
     const diagnostic = {
@@ -76,6 +82,12 @@ const jsLintSource = (esLint, code, opt, doc, f = 0, t) => esLint(code, opt)
     }
     return diagnostic;
 });
+export const getJsLintSource = async (opt) => {
+    const esLint = await getJsLinter();
+    const lintSource = async ({ doc }) => jsLintSource(esLint, doc.toString(), await getOpt(opt), doc);
+    lintSource.fixer = (doc, rule) => esLint.fixer(doc.toString(), rule);
+    return lintSource;
+};
 const cssLintSource = async (styleLint, code, opt, doc, f = 0, t) => {
     let option = opt ?? {};
     if (!('extends' in option || 'rules' in option)) {
@@ -104,12 +116,6 @@ const cssLintSource = async (styleLint, code, opt, doc, f = 0, t) => {
         return diagnostic;
     });
 };
-export const getJsLintSource = async (opt) => {
-    const esLint = await getJsLinter();
-    const lintSource = async ({ doc }) => jsLintSource(esLint, doc.toString(), await getOpt(opt), doc);
-    lintSource.fixer = (doc, rule) => esLint.fixer(doc.toString(), rule);
-    return lintSource;
-};
 export const getCssLintSource = async (opt) => {
     const styleLint = await getCssLinter();
     const lintSource = async ({ doc }) => cssLintSource(styleLint, doc.toString(), await getOpt(opt), doc);
@@ -128,6 +134,17 @@ export const getVueLintSource = async (opt) => {
         ];
     };
 };
+export const getHTMLLintSource = async (opt, view, language) => {
+    const vueLintSource = await getVueLintSource(opt), wikiLint = await getWikiLinter({ include: false, ...await getOpt(opt) }, view);
+    return async (state) => {
+        const { doc } = state, option = await getOpt(opt) ?? {}, wiki = option['wiki'];
+        return [
+            ...await vueLintSource(state),
+            ...(await Promise.all(language.findRegions(state)
+                .map(({ from, to }) => wikiLintSource(wikiLint, state.sliceDoc(from, to), wiki, doc, from, to)))).flat(),
+        ];
+    };
+};
 export const getJsonLintSource = () => {
     const jsonLint = getJsonLinter();
     return ({ doc }) => {