@kerebron/editor-kits 0.4.1

package/esm/extension-codemirror/src/utils.d.ts

@@ -0,0 +1,40 @@
+import { Command, EditorState, TextSelection, Transaction } from 'prosemirror-state';
+import { EditorView as PMEditorView } from 'prosemirror-view';
+import { Node } from 'prosemirror-model';
+import { EditorView } from '@codemirror/view';
+import { Compartment } from '@codemirror/state';
+import type { CodeBlockSettings, ThemeItem } from './types.js';
+import type { CoreEditor } from '../../editor/src/mod.js';
+export declare const CodeBlockNodeName = "code_block";
+export declare function computeChange(oldVal: string, newVal: string): {
+    from: number;
+    to: number;
+    text: string;
+} | null;
+export declare const asProseMirrorSelection: (pmDoc: Node, cmView: EditorView, getPos: () => number | undefined) => TextSelection;
+export declare const forwardSelection: (cmView: EditorView, pmView: PMEditorView, getPos: () => number | undefined) => void;
+export declare const valueChanged: (textUpdate: string, node: Node, getPos: () => number | undefined, view: PMEditorView) => void;
+export declare const maybeEscape: (unit: "char" | "line", dir: -1 | 1, cm: EditorView, view: PMEditorView, getPos: () => number | undefined) => boolean;
+export declare const backspaceHandler: (pmView: PMEditorView, view: EditorView, editor: CoreEditor) => boolean;
+export declare const setMode: (lang: string, cmView: EditorView, settings: CodeBlockSettings, languageConf: Compartment) => Promise<void>;
+export declare const setTheme: (cmView: EditorView, themeConfig: Compartment, theme: Array<ThemeItem | undefined>) => Promise<void>;
+export declare const createCodeBlock: (state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, attributes: object) => boolean;
+export declare const removeCodeBlock: (state: EditorState, dispatch: ((tr: Transaction) => void) | undefined) => boolean;
+export declare const toggleCodeBlock: (state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, attributes: object) => boolean;
+export declare const codeBlockArrowHandlers: {
+    ArrowLeft: Command;
+    ArrowRight: Command;
+    ArrowUp: Command;
+    ArrowDown: Command;
+};
+export declare const codeBlockToggleShortcut: {
+    'Mod-Alt-c': Command;
+};
+export declare const codeBlockKeymap: {
+    ArrowLeft: Command;
+    ArrowRight: Command;
+    ArrowUp: Command;
+    ArrowDown: Command;
+    'Mod-Alt-c': Command;
+};
+//# sourceMappingURL=utils.d.ts.map

package/esm/extension-codemirror/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/extension-codemirror/src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EACL,OAAO,EACP,WAAW,EAEX,aAAa,EACb,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG1D,eAAO,MAAM,iBAAiB,eAAe,CAAC;AAM9C,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;SAoB3D;AAED,eAAO,MAAM,sBAAsB,GACjC,OAAO,IAAI,EACX,QAAQ,UAAU,EAClB,QAAQ,MAAM,MAAM,GAAG,SAAS,kBAMjC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,UAAU,EAClB,QAAQ,YAAY,EACpB,QAAQ,MAAM,MAAM,GAAG,SAAS,SAOjC,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,YAAY,MAAM,EAClB,MAAM,IAAI,EACV,QAAQ,MAAM,MAAM,GAAG,SAAS,EAChC,MAAM,YAAY,SAkBnB,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,MAAM,MAAM,GAAG,MAAM,EACrB,KAAK,CAAC,CAAC,GAAG,CAAC,EACX,IAAI,UAAU,EACd,MAAM,YAAY,EAClB,QAAQ,MAAM,MAAM,GAAG,SAAS,YAyBjC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,YAAY,EACpB,MAAM,UAAU,EAChB,QAAQ,UAAU,YAYnB,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,MAAM,MAAM,EACZ,QAAQ,UAAU,EAClB,UAAU,iBAAiB,EAC3B,cAAc,WAAW,kBAa1B,CAAC;AAcF,eAAO,MAAM,QAAQ,GACnB,QAAQ,UAAU,EAClB,aAAa,WAAW,EACxB,OAAO,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC,kBAOpC,CAAC;AA2BF,eAAO,MAAM,eAAe,GAC1B,OAAO,WAAW,EAClB,UAAU,CAAC,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,CAAC,GAAG,SAAS,EACjD,YAAY,MAAM,YA4DnB,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,OAAO,WAAW,EAClB,UAAU,CAAC,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,CAAC,GAAG,SAAS,YAwBlD,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,OAAO,WAAW,EAClB,UAAU,CAAC,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,CAAC,GAAG,SAAS,EACjD,YAAY,MAAM,YAanB,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;CAKlC,CAAC;AAEF,eAAO,MAAM,uBAAuB;iBACF,OAAO;CACxC,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;iBAHM,OAAO;CAMxC,CAAC"}

package/esm/extension-codemirror/src/utils.js

@@ -0,0 +1,210 @@
+// From prosemirror guide
+import { Selection, TextSelection, } from 'prosemirror-state';
+import { LSPPlugin } from './lsp/plugin.js';
+export const CodeBlockNodeName = 'code_block';
+function nonEmpty(value) {
+    return value !== null && value !== undefined;
+}
+export function computeChange(oldVal, newVal) {
+    if (oldVal === newVal)
+        return null;
+    let start = 0;
+    let oldEnd = oldVal.length;
+    let newEnd = newVal.length;
+    while (start < oldEnd &&
+        oldVal.charCodeAt(start) === newVal.charCodeAt(start)) {
+        start += 1;
+    }
+    while (oldEnd > start &&
+        newEnd > start &&
+        oldVal.charCodeAt(oldEnd - 1) === newVal.charCodeAt(newEnd - 1)) {
+        oldEnd -= 1;
+        newEnd -= 1;
+    }
+    return { from: start, to: oldEnd, text: newVal.slice(start, newEnd) };
+}
+export const asProseMirrorSelection = (pmDoc, cmView, getPos) => {
+    const offset = (typeof getPos === 'function' ? getPos() || 0 : 0) + 1;
+    const anchor = cmView.state.selection.main.from + offset;
+    const head = cmView.state.selection.main.to + offset;
+    return TextSelection.create(pmDoc, anchor, head);
+};
+export const forwardSelection = (cmView, pmView, getPos) => {
+    if (!cmView.hasFocus)
+        return;
+    const selection = asProseMirrorSelection(pmView.state.doc, cmView, getPos);
+    if (!selection.eq(pmView.state.selection)) {
+        pmView.dispatch(pmView.state.tr.setSelection(selection));
+    }
+};
+export const valueChanged = (textUpdate, node, getPos, view) => {
+    const change = computeChange(node.textContent, textUpdate);
+    if (change) {
+        const pos = getPos();
+        if ('undefined' !== typeof pos) {
+            const start = pos + 1;
+            let pmTr = view.state.tr;
+            pmTr = pmTr.replaceWith(start + change.from, start + change.to, change.text ? view.state.schema.text(change.text) : []);
+            view.dispatch(pmTr);
+        }
+    }
+};
+export const maybeEscape = (unit, dir, cm, view, getPos) => {
+    const sel = cm.state.selection.main;
+    const line = cm.state.doc.lineAt(sel.from);
+    const lastLine = cm.state.doc.lines;
+    if (sel.to !== sel.from ||
+        line.number !== (dir < 0 ? 1 : lastLine) ||
+        (unit === 'char' && sel.from !== (dir < 0 ? 0 : line.to)) ||
+        typeof getPos !== 'function') {
+        return false;
+    }
+    view.focus();
+    const pos = getPos();
+    if (!pos) {
+        return false;
+    }
+    const node = view.state.doc.nodeAt(pos);
+    if (!node)
+        return false;
+    const targetPos = pos + (dir < 0 ? 0 : node.nodeSize);
+    const selection = Selection.near(view.state.doc.resolve(targetPos), dir);
+    view.dispatch(view.state.tr.setSelection(selection).scrollIntoView());
+    view.focus();
+    return true;
+};
+export const backspaceHandler = (pmView, view, editor) => {
+    const { selection } = view.state;
+    if (selection.main.empty && selection.main.from === 0) {
+        editor.commandFactories.setBlockType(pmView.state.schema.nodes.paragraph)(pmView.state, pmView.dispatch);
+        setTimeout(() => pmView.focus(), 20);
+        return true;
+    }
+    return false;
+};
+export const setMode = async (lang, cmView, settings, languageConf) => {
+    const support = await settings.languageLoaders?.[lang]?.();
+    if (support) {
+        cmView.dispatch({
+            effects: languageConf.reconfigure(support),
+        });
+    }
+    const lspPlugin = LSPPlugin.get(cmView);
+    if (lspPlugin) {
+        lspPlugin.setLang(lang);
+    }
+};
+const isTheme = (theme) => {
+    if (!Array.isArray(theme)) {
+        return false;
+    }
+    return theme.every((item) => item !== undefined &&
+        typeof item.extension === 'object' && // or whatever type Extension is
+        typeof item.name === 'string');
+};
+export const setTheme = async (cmView, themeConfig, theme) => {
+    if (isTheme(theme)) {
+        cmView.dispatch({
+            effects: themeConfig.reconfigure(theme),
+        });
+    }
+};
+const arrowHandler = (dir) => (state, dispatch, view) => {
+    if (state.selection.empty && view?.endOfTextblock(dir)) {
+        const side = dir === 'left' || dir === 'up' ? -1 : 1;
+        const { $head } = state.selection;
+        const nextPos = Selection.near(state.doc.resolve(side > 0 ? $head.after() : $head.before()), side);
+        if (nextPos.$head &&
+            nextPos.$head.parent.type.name === CodeBlockNodeName) {
+            dispatch?.(state.tr.setSelection(nextPos));
+            return true;
+        }
+    }
+    return false;
+};
+export const createCodeBlock = (state, dispatch, attributes) => {
+    const { $from, $to } = state.selection;
+    //if we are in a CodeBlock node we do nothing
+    const parentNode = $from.node($from.depth);
+    if (parentNode && parentNode.type.name === CodeBlockNodeName) {
+        return false;
+    }
+    //if from and to in the same paragraph
+    if ($from.parentOffset === $to.parentOffset &&
+        $from.parent.type.name === 'paragraph') {
+        const text = $from.parent.textContent;
+        const tr = state.tr;
+        const newNode = state.schema.nodes[CodeBlockNodeName].createAndFill(attributes, text ? [state.schema.text($from.parent.textContent)] : []);
+        if (newNode && dispatch) {
+            const pos = $from.before($from.depth);
+            tr.delete(pos, pos + $from.parent.nodeSize - 1);
+            tr.insert(pos, newNode);
+            tr.setSelection(TextSelection.create(tr.doc, $from.pos));
+            dispatch(tr);
+        }
+        return true;
+    }
+    if (dispatch) {
+        const tr = state.tr;
+        const slice = state.doc.slice($from.before($from.depth), $to.after($to.depth), true);
+        const content = slice.content.textBetween(0, slice.content.size, '\n');
+        const newNode = state.schema.nodes[CodeBlockNodeName].createAndFill(attributes, state.schema.text(content));
+        if (newNode) {
+            tr.delete($from.before(slice.openStart + 1), $to.after(slice.openEnd + 1));
+            tr.insert($from.before(slice.openStart + 1), newNode);
+            tr.setSelection(TextSelection.create(tr.doc, $from.pos, $from.pos + newNode.nodeSize - 2));
+            dispatch(tr);
+        }
+    }
+    return true;
+};
+export const removeCodeBlock = (state, dispatch) => {
+    const { $from } = state.selection;
+    const parentNode = $from.node($from.depth);
+    if (parentNode && parentNode.type.name === CodeBlockNodeName) {
+        const children = [];
+        parentNode.forEach((child) => {
+            children.push(child);
+        });
+        const childrenNodes = children
+            .map((child) => {
+            return state.schema.nodes.paragraph.createAndFill({}, [child]);
+        })
+            .filter(nonEmpty);
+        const tr = state.tr;
+        const pos = $from.before($from.depth);
+        tr.delete(pos, pos + parentNode.nodeSize - 1);
+        tr.insert(pos, childrenNodes);
+        tr.setSelection(TextSelection.create(tr.doc, $from.pos - 1));
+        if (dispatch) {
+            dispatch(tr.scrollIntoView());
+        }
+    }
+    return false;
+};
+export const toggleCodeBlock = (state, dispatch, attributes) => {
+    const { $from } = state.selection;
+    if ($from.pos === 0) {
+        return false;
+    }
+    const parentNode = $from.node($from.depth);
+    if (parentNode && parentNode.type.name === CodeBlockNodeName) {
+        return removeCodeBlock(state, dispatch);
+    }
+    else {
+        return createCodeBlock(state, dispatch, attributes);
+    }
+};
+export const codeBlockArrowHandlers = {
+    ArrowLeft: arrowHandler('left'),
+    ArrowRight: arrowHandler('right'),
+    ArrowUp: arrowHandler('up'),
+    ArrowDown: arrowHandler('down'),
+};
+export const codeBlockToggleShortcut = {
+    'Mod-Alt-c': toggleCodeBlock,
+};
+export const codeBlockKeymap = {
+    ...codeBlockToggleShortcut,
+    ...codeBlockArrowHandlers,
+};

package/esm/extension-dev-toolkit/src/mod.d.ts

@@ -0,0 +1,13 @@
+import { CommandFactories, type CoreEditor, Extension } from '../../editor/src/mod.js';
+import { CommandShortcuts } from '../../editor/src/commands/mod.js';
+export interface DevToolkitConfig {
+}
+export declare class ExtensionDevToolkit extends Extension {
+    protected config: DevToolkitConfig;
+    name: string;
+    private visible;
+    constructor(config?: DevToolkitConfig);
+    getCommandFactories(editor: CoreEditor): Partial<CommandFactories>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+}
+//# sourceMappingURL=mod.d.ts.map

package/esm/extension-dev-toolkit/src/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/extension-dev-toolkit/src/mod.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,KAAK,UAAU,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAGpE,MAAM,WAAW,gBAAgB;CAChC;AAED,qBAAa,mBAAoB,SAAQ,SAAS;cAKjB,MAAM,EAAE,gBAAgB;IAJvD,IAAI,SAAiB;IAErB,OAAO,CAAC,OAAO,CAAS;gBAEO,MAAM,GAAE,gBAAqB;IAInD,mBAAmB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAkBlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAM3D"}

package/esm/extension-dev-toolkit/src/mod.js

@@ -0,0 +1,50 @@
+import { applyDevTools, removeDevTools } from 'prosemirror-dev-toolkit';
+import { Extension } from '../../editor/src/mod.js';
+import { EditorView } from 'prosemirror-view';
+export class ExtensionDevToolkit extends Extension {
+    constructor(config = {}) {
+        super(config);
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'dev_toolkit'
+        });
+        Object.defineProperty(this, "visible", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    getCommandFactories(editor) {
+        const commands = {
+            toggleDevToolkit: () => () => {
+                if (this.visible) {
+                    removeDevTools();
+                    this.visible = !this.visible;
+                }
+                else {
+                    if (editor.view instanceof EditorView) {
+                        applyDevTools(editor.view, { devToolsExpanded: true });
+                        this.visible = !this.visible;
+                    }
+                }
+                return true;
+            },
+        };
+        return commands;
+    }
+    getKeyboardShortcuts() {
+        const shortcuts = {
+            'Ctrl-`': 'toggleDevToolkit',
+        };
+        return shortcuts;
+    }
+}

package/esm/extension-lsp/src/DiagnosticPlugin.d.ts

@@ -0,0 +1,32 @@
+import { Plugin } from 'prosemirror-state';
+import { ExtensionLsp } from './ExtensionLsp.js';
+import { PositionMapper } from '../../extension-markdown/src/PositionMapper.js';
+interface LspRange {
+    line: number;
+    character: number;
+}
+interface DiagnosticsItem {
+    severity: number;
+    range: {
+        start: LspRange;
+        end: LspRange;
+    };
+    message: string;
+    source: string;
+    code: string;
+    data: any;
+}
+interface DiagnosticPluginState {
+    diagnostics: DiagnosticsItem[];
+    mapper?: PositionMapper;
+}
+interface DiagnosticConfig {
+}
+export declare class DiagnosticPlugin extends Plugin<DiagnosticPluginState> {
+    diagListener: ((event: Event) => void) | undefined;
+    listenerDisconnect: ((event: Event) => void) | undefined;
+    listenerChange: ((event: Event) => void) | undefined;
+    constructor(config: DiagnosticConfig, extension: ExtensionLsp);
+}
+export {};
+//# sourceMappingURL=DiagnosticPlugin.d.ts.map

package/esm/extension-lsp/src/DiagnosticPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiagnosticPlugin.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/DiagnosticPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA0B,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AAEhF,UAAU,QAAQ;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,eAAe;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE;QACL,KAAK,EAAE,QAAQ,CAAC;QAChB,GAAG,EAAE,QAAQ,CAAC;KACf,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,GAAG,CAAC;CACX;AAED,UAAU,qBAAqB;IAC7B,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED,UAAU,gBAAgB;CACzB;AAID,qBAAa,gBAAiB,SAAQ,MAAM,CAAC,qBAAqB,CAAC;IACjE,YAAY,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACnD,kBAAkB,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACzD,cAAc,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;gBAEzC,MAAM,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY;CA8J9D"}

package/esm/extension-lsp/src/DiagnosticPlugin.js

@@ -0,0 +1,131 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+const DiagnosticPluginKey = new PluginKey('lsp-diagnostic');
+export class DiagnosticPlugin extends Plugin {
+    constructor(config, extension) {
+        super({
+            key: DiagnosticPluginKey,
+            view(view) {
+                return {
+                    destroy: () => {
+                        const client = extension.getClient(extension.mainLang);
+                        if (this.listener && client) {
+                            client.removeEventListener('textDocument/publishDiagnostics', this.listener);
+                        }
+                        if (this.listenerDisconnect && client) {
+                            client.removeEventListener('close', this.listenerDisconnect);
+                        }
+                        if (this.changeListener) {
+                            extension.getEditor().removeEventListener('change', this.changeListener);
+                        }
+                    },
+                };
+            },
+            state: {
+                init() {
+                    return {
+                        diagnostics: [],
+                    };
+                },
+                apply(tr, prev, oldState, newState) {
+                    const next = { ...prev };
+                    const meta = tr.getMeta(DiagnosticPluginKey);
+                    if (meta?.diagnostics) {
+                        next.diagnostics = meta.diagnostics;
+                    }
+                    if (meta?.mapper) {
+                        next.mapper = meta.mapper;
+                    }
+                    return next;
+                },
+            },
+            props: {
+                decorations(state) {
+                    const decorations = [];
+                    const pluginState = this.getState(state);
+                    if (pluginState) {
+                        const { diagnostics, mapper } = pluginState;
+                        if (mapper) {
+                            for (const diag of diagnostics) {
+                                const from = mapper.fromLineChar(diag.range.start.line, diag.range.start.character);
+                                const end = mapper.fromLineChar(diag.range.end.line, diag.range.end.character);
+                                if (from > -1 && end > -1) {
+                                    const decoration = Decoration.inline(from, end, { class: 'kb-lsp__error', title: diag.message });
+                                    decorations.push(decoration);
+                                }
+                            }
+                        }
+                    }
+                    return DecorationSet.create(state.doc, decorations);
+                },
+            },
+        });
+        Object.defineProperty(this, "diagListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listenerDisconnect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listenerChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        let lastDiag = 0;
+        const editor = extension.getEditor();
+        const uri = editor.config.uri;
+        if (uri) {
+            const client = extension.getClient(extension.mainLang);
+            this.diagListener = (event) => {
+                const detail = event.detail;
+                if (detail.params.uri !== uri) {
+                    return;
+                }
+                event.preventDefault();
+                lastDiag = +Date();
+                if (client) {
+                    const file = client.workspace.getFile(uri);
+                    if (file) {
+                        const { mapper } = file;
+                        const tr = editor.view.state.tr.setMeta(DiagnosticPluginKey, {
+                            diagnostics: detail.params.diagnostics,
+                            mapper,
+                        });
+                        editor.view.dispatch(tr);
+                    }
+                }
+            };
+            if (client) {
+                client.addEventListener('textDocument/publishDiagnostics', this.diagListener);
+            }
+            this.listenerDisconnect = (event) => {
+                const tr = editor.view.state.tr.setMeta(DiagnosticPluginKey, {
+                    diagnostics: [],
+                    mapper: undefined,
+                });
+                editor.view.dispatch(tr);
+            };
+            if (client) {
+                client.addEventListener('close', this.listenerDisconnect);
+            }
+            this.listenerChange = (event) => {
+                if (lastDiag === 0 && +Date() - lastDiag > 10_1000) {
+                    return;
+                }
+                const tr = editor.view.state.tr.setMeta(DiagnosticPluginKey, {
+                    diagnostics: [],
+                    mapper: undefined,
+                });
+                editor.view.dispatch(tr);
+            };
+            // extension.getEditor().addEventListener('changed', this.listenerChange);
+        }
+    }
+}

package/esm/extension-lsp/src/ExtensionLsp.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from 'prosemirror-state';
+import { Extension } from '../../editor/src/mod.js';
+import { type ExtensionMarkdown } from '../../extension-markdown/src/ExtensionMarkdown.js';
+import { type ExtensionAutocomplete } from '../../extension-autocomplete/src/mod.js';
+import { LSPClient, Transport } from './LSPClient.js';
+import { LspSource } from './workspace.js';
+export type LspTransportGetter = (lang: string) => Transport | undefined;
+export interface LspConfig {
+    getLspTransport: LspTransportGetter;
+}
+export declare class ExtensionLsp extends Extension {
+    protected config: LspConfig;
+    name: string;
+    clients: Record<string, LSPClient>;
+    uri: string | undefined;
+    extensionMarkdown: ExtensionMarkdown;
+    extensionAutocomplete: ExtensionAutocomplete;
+    mainLang: string;
+    source: LspSource;
+    constructor(config: LspConfig);
+    getProseMirrorPlugins(): Plugin[];
+    created(): void;
+    getClient(lang: string): LSPClient | undefined;
+}
+//# sourceMappingURL=ExtensionLsp.d.ts.map

package/esm/extension-lsp/src/ExtensionLsp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionLsp.d.ts","sourceRoot":"","sources":["../../../src/extension-lsp/src/ExtensionLsp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,mDAAmD,CAAC;AAC3F,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAGrF,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAItD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,CAAC;AAEzE,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,kBAAkB,CAAC;CACrC;AAED,qBAAa,YAAa,SAAQ,SAAS;cASV,MAAM,EAAE,SAAS;IARhD,IAAI,SAAS;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAM;IACxC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,iBAAiB,EAAG,iBAAiB,CAAC;IACtC,qBAAqB,EAAG,qBAAqB,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAc;IAC9B,MAAM,EAAG,SAAS,CAAC;gBAEY,MAAM,EAAE,SAAS;IAIvC,qBAAqB,IAAI,MAAM,EAAE;IAWjC,OAAO;IA6DhB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;CAW/C"}

package/esm/extension-lsp/src/ExtensionLsp.js

@@ -0,0 +1,126 @@
+import { Extension } from '../../editor/src/mod.js';
+import { PositionMapper } from '../../extension-markdown/src/PositionMapper.js';
+import { LSPClient } from './LSPClient.js';
+import { AutocompletePlugin } from '../../extension-autocomplete/src/AutocompletePlugin.js';
+import { DiagnosticPlugin } from './DiagnosticPlugin.js';
+import { createLspAutocomplete } from './createLspAutocomplete.js';
+export class ExtensionLsp extends Extension {
+    constructor(config) {
+        super(config);
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'lsp'
+        });
+        Object.defineProperty(this, "clients", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "uri", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extensionMarkdown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extensionAutocomplete", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mainLang", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'markdown'
+        });
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    getProseMirrorPlugins() {
+        const plugins = [];
+        const { autocompleteConfig } = createLspAutocomplete(this);
+        plugins.push(new AutocompletePlugin(autocompleteConfig, this.editor));
+        plugins.push(new DiagnosticPlugin({}, this));
+        return plugins;
+    }
+    created() {
+        this.mainLang = this.editor.config.languageID || 'markdown';
+        this.source = {
+            ui: this.editor.ui,
+            getMappedContent: () => {
+                const editor = this.editor;
+                const result = this.extensionMarkdown.toMarkdown(editor.state.doc);
+                const mapper = new PositionMapper(editor, result.rawTextMap);
+                return {
+                    ...result,
+                    mapper,
+                };
+            },
+        };
+        const extensionMarkdown = this.editor
+            .getExtension('markdown');
+        if (!extensionMarkdown) {
+            throw new Error('No markdown extension');
+        }
+        this.extensionMarkdown = extensionMarkdown;
+        this.editor.addEventListener('doc:loaded', async () => {
+            const languageID = this.mainLang;
+            this.uri = this.editor.config.uri;
+            if (this.uri) {
+                const client = this.getClient(this.mainLang);
+                if (client) {
+                    client.connect(this.uri, this.source);
+                    await client.restart();
+                    client.workspace.openFile(this.uri, languageID, this.source);
+                }
+            }
+        });
+        this.editor.addEventListener('changed', () => {
+            if (this.editor.config.uri) {
+                const client = this.getClient(this.mainLang);
+                if (client) {
+                    client.workspace.changedFile(this.editor.config.uri);
+                }
+            }
+        });
+        this.editor.addEventListener('beforeDestroy', () => {
+            if (this.uri) {
+                const client = this.getClient(this.mainLang);
+                if (client) {
+                    client.disconnect(this.uri);
+                }
+            }
+        });
+    }
+    getClient(lang) {
+        if (!this.clients[lang]) {
+            const transport = this.config.getLspTransport(lang);
+            if (!transport) {
+                console.warn(`No lsp transport for ${lang}`);
+                return undefined;
+            }
+            this.clients[lang] = new LSPClient(transport, { rootUri: 'file:///' });
+        }
+        return this.clients[lang];
+    }
+}