@bhsd/codemirror-mediawiki 3.0.3 → 3.2.0

package/dist/escape.d.ts

@@ -1,4 +1,5 @@
-import type { KeyBinding } from '@codemirror/view';
+import { CodeMirror6 } from './codemirror';
+import type { Extension } from '@codemirror/state';
 export declare const escapeHTML: (str: string) => string, escapeURI: (str: string) => string;
-declare const _default: KeyBinding[];
+declare const _default: (cm: CodeMirror6) => Extension;
 export default _default;

package/dist/escape.js

@@ -1,5 +1,8 @@
+import { keymap } from '@codemirror/view';
+import { EditorSelection } from '@codemirror/state';
 import { indentMore, indentLess } from '@codemirror/commands';
-import { CodeMirror6 } from './codemirror';
+import { getLSP } from '@bhsd/browser';
+import { CodeMirror6, menuRegistry } from './codemirror';
 const entity = { '"': 'quot', "'": 'apos', '<': 'lt', '>': 'gt', '&': 'amp', ' ': 'nbsp' };
 /**
  * 根据函数转换选中文本
@@ -7,7 +10,7 @@ const entity = { '"': 'quot', "'": 'apos', '<': 'lt', '>': 'gt', '&': 'amp', ' '
  * @param cmd 原命令
  */
 const convert = (func, cmd) => (view) => {
-    if (view.state.selection.ranges.some(range => !range.empty)) {
+    if (view.state.selection.ranges.some(({ empty }) => !empty)) {
         CodeMirror6.replaceSelections(view, func);
         return true;
     }
@@ -29,7 +32,76 @@ export const escapeHTML = (str) => [...str].map(c => {
     }
     return encodeURIComponent(str);
 };
-export default /* @__PURE__ */ (() => [
+const escapeWiki = (cm) => {
+    const view = cm.view, { state } = view, { ranges } = state.selection, lsp = getLSP(view, false, cm.getWikiConfig);
+    if (lsp && 'provideRefactoringAction' in lsp && ranges.some(({ empty }) => !empty)) {
+        (async () => {
+            const replacements = new WeakMap();
+            for (const range of ranges) {
+                // eslint-disable-next-line no-await-in-loop
+                const [action] = await lsp.provideRefactoringAction(state.sliceDoc(range.from, range.to));
+                replacements.set(range, action?.edit.changes[''][0].newText);
+            }
+            view.dispatch(state.changeByRange(range => {
+                const insert = replacements.get(range);
+                if (insert === undefined) {
+                    return { range };
+                }
+                return {
+                    range: EditorSelection.range(range.from, range.from + insert.length),
+                    changes: { from: range.from, to: range.to, insert },
+                };
+            }));
+        })();
+        return true;
+    }
+    return false;
+};
+const handlerBase = (view, e) => {
+    e.stopPropagation();
+    view.focus();
+};
+let items;
+menuRegistry.push({
+    name: 'escape',
+    isActionable({ lang, view }) {
+        return lang === 'mediawiki' && view.state.selection.ranges.some(({ empty }) => !empty);
+    },
+    getItems(cm) {
+        if (!items) {
+            const view = cm.view, btnHTML = document.createElement('div'), btnURI = document.createElement('div');
+            btnHTML.textContent = 'HTML escape';
+            btnHTML.addEventListener('click', e => {
+                CodeMirror6.replaceSelections(view, escapeHTML);
+                handlerBase(view, e);
+            });
+            btnURI.textContent = 'URI encode/decode';
+            btnURI.addEventListener('click', e => {
+                CodeMirror6.replaceSelections(view, escapeURI);
+                handlerBase(view, e);
+            });
+            items = [btnHTML, btnURI];
+            const lsp = getLSP(view, false, cm.getWikiConfig);
+            if (lsp && 'provideRefactoringAction' in lsp) {
+                const btnWiki = document.createElement('div');
+                btnWiki.textContent = 'Escape with magic words';
+                btnWiki.addEventListener('click', e => {
+                    escapeWiki(cm);
+                    handlerBase(view, e);
+                });
+                items.unshift(btnWiki);
+            }
+        }
+        return items;
+    },
+});
+export default (cm) => keymap.of([
     { key: 'Mod-[', run: convert(escapeHTML, indentLess) },
     { key: 'Mod-]', run: convert(escapeURI, indentMore) },
-])();
+    {
+        key: 'Mod-\\',
+        run() {
+            return escapeWiki(cm);
+        },
+    },
+]);

package/dist/fold.d.ts

@@ -1,14 +1,10 @@
-import { GutterMarker, ViewPlugin } from '@codemirror/view';
-import { RangeSet } from '@codemirror/state';
-import type { EditorView, Tooltip, ViewUpdate, BlockInfo, Command } from '@codemirror/view';
-import type { EditorState, StateEffect, Extension } from '@codemirror/state';
+import type { EditorView, Command } from '@codemirror/view';
+import type { EditorState, Extension } from '@codemirror/state';
 import type { SyntaxNode, Tree } from '@lezer/common';
 export interface DocRange {
     from: number;
     to: number;
 }
-declare type AnchorUpdate = (pos: number, range: DocRange) => number;
-export declare const updateSelection: AnchorUpdate;
 /**
  * Update the stack of opening (+) or closing (-) brackets
  * @param state
@@ -23,54 +19,9 @@ export declare const braceStackUpdate: (state: EditorState, node: SyntaxNode) =>
  * @param refOnly 是否仅检查`<ref>`标签
  */
 export declare const foldable: (state: EditorState, posOrNode: number | SyntaxNode, tree?: Tree | null, refOnly?: boolean) => DocRange | false;
-/**
- * 创建折叠提示
- * @param state
- */
-export declare const create: (state: EditorState) => Tooltip | null;
-/**
- * 执行折叠
- * @param view
- * @param effects 折叠
- * @param anchor 光标位置
- */
-export declare const execute: (view: EditorView, effects: StateEffect<DocRange>[], anchor: number) => boolean;
-/**
- * The rightmost position of all selections, to be updated with folding
- * @param state
- */
-export declare const getAnchor: (state: EditorState) => number;
-/**
- * 折叠所有模板
- * @param state
- * @param tree 语法树
- * @param effects 折叠
- * @param node 语法树节点
- * @param end 终止位置
- * @param anchor 光标位置
- * @param update 更新光标位置
- * @param refOnly 是否仅检查`<ref>`标签
- */
-export declare const traverse: (state: EditorState, tree: Tree, effects: StateEffect<DocRange>[], node: SyntaxNode | null, end: number, anchor: number, update: AnchorUpdate, refOnly?: boolean) => number;
-export declare class FoldMarker extends GutterMarker {
-    readonly open: boolean;
-    constructor(open: boolean);
-    eq(other: this): boolean;
-    toDOM({ state }: EditorView): HTMLSpanElement;
-}
-export declare const findFold: ({ state }: EditorView, line: BlockInfo) => DocRange | undefined;
 export declare const foldableLine: ({ state, viewport: { to: end }, viewportLineBlocks }: EditorView, { from: f, to: t }: DocRange) => DocRange | false;
-export declare const markers: ViewPlugin<{
-    markers: RangeSet<FoldMarker>;
-    update({ docChanged, viewportChanged, startState, state, view }: ViewUpdate): void;
-}, undefined>;
-/**
- * 生成折叠命令
- * @param refOnly 是否仅检查`<ref>`标签
- */
-export declare const foldCommand: (refOnly?: boolean) => Command;
 export declare const foldRef: Command;
-declare const _default: [(e?: Extension | undefined) => Extension];
+declare const _default: (e?: Extension | undefined) => Extension;
 export default _default;
 export declare const mediaWikiFold: Extension;
 /**

package/dist/fold.js

@@ -5,8 +5,7 @@ import { getRegex } from '@bhsd/common';
 import { tokens } from './config';
 import { matchTag, getTag } from './matchTag';
 const getExtRegex = /* @__PURE__ */ getRegex(tag => new RegExp(`mw-tag-${tag}(?![a-z])`, 'u'));
-export const updateSelection = (pos, { to }) => Math.max(pos, to);
-const updateAll = (pos, { from, to }) => from <= pos && to > pos ? to : pos;
+const updateSelection = (pos, { to }) => Math.max(pos, to), updateAll = (pos, { from, to }) => from <= pos && to > pos ? to : pos;
 /**
  * Check if a SyntaxNode is among the specified components
  * @param keys The keys of the tokens to check
@@ -145,7 +144,7 @@ export const foldable = (state, posOrNode, tree, refOnly = false) => {
  * 创建折叠提示
  * @param state
  */
-export const create = (state) => {
+const create = (state) => {
     const { selection: { main: { head } } } = state, range = foldable(state, head);
     if (range) {
         const { from, to } = range;
@@ -179,7 +178,7 @@ export const create = (state) => {
  * @param effects 折叠
  * @param anchor 光标位置
  */
-export const execute = (view, effects, anchor) => {
+const execute = (view, effects, anchor) => {
     if (effects.length > 0) {
         view.dom.querySelector('.cm-tooltip-fold')?.remove();
         // Fold the template(s) and update the cursor position
@@ -192,7 +191,7 @@ export const execute = (view, effects, anchor) => {
  * The rightmost position of all selections, to be updated with folding
  * @param state
  */
-export const getAnchor = (state) => Math.max(...state.selection.ranges.map(({ to }) => to));
+const getAnchor = (state) => Math.max(...state.selection.ranges.map(({ to }) => to));
 /**
  * 折叠所有模板
  * @param state
@@ -204,7 +203,7 @@ export const getAnchor = (state) => Math.max(...state.selection.ranges.map(({ to
  * @param update 更新光标位置
  * @param refOnly 是否仅检查`<ref>`标签
  */
-export const traverse = (state, tree, effects, node, end, anchor, update, refOnly) => {
+const traverse = (state, tree, effects, node, end, anchor, update, refOnly) => {
     while (node && node.from <= end) {
         /* eslint-disable no-param-reassign */
         const range = foldable(state, node, tree, refOnly);
@@ -220,7 +219,7 @@ export const traverse = (state, tree, effects, node, end, anchor, update, refOnl
     }
     return anchor;
 };
-export class FoldMarker extends GutterMarker {
+class FoldMarker extends GutterMarker {
     constructor(open) {
         super();
         this.open = open;
@@ -236,7 +235,7 @@ export class FoldMarker extends GutterMarker {
     }
 }
 const canFold = /* @__PURE__ */ new FoldMarker(true), canUnfold = /* @__PURE__ */ new FoldMarker(false);
-export const findFold = ({ state }, line) => {
+const findFold = ({ state }, line) => {
     let found;
     state.field(foldState, false)?.between(line.from, line.to, (from, to) => {
         if (!found && to === line.to) {
@@ -310,7 +309,7 @@ const buildMarkers = (view) => {
     }
     return builder.finish();
 };
-export const markers = /* @__PURE__ */ ViewPlugin.fromClass(class {
+const markers = /* @__PURE__ */ ViewPlugin.fromClass(class {
     constructor(view) {
         this.markers = buildMarkers(view);
     }
@@ -324,17 +323,17 @@ export const markers = /* @__PURE__ */ ViewPlugin.fromClass(class {
         }
     }
 });
-const defaultFoldExtension = [foldGutter(), keymap.of(foldKeymap)];
+const defaultFoldExtension = /* @__PURE__ */ (() => [foldGutter(), keymap.of(foldKeymap)])();
 /**
  * 生成折叠命令
  * @param refOnly 是否仅检查`<ref>`标签
  */
-export const foldCommand = (refOnly) => view => {
+const foldCommand = (refOnly) => view => {
     const { state } = view, tree = syntaxTree(state), effects = [], anchor = traverse(state, tree, effects, tree.topNode.firstChild, Infinity, getAnchor(state), updateAll, refOnly);
     return execute(view, effects, anchor);
 };
 export const foldRef = /* @__PURE__ */ foldCommand(true);
-export default [(e = defaultFoldExtension) => e];
+export default ((e = defaultFoldExtension) => e);
 export const mediaWikiFold = /* @__PURE__ */ (() => [
     codeFolding({
         placeholderDOM(view) {

package/dist/html.d.ts

@@ -0,0 +1,4 @@
+import { LanguageSupport } from '@codemirror/language';
+import type { MwConfig } from './token';
+declare const _default: (config: MwConfig) => LanguageSupport;
+export default _default;

package/dist/html.js

@@ -0,0 +1,31 @@
+import { configureNesting } from '@lezer/html';
+import { htmlPlain, htmlCompletionSourceWith } from '@codemirror/lang-html';
+import { javascript, javascriptLanguage } from '@codemirror/lang-javascript';
+import { cssLanguage } from '@codemirror/lang-css';
+import { LanguageSupport } from '@codemirror/language';
+import { jsCompletion } from './javascript';
+import { mediawiki } from './mediawiki';
+import { cssCompletion } from './css';
+export default (config) => {
+    const { language, support } = mediawiki(config), lang = new LanguageSupport(htmlPlain.configure({
+        wrap: configureNesting([
+            { tag: 'script', parser: javascriptLanguage.parser },
+            { tag: 'style', parser: cssLanguage.parser },
+            { tag: 'noinclude', parser: language.parser },
+        ], [{ name: 'style', parser: cssLanguage.parser.configure({ top: 'Styles' }) }]),
+    }), [
+        htmlPlain.data.of({
+            autocomplete: htmlCompletionSourceWith({
+                extraTags: {
+                    noinclude: { globalAttrs: false },
+                },
+            }),
+        }),
+        javascript().support,
+        jsCompletion,
+        cssCompletion(),
+        support,
+    ]);
+    Object.assign(lang, { nestedMWLanguage: language });
+    return lang;
+};

package/dist/indent.js

@@ -1,4 +1,4 @@
-const noDetectionLangs = new Set(['plain', 'mediawiki', 'html']);
+const noDetectionLangs = new Set(['plain', 'mediawiki']);
 const getLines = (text) => text.children?.flatMap(getLines) ?? text.text;
 /**
  * 检测文本的缩进方式

package/dist/index.d.ts

@@ -0,0 +1,102 @@
+import { CodeMirror6 } from './codemirror';
+import type { LanguageSupport } from '@codemirror/language';
+import type { MwConfig } from './token';
+import type { LintSourceGetter } from './lintsource';
+export type { MwConfig };
+export { CodeMirror6 };
+/** Register the `highlightSpecialChars` extension */
+export declare const registerHighlightSpecialChars: () => void;
+/** Register the `highlightActiveLine` extension */
+export declare const registerHighlightActiveLine: () => void;
+/** Register the `highlightWhitespace` extension */
+export declare const registerHighlightWhitespace: () => void;
+/** Register the `highlightTrailingWhitespace` extension */
+export declare const registerHighlightTrailingWhitespace: () => void;
+/** Register the `highlightSelectionMatches` extension */
+export declare const registerHighlightSelectionMatches: () => void;
+/** Register the `bracketMatching` extension */
+export declare const registerBracketMatching: () => void;
+/** Register the `closeBrackets` extension */
+export declare const registerCloseBrackets: () => void;
+/** Register the `scrollPastEnd` extension */
+export declare const registerScrollPastEnd: () => void;
+/** Register the `allowMultipleSelections` extension */
+export declare const registerAllowMultipleSelections: () => void;
+/** Register the `autocompletion` extension */
+export declare const registerAutocompletion: () => void;
+/** Register the `codeFolding` extension */
+export declare const registerCodeFolding: () => void;
+/** Register the `colorPicker` extension */
+export declare const registerColorPicker: () => void;
+/** Register all common extensions */
+export declare const registerCommonExtensions: () => void;
+/** Register MediaWiki language support */
+export declare const registerMediaWiki: () => void;
+/** Register the `openLinks` extension */
+export declare const registerOpenLinks: () => void;
+/** Register the `escape` extension */
+export declare const registerEscape: () => void;
+/** Register the `refHover` extension */
+export declare const registerRefHover: () => void;
+/** Register the `hover` extension */
+export declare const registerHover: () => void;
+/** Register the `signatureHelp` extension */
+export declare const registerSignatureHelp: () => void;
+/** Register the `inlayHints` extension */
+export declare const registerInlayHints: () => void;
+/** Register the `colorPicker` extension for MediaWiki */
+export declare const registerColorPickerForMediaWiki: () => void;
+/** Register the `bracketMatching` extension for MediaWiki */
+export declare const registerBracketMatchingForMediaWiki: () => void;
+/** Register the `codeFolding` extension for MediaWiki */
+export declare const registerCodeFoldingForMediaWiki: () => void;
+/** Register MediaWiki core language support */
+export declare const registerMediaWikiCore: () => void;
+/** Register mixed MediaWiki-HTML language support */
+export declare const registerHTML: () => void;
+/** Register the `closeBrackets` extension for mixed MediaWiki-HTML */
+export declare const registerCloseBracketsForHTML: () => void;
+/** Register the `colorPicker` extension for mixed MediaWiki-HTML */
+export declare const registerColorPickerForHTML: () => void;
+/** Register mixed MediaWiki-HTML core language support */
+export declare const registerHTMLCore: () => void;
+/** Register JavaScript language support */
+export declare const registerJavaScript: () => void;
+/** Register JavaScript core language support */
+export declare const registerJavaScriptCore: () => void;
+/** Register CSS language support */
+export declare const registerCSS: () => void;
+/** Register the `colorPicker` extension for CSS */
+export declare const registerColorPickerForCSS: () => void;
+/** Register CSS core language support */
+export declare const registerCSSCore: () => void;
+/** Register JSON language support */
+export declare const registerJSON: () => void;
+/** Register JSON core language support */
+export declare const registerJSONCore: () => void;
+/** Register Lua language support */
+export declare const registerLua: () => void;
+/** Register Lua core language support */
+export declare const registerLuaCore: () => void;
+/** Register Vue language support */
+export declare const registerVue: () => void;
+/** Register the `closeBrackets` extension for Vue */
+export declare const registerCloseBracketsForVue: () => void;
+/** Register the `colorPicker` extension for Vue */
+export declare const registerColorPickerForVue: () => void;
+/** Register Vue core language support */
+export declare const registerVueCore: () => void;
+/**
+ * Register a custom language support
+ * @param name language name
+ * @param lang language support
+ * @param lintSource optional linter
+ */
+export declare const registerLanguage: (name: string, lang: (config?: unknown) => LanguageSupport, lintSource?: LintSourceGetter) => void;
+/**
+ * Register a custom language support without common extensions
+ * @param name language name
+ * @param lang language support
+ * @param lintSource optional linter
+ */
+export declare const registerLanguageCore: (name: string, lang: (config?: unknown) => LanguageSupport, lintSource?: LintSourceGetter) => void;