@adecore/editor-react 0.42.0 → 0.44.0

package/src/template-context.ts

@@ -0,0 +1,65 @@
+import type { EditorPosition } from '@adecore/editor';
+import type { EditorLanguage } from './editor-language.ts';
+import type { LiveTemplate, TemplateLanguage, TemplatePlace } from './templates.ts';
+
+/* The completion item kind of a snippet. */
+export const SNIPPET_KIND = 15;
+
+/* Sorts a template row after the rows of the same score that a service answers. */
+export function sortAfterServer(key: string): string {
+    return `￿${key}`;
+}
+
+/* The families a language id counts as; TypeScript builds on JavaScript. */
+export function familiesOf(languageId: string): readonly TemplateLanguage[] {
+    switch (languageId) {
+        case 'javascript':
+        case 'js':
+        case 'mjs':
+        case 'cjs':
+        case 'jsx':
+        case 'javascriptreact':
+            return ['javascript'];
+        case 'typescript':
+        case 'ts':
+        case 'mts':
+        case 'cts':
+        case 'tsx':
+        case 'typescriptreact':
+            return ['javascript', 'typescript'];
+        case 'php':
+            return ['php'];
+        case 'css':
+        case 'scss':
+        case 'less':
+            return ['css'];
+        case 'html':
+        case 'xhtml':
+        case 'vue':
+            return ['html'];
+        case 'xml':
+        case 'svg':
+        case 'xsl':
+            return ['xml'];
+        default:
+            return ['other'];
+    }
+}
+
+/* What a position is written in. */
+export interface TemplateContext {
+    readonly families: readonly TemplateLanguage[];
+    readonly place: TemplatePlace;
+}
+
+/* The families and the place at a position; an editor that cannot tell has the language of the document, in code. */
+export function templateContextAt(language: EditorLanguage, position: EditorPosition): TemplateContext {
+    const place = language.editor.placeAt?.(position);
+
+    return place === undefined ? { families: familiesOf(language.languageId), place: 'code' } : { families: familiesOf(place.language), place: place.kind };
+}
+
+/* Whether a template shares a family with the context and applies to its place. */
+export function templateApplies(template: LiveTemplate, context: TemplateContext): boolean {
+    return template.languages.some((family) => context.families.includes(family)) && (template.places ?? ['code']).includes(context.place);
+}

package/src/templates.ts

@@ -0,0 +1,197 @@
+import { BUILT_IN_LIVE_TEMPLATES, BUILT_IN_POSTFIX_TEMPLATES } from './template-builtins.ts';
+import { checkSnippet } from './snippet.ts';
+
+export { BUILT_IN_LIVE_TEMPLATES, BUILT_IN_POSTFIX_TEMPLATES };
+export { type TemplatesFeature } from './live-templates.ts';
+
+/* The families of language a live template belongs to; a family also matches the languages that build on it. */
+export type TemplateLanguage = 'javascript' | 'typescript' | 'php' | 'css' | 'html' | 'xml' | 'other';
+
+/* What the text at the caret is: code, a comment or a string. */
+export type TemplatePlace = 'code' | 'comment' | 'string';
+
+const MAX_KEY_LENGTH = 40;
+const MAX_BODY_LENGTH = 20_000;
+const POSTFIX_LANGUAGES: readonly string[] = ['javascript', 'typescript', 'php'];
+const LANGUAGES: readonly string[] = ['javascript', 'typescript', 'php', 'css', 'html', 'xml', 'other'];
+const PLACES: readonly string[] = ['code', 'comment', 'string'];
+
+/* A text that Tab expands after its key, in the syntax of a snippet. */
+export interface LiveTemplate {
+    /* Stable; a built-in one is `builtin.<language>.<key>`. */
+    readonly id: string;
+
+    /* One to 40 characters, none of them whitespace. */
+    readonly key: string;
+
+    /* Snippet syntax; the leading tabs of a line are one indentation unit each. */
+    readonly body: string;
+    readonly description?: string;
+    readonly languages: readonly TemplateLanguage[];
+
+    /* Where it applies; `['code']` without it. */
+    readonly places?: readonly TemplatePlace[];
+
+    /* What Insert Live Template sorts by; the first language without it. */
+    readonly group?: string;
+}
+
+/* A text that Tab expands after a dot and its key, around the expression before the dot. */
+export interface PostfixTemplate {
+    readonly id: string;
+
+    /* Without the dot; identifier characters only. */
+    readonly key: string;
+
+    /* Snippet syntax, in which `$EXPR` is the expression. */
+    readonly body: string;
+    readonly description?: string;
+
+    /* Shown at the end of its row, as in `if (expr) {}`. */
+    readonly example?: string;
+    readonly languages: readonly ('javascript' | 'typescript' | 'php')[];
+
+    /* `any` without it. */
+    readonly expression?: 'any' | 'statement';
+}
+
+/* Each is on unless false. */
+export interface TemplateSettings {
+    /* Live templates are rows of the suggestion list. */
+    readonly liveInCompletion?: boolean;
+
+    /* Tab after a dot and a key expands a postfix template. */
+    readonly postfix?: boolean;
+
+    /* Postfix templates are rows of the suggestion list. */
+    readonly postfixInCompletion?: boolean;
+}
+
+/* What Save as Live Template hands the host. */
+export interface LiveTemplateDraft {
+    readonly body: string;
+    readonly languages: readonly TemplateLanguage[];
+    readonly places: readonly TemplatePlace[];
+}
+
+export interface TemplateRegistryOptions {
+    /* Whether the built-in templates are part of the registry; true by default. */
+    readonly builtins?: boolean;
+}
+
+export interface TemplateUpdate {
+    readonly live?: readonly LiveTemplate[];
+    readonly postfix?: readonly PostfixTemplate[];
+
+    /* Ids of the built-in templates that are off. */
+    readonly disabled?: readonly string[];
+    readonly settings?: TemplateSettings;
+}
+
+/*
+ * The templates the editors of a project know: the built-in ones and the ones a host sets. A host that keeps
+ * templates feeds them through `set`, and the editors read the registry on every use.
+ */
+export class TemplateRegistry {
+    private readonly builtins: boolean;
+    private readonly listeners = new Set<() => void>();
+    private own: { live: readonly LiveTemplate[]; postfix: readonly PostfixTemplate[] } = { live: [], postfix: [] };
+    private off: ReadonlySet<string> = new Set();
+    private current: Required<TemplateSettings> = { liveInCompletion: true, postfix: true, postfixInCompletion: true };
+    private liveList: readonly LiveTemplate[];
+    private postfixList: readonly PostfixTemplate[];
+
+    constructor(options: TemplateRegistryOptions = {}) {
+        this.builtins = options.builtins !== false;
+        this.liveList = this.listed(BUILT_IN_LIVE_TEMPLATES, []);
+        this.postfixList = this.listed(BUILT_IN_POSTFIX_TEMPLATES, []);
+    }
+
+    /* The built-in templates that are not disabled, then the host's. */
+    get live(): readonly LiveTemplate[] {
+        return this.liveList;
+    }
+
+    get postfix(): readonly PostfixTemplate[] {
+        return this.postfixList;
+    }
+
+    get settings(): Required<TemplateSettings> {
+        return this.current;
+    }
+
+    /* Replaces what the update names. A template that fails `checkTemplate` is dropped; this never throws. */
+    set(update: TemplateUpdate): void {
+        this.own = {
+            live: update.live === undefined ? this.own.live : update.live.filter((template) => checkTemplate(template, 'live') === null),
+            postfix: update.postfix === undefined ? this.own.postfix : update.postfix.filter((template) => checkTemplate(template, 'postfix') === null)
+        };
+        this.off = update.disabled === undefined ? this.off : new Set(update.disabled);
+
+        if (update.settings !== undefined) {
+            this.current = {
+                liveInCompletion: update.settings.liveInCompletion !== false,
+                postfix: update.settings.postfix !== false,
+                postfixInCompletion: update.settings.postfixInCompletion !== false
+            };
+        }
+
+        this.liveList = this.listed(BUILT_IN_LIVE_TEMPLATES, this.own.live);
+        this.postfixList = this.listed(BUILT_IN_POSTFIX_TEMPLATES, this.own.postfix);
+
+        for (const listener of [...this.listeners]) {
+            listener();
+        }
+    }
+
+    /* Calls `listener` after every `set`. Returns the function that stops it. */
+    onChange(listener: () => void): () => void {
+        this.listeners.add(listener);
+
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+
+    private listed<T extends { readonly id: string }>(builtins: readonly T[], own: readonly T[]): readonly T[] {
+        return [...(this.builtins ? builtins.filter((template) => !this.off.has(template.id)) : []), ...own];
+    }
+}
+
+/*
+ * Why a template cannot be used, in English for a host to show, or null. `kind` says which rules apply; without it a
+ * template with an `expression` or an `example` counts as a postfix one.
+ */
+export function checkTemplate(template: LiveTemplate | PostfixTemplate, kind?: 'live' | 'postfix'): string | null {
+    const postfix = kind === undefined ? 'expression' in template || 'example' in template : kind === 'postfix';
+
+    if (template.id === '') {
+        return 'The template has no id.';
+    }
+
+    if (template.key === '' || template.key.length > MAX_KEY_LENGTH) {
+        return `The key is one to ${MAX_KEY_LENGTH} characters.`;
+    }
+
+    if (postfix ? !/^[\p{L}\p{N}_$]+$/u.test(template.key) : /\s/.test(template.key)) {
+        return postfix ? 'The key holds letters, digits, underscores and dollar signs only.' : 'The key holds no whitespace.';
+    }
+
+    if (template.body.trim() === '') {
+        return 'The text is empty.';
+    }
+
+    if (template.body.length > MAX_BODY_LENGTH) {
+        return `The text is longer than ${MAX_BODY_LENGTH} characters.`;
+    }
+
+    if (template.languages.length === 0 || template.languages.some((language) => !(postfix ? POSTFIX_LANGUAGES : LANGUAGES).includes(language))) {
+        return 'The languages are empty or not known.';
+    }
+
+    if (!postfix && (template as LiveTemplate).places?.some((place) => !PLACES.includes(place)) === true) {
+        return 'The places are not known.';
+    }
+
+    return checkSnippet(template.body);
+}

package/src/testing.ts

@@ -38,7 +38,24 @@ import {
     type SignatureHelpContext,
     type TextEdit,
     type WorkspaceEdit,
-    type WorkspaceSymbolResult
+    type WorkspaceSymbolResult,
+    type Color,
+    type ColorInformation,
+    type ColorPresentation,
+    type DocumentLink,
+    type InlineCompletionContext,
+    type InlineCompletionResult,
+    type InlineValue,
+    type InlineValueContext,
+    type LinkedEditingRanges,
+    type Moniker,
+    type PreviousResultId,
+    type ServerMessage,
+    type ShowDocumentParams,
+    type ShowDocumentResult,
+    type TextDocumentSaveReason,
+    type TypeHierarchyItem,
+    type WorkspaceDiagnosticReport
 } from '@adecore/lsp';
 
 export { ManualTimers } from './timers.ts';
@@ -57,6 +74,8 @@ export class FakeLanguageService implements LanguageService {
     private readonly answers = new Map<string, (call: LanguageCall) => unknown>();
     private readonly diagnostics = new Set<(report: DiagnosticsReport) => void>();
     private readonly changes = new Set<(uri: string) => void>();
+    private readonly messages = new Set<(message: ServerMessage) => void>();
+    private showDocument: ((params: ShowDocumentParams) => Promise<ShowDocumentResult>) | null = null;
 
     respond(method: string, answer: (call: LanguageCall) => unknown, provider: ProviderOptions = {}): void {
         this.answers.set(method, answer);
@@ -271,4 +290,110 @@ export class FakeLanguageService implements LanguageService {
     resolveCodeLens(uri: string, lens: CodeLens, options: LanguageRequestOptions = {}): Promise<CodeLens> {
         return this.request<CodeLens>('codeLens/resolve', uri, lens, options);
     }
+
+    documentLinks(uri: string, options: LanguageRequestOptions = {}): Promise<DocumentLink[] | null> {
+        return this.request<DocumentLink[] | null>('textDocument/documentLink', uri, {}, options);
+    }
+
+    resolveDocumentLink(uri: string, link: DocumentLink, options: LanguageRequestOptions = {}): Promise<DocumentLink> {
+        return this.request<DocumentLink>('documentLink/resolve', uri, link, options);
+    }
+
+    documentColors(uri: string, options: LanguageRequestOptions = {}): Promise<ColorInformation[] | null> {
+        return this.request<ColorInformation[] | null>('textDocument/documentColor', uri, {}, options);
+    }
+
+    colorPresentations(uri: string, color: Color, range: Range, options: LanguageRequestOptions = {}): Promise<ColorPresentation[] | null> {
+        return this.request<ColorPresentation[] | null>('textDocument/colorPresentation', uri, { color, range }, options);
+    }
+
+    linkedEditingRanges(uri: string, position: Position, options: LanguageRequestOptions = {}): Promise<LinkedEditingRanges | null> {
+        return this.request<LinkedEditingRanges | null>('textDocument/linkedEditingRange', uri, { position }, options);
+    }
+
+    monikers(uri: string, position: Position, options: LanguageRequestOptions = {}): Promise<Moniker[] | null> {
+        return this.request<Moniker[] | null>('textDocument/moniker', uri, { position }, options);
+    }
+
+    prepareTypeHierarchy(uri: string, position: Position, options: LanguageRequestOptions = {}): Promise<TypeHierarchyItem[] | null> {
+        return this.request<TypeHierarchyItem[] | null>('textDocument/prepareTypeHierarchy', uri, { position }, options);
+    }
+
+    supertypes(uri: string, item: TypeHierarchyItem, options: LanguageRequestOptions = {}): Promise<TypeHierarchyItem[] | null> {
+        return this.request<TypeHierarchyItem[] | null>('typeHierarchy/supertypes', uri, { item }, options);
+    }
+
+    subtypes(uri: string, item: TypeHierarchyItem, options: LanguageRequestOptions = {}): Promise<TypeHierarchyItem[] | null> {
+        return this.request<TypeHierarchyItem[] | null>('typeHierarchy/subtypes', uri, { item }, options);
+    }
+
+    inlineValues(uri: string, range: Range, context: InlineValueContext, options: LanguageRequestOptions = {}): Promise<InlineValue[] | null> {
+        return this.request<InlineValue[] | null>('textDocument/inlineValue', uri, { range, context }, options);
+    }
+
+    inlineCompletions(
+        uri: string,
+        position: Position,
+        context: InlineCompletionContext,
+        options: LanguageRequestOptions = {}
+    ): Promise<InlineCompletionResult> {
+        return this.request<InlineCompletionResult>('textDocument/inlineCompletion', uri, { position, context }, options);
+    }
+
+    rangesFormatting(uri: string, ranges: readonly Range[], formatting: FormattingOptions, options: LanguageRequestOptions = {}): Promise<TextEdit[] | null> {
+        return this.request<TextEdit[] | null>('textDocument/rangesFormatting', uri, { ranges, options: formatting }, options);
+    }
+
+    async willSave(uri: string, reason: TextDocumentSaveReason = 1): Promise<void> {
+        this.calls.push({ method: 'textDocument/willSave', uri, params: { reason }, options: {} });
+    }
+
+    async willSaveWaitUntil(uri: string, reason: TextDocumentSaveReason = 1, options: LanguageRequestOptions = {}): Promise<TextEdit[] | null> {
+        return this.supports('textDocument/willSaveWaitUntil', uri)
+            ? this.request<TextEdit[] | null>('textDocument/willSaveWaitUntil', uri, { reason }, options)
+            : null;
+    }
+
+    workspaceDiagnostics(
+        uri: string,
+        previousResultIds: readonly PreviousResultId[] = [],
+        options: LanguageRequestOptions = {}
+    ): Promise<WorkspaceDiagnosticReport> {
+        return this.request<WorkspaceDiagnosticReport>('workspace/diagnostic', uri, { previousResultIds }, options);
+    }
+
+    async textDocumentContent(uri: string, options: LanguageRequestOptions = {}): Promise<string | null> {
+        if (!this.supports('workspace/textDocumentContent', uri)) {
+            return null;
+        }
+        return (await this.request<{ text: string } | null>('workspace/textDocumentContent', uri, { uri }, options))?.text ?? null;
+    }
+
+    onServerMessage(listener: (message: ServerMessage) => void): Disposable {
+        this.messages.add(listener);
+        return { dispose: () => this.messages.delete(listener) };
+    }
+
+    onShowDocument(handler: (params: ShowDocumentParams) => Promise<ShowDocumentResult>): Disposable {
+        this.showDocument = handler;
+        return {
+            dispose: () => {
+                if (this.showDocument === handler) {
+                    this.showDocument = null;
+                }
+            }
+        };
+    }
+
+    /* Sends a message as a server would. */
+    message(message: ServerMessage): void {
+        for (const listener of this.messages) {
+            listener(message);
+        }
+    }
+
+    /* Asks the host to show a document as a server would; false when nothing handles it. */
+    async show(params: ShowDocumentParams): Promise<boolean> {
+        return (await this.showDocument?.(params))?.success ?? false;
+    }
 }