@esportsplus/ui 0.56.3 → 0.57.0

package/build/components/editor/code/services/completion.js

@@ -0,0 +1,90 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+import { ReactiveArray, flush } from '@esportsplus/reactivity';
+class ReactiveObject_0eyz8gh0 extends reactivity_u0.ReactiveObject {
+    #open = this[reactivity_u0.SIGNAL](false);
+    #selected = this[reactivity_u0.SIGNAL](0);
+    constructor() {
+        super(null);
+    }
+    get open() {
+        return reactivity_u0.read(this.#open);
+    }
+    set open(_v0) {
+        reactivity_u0.write(this.#open, _v0);
+    }
+    get selected() {
+        return reactivity_u0.read(this.#selected);
+    }
+    set selected(_v1) {
+        reactivity_u0.write(this.#selected, _v1);
+    }
+}
+const LIMIT = 200;
+const completion = (id) => {
+    let items = [], list, rows = new ReactiveArray(), state = new ReactiveObject_0eyz8gh0();
+    function reveal() {
+        flush();
+        let option = list?.children[state.selected];
+        if (!list || !option) {
+            return;
+        }
+        if (option.offsetTop < list.scrollTop) {
+            list.scrollTop = option.offsetTop;
+        }
+        else if (option.offsetTop + option.offsetHeight > list.scrollTop + list.clientHeight) {
+            list.scrollTop = option.offsetTop + option.offsetHeight - list.clientHeight;
+        }
+    }
+    let api = {
+        aria: {
+            'aria-activedescendant': () => state.open && `${id}-${state.selected}`,
+            'aria-controls': () => state.open && id
+        },
+        attach: (element) => {
+            list = element;
+        },
+        hide: () => {
+            if (!state.open && !rows.$length) {
+                return;
+            }
+            state.open = false;
+            rows.splice(0, rows.$length);
+            items = [];
+            if (list?.matches(':popover-open')) {
+                list.hidePopover();
+            }
+        },
+        id,
+        item: (index = state.selected) => items[index],
+        move: (step) => {
+            let n = rows.$length;
+            state.selected = (state.selected + step + n) % n;
+            reveal();
+        },
+        rows,
+        show: (next) => {
+            items = next
+                .filter((item) => typeof item?.label === 'string')
+                .sort((a, b) => (a.sortText ?? a.label).localeCompare(b.sortText ?? b.label))
+                .slice(0, LIMIT);
+            if (!items.length) {
+                api.hide();
+                return;
+            }
+            rows.splice(0, rows.$length, ...items.map((item, index) => ({ detail: item.detail ?? '', index, label: item.label })));
+            state.selected = 0;
+            state.open = true;
+            flush();
+            if (!list?.isConnected) {
+                return;
+            }
+            if (!list.matches(':popover-open')) {
+                list.showPopover();
+            }
+            list.scrollTop = 0;
+        },
+        state
+    };
+    return api;
+};
+export { completion };

package/build/components/editor/code/services/diagnostics.d.ts

@@ -0,0 +1,28 @@
+import { ReactiveArray } from '@esportsplus/reactivity';
+import type { Edit, EditorDocument } from '../document.js';
+import type { Mark } from '../rows.js';
+import type { Diagnostic } from './protocol.js';
+type Diagnostics = {
+    readonly all: readonly Entry[];
+    clear: VoidFunction;
+    readonly count: number;
+    hit: (from: number, to: number) => Entry[];
+    map: (batches: readonly (readonly Edit[])[]) => void;
+    marks: (from: number, to: number) => readonly Mark[];
+    problems: ReactiveArray<Entry>;
+    publish: (doc: EditorDocument, list: readonly Diagnostic[]) => void;
+};
+type Entry = {
+    from: number;
+    kind: string;
+    label: string;
+    message: string;
+    severity: Severity;
+    to: number;
+};
+type Severity = 'error' | 'hint' | 'info' | 'warning';
+declare const diagnostics: ({ changed }?: {
+    changed?: (entries: readonly Entry[]) => void;
+}) => Diagnostics;
+export { diagnostics };
+export type { Diagnostics, Entry };

package/build/components/editor/code/services/diagnostics.js

@@ -0,0 +1,98 @@
+import { ReactiveArray } from '@esportsplus/reactivity';
+import { spanOf } from './model.js';
+const LIMIT = 1000;
+const SEVERITIES = ['error', 'error', 'warning', 'info', 'hint'];
+const diagnostics = ({ changed } = {}) => {
+    let entries = [], problems = new ReactiveArray();
+    function set(next) {
+        entries = next;
+        problems.splice(0, problems.$length, ...next);
+        changed?.(next);
+    }
+    let api = {
+        get all() {
+            return entries;
+        },
+        clear: () => {
+            if (entries.length) {
+                set([]);
+            }
+        },
+        get count() {
+            return entries.length;
+        },
+        hit: (from, to) => entries.filter((entry) => entry.from < to && entry.to > from),
+        map: (batches) => {
+            if (!entries.length) {
+                return;
+            }
+            let next = entries;
+            for (let i = 0, n = batches.length; i < n; i++) {
+                let batch = batches[i], kept = [];
+                for (let j = 0, m = next.length; j < m; j++) {
+                    let entry = next[j], shift = 0, touched = false;
+                    for (let k = 0, o = batch.length; k < o; k++) {
+                        let edit = batch[k];
+                        if (edit.to <= entry.from) {
+                            shift += edit.insert.length - (edit.to - edit.from);
+                        }
+                        else if (edit.from < entry.to && (edit.from < edit.to || edit.from > entry.from)) {
+                            touched = true;
+                            break;
+                        }
+                    }
+                    if (!touched) {
+                        entry.from += shift;
+                        entry.to += shift;
+                        kept.push(entry);
+                    }
+                }
+                next = kept;
+            }
+            if (next.length !== entries.length) {
+                set(next);
+            }
+        },
+        marks: (from, to) => {
+            let out = [];
+            for (let i = 0, n = entries.length; i < n; i++) {
+                let entry = entries[i];
+                if (entry.to >= from && entry.from <= to) {
+                    out.push(entry);
+                }
+            }
+            return out;
+        },
+        problems,
+        publish: (doc, list) => {
+            let next = [];
+            for (let i = 0, n = list.length; i < n && next.length < LIMIT; i++) {
+                let diagnostic = list[i], span = typeof diagnostic?.message === 'string' && diagnostic.range ? spanOf(doc, diagnostic.range) : null;
+                if (!span) {
+                    continue;
+                }
+                if (span.from === span.to) {
+                    let line = doc.lineAt(span.from);
+                    if (span.to < doc.lineEnd(line)) {
+                        span.to++;
+                    }
+                    else if (span.from > doc.lineStart(line)) {
+                        span.from--;
+                    }
+                }
+                let severity = SEVERITIES[diagnostic.severity ?? 1] ?? 'error';
+                next.push({
+                    from: span.from,
+                    kind: `code-editor-diagnostic code-editor-diagnostic--${severity}`,
+                    label: diagnostic.source ? `${diagnostic.source}: ${diagnostic.message}` : diagnostic.message,
+                    message: diagnostic.message,
+                    severity,
+                    to: span.to
+                });
+            }
+            set(next.sort((a, b) => a.from - b.from));
+        }
+    };
+    return api;
+};
+export { diagnostics };

package/build/components/editor/code/services/hover.d.ts

@@ -0,0 +1,14 @@
+import type { Hover } from './protocol.js';
+type Card = {
+    attach: (element: HTMLElement) => void;
+    hide: VoidFunction;
+    show: (value: string) => void;
+    state: {
+        open: boolean;
+        text: string;
+    };
+};
+declare const hover: () => Card;
+declare const hoverText: (value: Hover) => string;
+export { hover, hoverText };
+export type { Card };

package/build/components/editor/code/services/hover.js

@@ -0,0 +1,66 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+import { flush } from '@esportsplus/reactivity';
+class ReactiveObject_13n94f90 extends reactivity_u0.ReactiveObject {
+    #open = this[reactivity_u0.SIGNAL](false);
+    #text = this[reactivity_u0.SIGNAL]('');
+    constructor() {
+        super(null);
+    }
+    get open() {
+        return reactivity_u0.read(this.#open);
+    }
+    set open(_v0) {
+        reactivity_u0.write(this.#open, _v0);
+    }
+    get text() {
+        return reactivity_u0.read(this.#text);
+    }
+    set text(_v1) {
+        reactivity_u0.write(this.#text, _v1);
+    }
+}
+function text(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value && typeof value === 'object' && 'value' in value) {
+        return String(value.value);
+    }
+    return '';
+}
+const hover = () => {
+    let card, state = new ReactiveObject_13n94f90();
+    let api = {
+        attach: (element) => {
+            card = element;
+        },
+        hide: () => {
+            if (!state.open) {
+                return;
+            }
+            state.open = false;
+            state.text = '';
+            if (card?.matches(':popover-open')) {
+                card.hidePopover();
+            }
+        },
+        show: (value) => {
+            if (!value) {
+                api.hide();
+                return;
+            }
+            state.text = value;
+            state.open = true;
+            flush();
+            if (card?.isConnected && !card.matches(':popover-open')) {
+                card.showPopover();
+            }
+        },
+        state
+    };
+    return api;
+};
+const hoverText = (value) => Array.isArray(value.contents)
+    ? value.contents.map(text).filter(Boolean).join('\n\n')
+    : text(value.contents);
+export { hover, hoverText };

package/build/components/editor/code/services/index.d.ts

@@ -0,0 +1,27 @@
+import { type Attributes, type Renderable } from '@esportsplus/template';
+import type { Mark } from '../rows.js';
+import type { Entry } from './diagnostics.js';
+import type { Options } from '../view.js';
+import { fileUri, languageIdFor } from './model.js';
+import type { CompletionItem, Diagnostic, Hover, LanguageTransport, Notification, Position, Range, TextEdit } from './protocol.js';
+import { type Host, type LanguageServiceOptions } from './session.js';
+import { referenceRpcTransport } from './transport.js';
+type Services = {
+    anchors: () => Renderable<unknown>;
+    aria: Attributes;
+    configure: (options: Options) => void;
+    dismiss: VoidFunction;
+    dispose: VoidFunction;
+    keydown: (e: KeyboardEvent) => boolean;
+    leave: VoidFunction;
+    list: () => readonly Entry[];
+    marks: (from: number, to: number) => readonly Mark[];
+    notice: (offset: number, text: string) => void;
+    paint: VoidFunction;
+    pointer: (e: PointerEvent) => void;
+    retarget: VoidFunction;
+    template: () => Renderable<unknown>;
+};
+declare const services: (host: Host) => Services;
+export { fileUri, languageIdFor, referenceRpcTransport, services };
+export type { CompletionItem, Diagnostic, Entry, Hover, LanguageServiceOptions, LanguageTransport, Notification, Position, Range, Services, TextEdit };

package/build/components/editor/code/services/index.js

@@ -0,0 +1,64 @@
+import * as template_u1 from '@esportsplus/template';
+import { fileUri, languageIdFor } from './model.js';
+import { session } from './session.js';
+import { referenceRpcTransport } from './transport.js';
+const template_0ai3xuz1 = template_u1.template(`<div aria-hidden='true' class='code-editor-anchor'></div><div aria-hidden='true' class='code-editor-anchor'>`);
+const template_0ai3xuz5 = template_u1.template(`<div aria-label='Completions' class='code-editor-completions' popover='manual' role='listbox'></div><div class='code-editor-hover' popover='manual' role='tooltip'></div><div aria-label='Problems' aria-live='polite' class='code-editor-problems'>`);
+const template_0ai3xuza = template_u1.template(`<div class='code-editor-completion' role='option'><span class='code-editor-completion-label'></span><span class='code-editor-completion-detail'>`);
+const template_0ai3xuzf = template_u1.template(`<button class='code-editor-problem ' type='button'>`);
+const services = (host) => {
+    let api = session(host), { anchors, card, complete, diagnostics, id } = api;
+    return {
+        anchors: () => {
+            let root_0ai3xuz0 = template_0ai3xuz1(), element_0ai3xuz2 = root_0ai3xuz0.firstChild, element_0ai3xuz3 = element_0ai3xuz2.nextSibling;
+            template_u1.setList(element_0ai3xuz3, 'style', () => `anchor-name: --code-editor-hover-${id}; ${anchors.hover}`);
+            template_u1.setList(element_0ai3xuz2, 'style', () => `anchor-name: --code-editor-completion-${id}; ${anchors.completion}`);
+            return root_0ai3xuz0;
+        },
+        aria: api.aria,
+        configure: api.configure,
+        dismiss: api.dismiss,
+        dispose: api.dispose,
+        keydown: api.keydown,
+        leave: api.leave,
+        list: api.list,
+        marks: api.marks,
+        notice: api.notice,
+        paint: api.paint,
+        pointer: api.pointer,
+        retarget: api.retarget,
+        template: () => {
+            let root_0ai3xuz4 = template_0ai3xuz5(), element_0ai3xuz6 = root_0ai3xuz4.firstChild, element_0ai3xuz7 = element_0ai3xuz6.nextSibling, element_0ai3xuz8 = element_0ai3xuz7.nextSibling;
+            element_0ai3xuz6.appendChild(new template_u1.ArraySlot(complete.rows, (row) => {
+                let root_0ai3xuz9 = template_0ai3xuza(), element_0ai3xuzb = root_0ai3xuz9.firstChild, element_0ai3xuzc = element_0ai3xuzb.firstElementChild, element_0ai3xuzd = element_0ai3xuzc.nextElementSibling;
+                template_u1.slot(element_0ai3xuzc, row.label, 1);
+                template_u1.slot(element_0ai3xuzd, row.detail, 1);
+                template_u1.setProperty(element_0ai3xuzb, 'id', `${complete.id}-${row.index}`);
+                template_u1.setProperty(element_0ai3xuzb, 'aria-selected', () => String(complete.state.selected === row.index));
+                template_u1.setList(element_0ai3xuzb, 'class', () => complete.state.selected === row.index && '--active');
+                template_u1.delegate(element_0ai3xuzb, 'click', () => api.accept(row.index));
+                template_u1.delegate(element_0ai3xuzb, 'pointerdown', (e) => e.preventDefault());
+                template_u1.delegate(element_0ai3xuzb, 'pointermove', () => {
+                    complete.state.selected = row.index;
+                });
+                return root_0ai3xuz9;
+            }, true).fragment);
+            new template_u1.EffectSlot(element_0ai3xuz7, () => card.state.text, 1);
+            element_0ai3xuz8.appendChild(new template_u1.ArraySlot(diagnostics.problems, (entry) => {
+                let root_0ai3xuze = template_0ai3xuzf(), element_0ai3xuzg = root_0ai3xuze.firstChild;
+                template_u1.slot(element_0ai3xuzg, entry.label, 1);
+                template_u1.setList(element_0ai3xuzg, 'class', `code-editor-problem--${entry.severity}`);
+                template_u1.delegate(element_0ai3xuzg, 'click', () => api.reveal(entry.from, entry.to));
+                return root_0ai3xuze;
+            }, true).fragment);
+            template_u1.setList(element_0ai3xuz8, 'class', () => diagnostics.problems.$length > 0 && '--active');
+            template_u1.setList(element_0ai3xuz7, 'style', `--anchor: --code-editor-hover-${id};`);
+            template_u1.onconnect(element_0ai3xuz7, card.attach);
+            template_u1.setProperty(element_0ai3xuz6, 'id', complete.id);
+            template_u1.setList(element_0ai3xuz6, 'style', `--anchor: --code-editor-completion-${id};`);
+            template_u1.onconnect(element_0ai3xuz6, complete.attach);
+            return root_0ai3xuz4;
+        }
+    };
+};
+export { fileUri, languageIdFor, referenceRpcTransport, services };

package/build/components/editor/code/services/model.d.ts

@@ -0,0 +1,35 @@
+import type { Edit, EditorDocument } from '../document.js';
+import type { CompletionItem, Position, Range } from './protocol.js';
+type Span = {
+    from: number;
+    to: number;
+};
+type Stop = {
+    from: number;
+    index: number;
+    to: number;
+};
+declare function identifier(code: number): boolean;
+declare const applyCompletion: (doc: EditorDocument, item: CompletionItem, offset: number, commit?: string) => {
+    from: number;
+    index: number;
+    to: number;
+}[] | null;
+declare const expandSnippet: (source: string) => {
+    stops: Stop[];
+    text: string;
+};
+declare const fileUri: (cwd: string, path: string) => string;
+declare const languageIdFor: (path: string) => string;
+declare const localWords: (text: string, offset: number) => CompletionItem[];
+declare const mapStops: (stops: readonly Stop[], active: number, batches: readonly (readonly Edit[])[]) => {
+    from: number;
+    index: number;
+    to: number;
+}[] | null;
+declare const offsetAt: (doc: EditorDocument, position: Position) => number | null;
+declare const positionAt: (doc: EditorDocument, offset: number) => Position;
+declare const spanOf: (doc: EditorDocument, range: Range) => Span | null;
+declare const wordStart: (text: string, offset: number) => number;
+export { applyCompletion, expandSnippet, fileUri, identifier, languageIdFor, localWords, mapStops, offsetAt, positionAt, spanOf, wordStart };
+export type { Span, Stop };

package/build/components/editor/code/services/model.js

@@ -0,0 +1,167 @@
+const LANGUAGES = {
+    cjs: 'javascript',
+    css: 'css',
+    cts: 'typescript',
+    html: 'html',
+    js: 'javascript',
+    json: 'json',
+    jsx: 'javascript',
+    markdown: 'markdown',
+    md: 'markdown',
+    mjs: 'javascript',
+    mts: 'typescript',
+    py: 'python',
+    scss: 'scss',
+    ts: 'typescript',
+    tsx: 'typescript'
+};
+const SNIPPET = /\\([\\$}])|\$\{(\d+)(?::([^{}]*?)|\|([^{}]*?)\|)?\}|\$(\d+)/g;
+const URI = /^[a-z][a-z\d+.-]*:\/\//i;
+const WORD = /[A-Za-z_$][\w$]*/g;
+const WORDS = 200;
+function identifier(code) {
+    return (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 36 || code === 95;
+}
+const applyCompletion = (doc, item, offset, commit = '') => {
+    let main = item.textEdit
+        ? spanOf(doc, 'range' in item.textEdit ? item.textEdit.range : item.textEdit.replace)
+        : { from: wordStart(doc.value, offset), to: offset };
+    if (!main) {
+        return null;
+    }
+    let source = item.textEdit?.newText ?? item.insertText ?? item.label, snippet = item.insertTextFormat === 2 ? expandSnippet(source) : { stops: [], text: source }, edits = [{ from: main.from, insert: snippet.text + (snippet.text.endsWith(commit) ? '' : commit), to: main.to }];
+    for (let additional of item.additionalTextEdits ?? []) {
+        let span = spanOf(doc, additional.range);
+        if (!span) {
+            return null;
+        }
+        edits.push({ from: span.from, insert: additional.newText, to: span.to });
+    }
+    let shift = 0;
+    for (let i = 1, n = edits.length; i < n; i++) {
+        if (edits[i].to <= main.from) {
+            shift += edits[i].insert.length - (edits[i].to - edits[i].from);
+        }
+    }
+    let origin = main.from + shift, end = origin + edits[0].insert.length, first = snippet.stops[0], result = doc.transact(edits, {
+        selection: { end: first ? origin + first.to : end, start: first ? origin + first.from : end },
+        source: 'completion'
+    });
+    if (!result.accepted) {
+        return null;
+    }
+    return snippet.stops.map((stop) => ({ from: origin + stop.from, index: stop.index, to: origin + stop.to }));
+};
+const expandSnippet = (source) => {
+    let cursor = 0, stops = [], text = '', values = new Map();
+    for (let match of source.matchAll(SNIPPET)) {
+        text += source.slice(cursor, match.index);
+        cursor = match.index + match[0].length;
+        if (match[1]) {
+            text += match[1];
+            continue;
+        }
+        let index = Number(match[2] ?? match[5]), value = values.get(index) ?? match[3] ?? match[4]?.split(',')[0] ?? '';
+        values.set(index, value);
+        stops.push({ from: text.length, index, to: text.length + value.length });
+        text += value;
+    }
+    text += source.slice(cursor);
+    stops.sort((a, b) => (a.index || Infinity) - (b.index || Infinity) || a.from - b.from);
+    return { stops, text };
+};
+const fileUri = (cwd, path) => {
+    if (URI.test(path)) {
+        return path;
+    }
+    let normalized = path.replace(/\\/g, '/'), absolute = normalized.startsWith('/') || /^[A-Za-z]:/.test(normalized), full = absolute ? normalized : `${cwd.replace(/\\/g, '/').replace(/\/+$/, '')}/${normalized}`, host = '';
+    let unc = /^\/\/([^/]+)(\/.*)?$/.exec(full);
+    if (unc) {
+        host = unc[1];
+        full = unc[2] ?? '/';
+    }
+    let drive = /^\/?([A-Za-z]:)(.*)$/.exec(full), prefix = drive ? `/${drive[1]}` : '', segments = [];
+    if (drive) {
+        full = drive[2];
+    }
+    let parts = full.split('/');
+    for (let i = 0, n = parts.length; i < n; i++) {
+        let part = parts[i];
+        if (part === '..') {
+            segments.pop();
+        }
+        else if (part && part !== '.') {
+            segments.push(encodeURIComponent(part));
+        }
+    }
+    let trailing = segments.length > 0 && /\/\.{0,2}$/.test(full) ? '/' : '';
+    return `file://${encodeURIComponent(host)}${prefix}/${segments.join('/')}${trailing}`;
+};
+const languageIdFor = (path) => {
+    let name = path.slice(Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\')) + 1), dot = name.lastIndexOf('.');
+    return (dot > 0 && LANGUAGES[name.slice(dot + 1).toLowerCase()]) || 'plaintext';
+};
+const localWords = (text, offset) => {
+    let from = wordStart(text, offset), prefix = text.slice(from, offset), words = new Set();
+    for (let match of text.matchAll(WORD)) {
+        if (match.index === from || match[0] === prefix || !match[0].startsWith(prefix)) {
+            continue;
+        }
+        words.add(match[0]);
+        if (words.size >= WORDS) {
+            break;
+        }
+    }
+    return [...words].sort().map((label) => ({ label }));
+};
+const mapStops = (stops, active, batches) => {
+    let next = stops.map((stop) => ({ ...stop }));
+    for (let i = 0, n = batches.length; i < n; i++) {
+        let batch = batches[i], current = next[active], delta = 0;
+        if (!current) {
+            return null;
+        }
+        for (let j = 0, m = batch.length; j < m; j++) {
+            let edit = batch[j];
+            if (edit.from < current.from || edit.to > current.to) {
+                return null;
+            }
+            delta += edit.insert.length - (edit.to - edit.from);
+        }
+        let end = current.to;
+        for (let j = 0, m = next.length; j < m; j++) {
+            let stop = next[j];
+            if (j === active) {
+                stop.to += delta;
+            }
+            else if (stop.from >= end) {
+                stop.from += delta;
+                stop.to += delta;
+            }
+        }
+    }
+    return next;
+};
+const offsetAt = (doc, position) => {
+    let { character, line } = position;
+    if (!Number.isInteger(line) || line < 0 || line >= doc.lineCount || !Number.isInteger(character) || character < 0) {
+        return null;
+    }
+    return Math.min(doc.lineStart(line) + character, doc.lineEnd(line));
+};
+const positionAt = (doc, offset) => {
+    let line = doc.lineAt(offset);
+    return { character: Math.min(Math.max(0, offset), doc.lineEnd(line)) - doc.lineStart(line), line };
+};
+const spanOf = (doc, range) => {
+    let from = offsetAt(doc, range.start), to = offsetAt(doc, range.end);
+    return from === null || to === null || to < from ? null : { from, to };
+};
+const wordStart = (text, offset) => {
+    let from = offset;
+    while (from > 0 && identifier(text.charCodeAt(from - 1))) {
+        from--;
+    }
+    return from;
+};
+export { applyCompletion, expandSnippet, fileUri, identifier, languageIdFor, localWords, mapStops, offsetAt, positionAt, spanOf, wordStart };

package/build/components/editor/code/services/protocol.d.ts

@@ -0,0 +1,68 @@
+type CompletionItem = {
+    additionalTextEdits?: TextEdit[];
+    commitCharacters?: string[];
+    detail?: string;
+    documentation?: string | {
+        value: string;
+    };
+    filterText?: string;
+    insertText?: string;
+    insertTextFormat?: 1 | 2;
+    kind?: number;
+    label: string;
+    sortText?: string;
+    textEdit?: TextEdit | {
+        insert: Range;
+        newText: string;
+        replace: Range;
+    };
+};
+type CompletionResult = CompletionItem[] | {
+    isIncomplete?: boolean;
+    items: CompletionItem[];
+} | null;
+type Diagnostic = {
+    code?: number | string;
+    message: string;
+    range: Range;
+    severity?: number;
+    source?: string;
+};
+type Hover = {
+    contents: string | unknown[] | {
+        language?: string;
+        value: string;
+    };
+    range?: Range;
+};
+type LanguageTransport = {
+    notify(method: string, params: unknown): Promise<void> | void;
+    request<M extends keyof ServiceResults>(method: M, params: unknown, signal?: AbortSignal): Promise<ServiceResults[M]>;
+    subscribe(listener: (event: Notification) => void): VoidFunction;
+};
+type Notification = {
+    method: string;
+    params: unknown;
+};
+type Position = {
+    character: number;
+    line: number;
+};
+type PublishDiagnostics = {
+    diagnostics: Diagnostic[];
+    uri: string;
+    version?: number;
+};
+type Range = {
+    end: Position;
+    start: Position;
+};
+type ServiceResults = {
+    'textDocument/completion': CompletionResult;
+    'textDocument/hover': Hover | null;
+};
+type TextEdit = {
+    newText: string;
+    range: Range;
+};
+export type { CompletionItem, CompletionResult, Diagnostic, Hover, LanguageTransport, Notification, Position, PublishDiagnostics, Range, ServiceResults, TextEdit };

package/build/components/editor/code/services/protocol.js

@@ -0,0 +1 @@
+export {};