@adecore/editor 0.22.1 → 0.23.0

package/dist/search-protocol.d.ts

@@ -0,0 +1,103 @@
+import type { FindMatch } from '@adecore/editor-core';
+import type { EditorFindQuery } from './types.ts';
+export declare const SEARCH_LIMIT = 10000;
+export declare const MAX_REPLACEMENT_PAGE = 10000;
+export declare const MAX_REPLACEMENT_CHARACTERS = 4000000;
+export interface EditorSearchSnapshot {
+    readonly revision: number;
+    readonly text: string;
+}
+export interface EditorSearchOptions {
+    readonly deadline?: number;
+    readonly from?: number;
+    readonly to?: number;
+    readonly maxResults?: number;
+}
+export interface EditorSearchResult {
+    readonly revision: number;
+    readonly ranges: Uint32Array;
+    readonly limited: boolean;
+}
+export interface EditorSearchRange {
+    readonly from: number;
+    readonly to: number;
+}
+export interface EditorSearchNextOptions {
+    readonly deadline?: number;
+    readonly from?: number;
+    readonly to?: number;
+    readonly backwards?: boolean;
+    readonly wrap?: boolean;
+}
+export interface EditorSearchReplacementOptions {
+    readonly deadline?: number;
+    readonly from?: number;
+    readonly to?: number;
+    readonly preserveCase?: boolean;
+    readonly maxEdits?: number;
+    readonly maxCharacters?: number;
+}
+export interface EditorSearchReplacements {
+    readonly revision: number;
+    readonly ranges: Uint32Array;
+    readonly text: string;
+    readonly next: number | null;
+}
+export type EditorSearchMatch = Omit<FindMatch, 'revision' | 'text'>;
+interface SearchInput {
+    readonly id: number;
+    readonly revision: number;
+    readonly text?: string;
+    readonly query: EditorFindQuery;
+}
+export type EditorSearchInput = (SearchInput & {
+    readonly type: 'search';
+    readonly from?: number;
+    readonly to?: number;
+    readonly maxResults: number;
+}) | (SearchInput & {
+    readonly type: 'match';
+    readonly from: number;
+    readonly to: number;
+}) | (SearchInput & {
+    readonly type: 'next';
+    readonly offset: number;
+    readonly from?: number;
+    readonly to?: number;
+    readonly backwards?: boolean;
+    readonly wrap?: boolean;
+}) | (SearchInput & {
+    readonly type: 'replacements';
+    readonly from?: number;
+    readonly to?: number;
+    readonly replacement: string;
+    readonly preserveCase?: boolean;
+    readonly maxEdits: number;
+    readonly maxCharacters: number;
+});
+export type EditorSearchOutput = {
+    readonly type: 'ready';
+} | ({
+    readonly type: 'matches';
+    readonly id: number;
+} & EditorSearchResult) | {
+    readonly type: 'match';
+    readonly id: number;
+    readonly revision: number;
+    readonly match: EditorSearchMatch | null;
+} | {
+    readonly type: 'next';
+    readonly id: number;
+    readonly revision: number;
+    readonly range: EditorSearchRange | null;
+} | ({
+    readonly type: 'replacements';
+    readonly id: number;
+} & EditorSearchReplacements) | {
+    readonly type: 'error';
+    readonly id: number;
+    readonly revision: number;
+    readonly kind: 'syntax' | 'range' | 'snapshot' | 'error';
+    readonly message: string;
+};
+export {};

package/dist/search-protocol.js

@@ -0,0 +1,3 @@
+export const SEARCH_LIMIT = 10000;
+export const MAX_REPLACEMENT_PAGE = 10000;
+export const MAX_REPLACEMENT_CHARACTERS = 4_000_000;

package/dist/search-worker.d.ts

@@ -0,0 +1,11 @@
+import { type EditorSearchInput, type EditorSearchOutput } from './search-protocol.ts';
+export { createSearchClient, EditorSearchError, type EditorSearchClient, type EditorSearchClientOptions, type EditorSearchErrorKind } from './search-client.ts';
+export type { EditorSearchInput, EditorSearchOptions, EditorSearchOutput, EditorSearchResult, EditorSearchSnapshot, EditorSearchMatch, EditorSearchRange, EditorSearchNextOptions, EditorSearchReplacementOptions, EditorSearchReplacements } from './search-protocol.ts';
+export interface EditorSearchWorkerEndpoint {
+    addEventListener(type: 'message', listener: (event: MessageEvent<EditorSearchInput>) => void): void;
+    removeEventListener(type: 'message', listener: (event: MessageEvent<EditorSearchInput>) => void): void;
+    postMessage(message: EditorSearchOutput, options?: {
+        transfer: Transferable[];
+    }): void;
+}
+export declare function serveEditorSearch(endpoint: EditorSearchWorkerEndpoint): () => void;

package/dist/search-worker.js

@@ -0,0 +1,137 @@
+import { iterateMatches, findMatchFrom, replacementText } from '@adecore/editor-core';
+import { SEARCH_LIMIT, MAX_REPLACEMENT_PAGE, MAX_REPLACEMENT_CHARACTERS } from './search-protocol.js';
+export { createSearchClient, EditorSearchError } from './search-client.js';
+const MAX_CAPTURE_CHARACTERS = 4_000_000;
+function findOptions(request) {
+    return { caseSensitive: request.query.caseSensitive, wholeWord: request.query.wholeWord, regex: request.query.regex, from: request.from, to: request.to };
+}
+function captureMatch(found) {
+    let characters = 0;
+    for (const value of found.captures) {
+        characters += value?.length ?? 0;
+    }
+    for (const value of Object.values(found.groups ?? {})) {
+        characters += value?.length ?? 0;
+    }
+    if (characters > MAX_CAPTURE_CHARACTERS) {
+        throw new RangeError('Search captures exceed the response size limit.');
+    }
+    return { from: found.from, to: found.to, captures: found.captures, groups: found.groups, regex: found.regex };
+}
+function searchReply(request, snapshot) {
+    const { text } = snapshot;
+    const options = findOptions(request);
+    const header = { id: request.id, revision: request.revision };
+    if (request.type === 'next') {
+        let found = null;
+        if (request.backwards) {
+            let last = null;
+            for (const match of iterateMatches(text, request.query.text, request.revision, options)) {
+                last = match;
+                if (match.from < request.offset) {
+                    found = match;
+                }
+                else if (found !== null || request.wrap === false) {
+                    break;
+                }
+            }
+            found ??= request.wrap === false ? null : last;
+        }
+        else {
+            found = findMatchFrom(text, request.query.text, request.revision, request.offset, { ...options, wrap: request.wrap });
+        }
+        return { type: 'next', ...header, range: found === null ? null : { from: found.from, to: found.to } };
+    }
+    if (request.type === 'match') {
+        const found = iterateMatches(text, request.query.text, request.revision, { ...options, maxResults: 1 }).next().value;
+        return { type: 'match', ...header, match: found && found.from === request.from && found.to === request.to ? captureMatch(found) : null };
+    }
+    if (request.type === 'replacements') {
+        if (!Number.isInteger(request.maxEdits) ||
+            request.maxEdits < 1 ||
+            request.maxEdits > MAX_REPLACEMENT_PAGE ||
+            !Number.isInteger(request.maxCharacters) ||
+            request.maxCharacters < 0 ||
+            request.maxCharacters > MAX_REPLACEMENT_CHARACTERS) {
+            throw new RangeError('Replacement pages need a positive edit limit and a bounded character limit.');
+        }
+        const ranges = [], pieces = [];
+        let characters = 0;
+        let resume = request.from ?? 0;
+        let next = null;
+        for (const match of iterateMatches(text, request.query.text, request.revision, { ...options, maxResults: request.maxEdits + 1 })) {
+            if (pieces.length === request.maxEdits) {
+                next = resume;
+                break;
+            }
+            const replacement = replacementText(text, match, request.replacement, false, request.preserveCase, request.maxCharacters);
+            if (characters + replacement.length > request.maxCharacters) {
+                if (pieces.length === 0) {
+                    throw new RangeError('One replacement exceeds the response size limit.');
+                }
+                next = resume;
+                break;
+            }
+            characters += replacement.length;
+            ranges.push(match.from, match.to, replacement.length);
+            pieces.push(replacement);
+            // Resuming after an empty match must skip the same full code point as the matcher.
+            resume = match.to + (match.from === match.to ? ((text.codePointAt(match.to) ?? 0) > 0xffff ? 2 : 1) : 0);
+        }
+        return { type: 'replacements', ...header, ranges: Uint32Array.from(ranges), text: pieces.join(''), next };
+    }
+    if (!Number.isInteger(request.maxResults) || request.maxResults < 0 || request.maxResults > SEARCH_LIMIT) {
+        throw new RangeError(`Search results must be limited to ${SEARCH_LIMIT} matches or fewer.`);
+    }
+    const offsets = [];
+    let limited = false;
+    for (const match of iterateMatches(text, request.query.text, request.revision, { ...options, maxResults: request.maxResults + 1 })) {
+        if (offsets.length === request.maxResults * 2) {
+            limited = true;
+            break;
+        }
+        offsets.push(match.from, match.to);
+    }
+    return { type: 'matches', ...header, ranges: Uint32Array.from(offsets), limited };
+}
+/* A running RegExp can only be interrupted by terminating its worker. */
+export function serveEditorSearch(endpoint) {
+    let snapshot;
+    const listener = ({ data: request }) => {
+        try {
+            if (!Number.isSafeInteger(request.revision) || request.revision < 0) {
+                throw new RangeError('The search revision must be a nonnegative safe integer.');
+            }
+            if (request.text !== undefined) {
+                snapshot = { revision: request.revision, text: request.text };
+            }
+            if (snapshot === undefined || snapshot.revision !== request.revision) {
+                endpoint.postMessage({
+                    type: 'error',
+                    id: request.id,
+                    revision: request.revision,
+                    kind: 'snapshot',
+                    message: 'The search worker needs the text of this revision.'
+                });
+                return;
+            }
+            const response = searchReply(request, snapshot);
+            endpoint.postMessage(response, response.type === 'matches' || response.type === 'replacements' ? { transfer: [response.ranges.buffer] } : undefined);
+        }
+        catch (error) {
+            endpoint.postMessage({
+                type: 'error',
+                id: request.id,
+                revision: request.revision,
+                kind: error instanceof SyntaxError ? 'syntax' : error instanceof RangeError ? 'range' : 'error',
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+    };
+    endpoint.addEventListener('message', listener);
+    endpoint.postMessage({ type: 'ready' });
+    return () => {
+        endpoint.removeEventListener('message', listener);
+        snapshot = undefined;
+    };
+}

package/dist/semantic.d.ts

@@ -1,8 +1,9 @@
-import type { LineToken } from './types.ts';
+import type { LineToken, LineTokenKind } from './types.ts';
 export interface SemanticSpan {
     readonly from: number;
     readonly to: number;
     readonly color: string;
     readonly fontStyle: number;
+    readonly within?: LineTokenKind;
 }
 export declare function overlayTokens(base: readonly LineToken[], spans: readonly SemanticSpan[]): LineToken[];

package/dist/semantic.js

@@ -37,7 +37,12 @@ export function overlayTokens(base, spans) {
             }
             else {
                 const stop = Math.min(end, current.to);
-                push(stop - at, current.color, current.fontStyle);
+                if (current.within === undefined || token.kind === current.within) {
+                    push(stop - at, current.color, current.fontStyle);
+                }
+                else {
+                    push(stop - at, token.color, token.fontStyle);
+                }
                 at = stop;
             }
         }

package/dist/shiki-document.d.ts

@@ -0,0 +1,8 @@
+import type { Highlighter, ShikiTransformer, ThemedToken } from 'shiki';
+export interface ShikiDocumentTokenOptions {
+    readonly reset?: ReadonlySet<number>;
+    readonly tokenizeMaxLineLength?: number;
+    readonly tokenizeTimeLimit?: number;
+}
+export declare function shikiDocumentHighlighter(highlighter: () => Promise<Highlighter>, blocks: readonly string[], language: string, theme: string, transformers?: readonly ShikiTransformer[]): (index: number) => Promise<string>;
+export declare function shikiDocumentTokens(highlighter: () => Promise<Highlighter>, blocks: readonly string[], language: string, theme: string, options?: ShikiDocumentTokenOptions): (index: number) => Promise<ThemedToken[][]>;

package/dist/shiki-document.js

@@ -0,0 +1,93 @@
+import { documentLanguageOf, loadGrammar } from './shiki.js';
+export function shikiDocumentHighlighter(highlighter, blocks, language, theme, transformers = []) {
+    return documentHighlighter(highlighter, blocks, language, theme, (loaded, code, grammar, theme, state) => {
+        let root;
+        const value = loaded.codeToHtml(code, {
+            lang: grammar,
+            theme,
+            grammarState: state,
+            transformers: [
+                ...transformers,
+                {
+                    root(node) {
+                        root = node;
+                    }
+                }
+            ]
+        });
+        return { value, state: root === undefined ? undefined : loaded.getLastGrammarState(root) };
+    });
+}
+export function shikiDocumentTokens(highlighter, blocks, language, theme, options = {}) {
+    return documentHighlighter(highlighter, blocks, language, theme, (loaded, code, grammar, theme, state) => {
+        // Shiki 4.4 caches the active theme by argument identity, even after a same-name replacement.
+        const value = loaded.codeToTokensBase(code, {
+            lang: grammar,
+            theme: loaded.getTheme(theme),
+            grammarState: state,
+            tokenizeMaxLineLength: options.tokenizeMaxLineLength,
+            tokenizeTimeLimit: options.tokenizeTimeLimit
+        });
+        return { value, state: loaded.getLastGrammarState(value) };
+    }, options.reset);
+}
+function documentHighlighter(highlighter, blocks, language, theme, render, reset = new Set()) {
+    const resets = new Set(reset);
+    // A CR before the removed LF belongs to the block separator, not the last source line.
+    const code = blocks.map((block, index) => (index < blocks.length - 1 ? block.replace(/\r$/, '') : block));
+    let prepared;
+    let pending = Promise.resolve();
+    let grammar;
+    let themeRegistration;
+    let state;
+    let values = [];
+    const prepare = async () => {
+        const loaded = await highlighter();
+        if (!loaded.getLoadedThemes().includes(theme)) {
+            await loaded.loadTheme(theme);
+        }
+        const documentLanguage = documentLanguageOf(language);
+        const known = loaded.getLoadedLanguages().includes(documentLanguage) || documentLanguage in loaded.getBundledLanguages() || documentLanguage !== language;
+        const grammar = known && (await loadGrammar(loaded, documentLanguage, code.join('\n'))) ? documentLanguage : 'text';
+        return { highlighter: loaded, language: grammar };
+    };
+    return (index) => {
+        if (!Number.isInteger(index) || index < 0 || index >= code.length) {
+            return Promise.reject(new RangeError('The highlighted block index is outside the document.'));
+        }
+        const result = pending.then(async () => {
+            prepared ??= prepare().catch((error) => {
+                prepared = undefined;
+                throw error;
+            });
+            const { highlighter: loaded, language: grammarId } = await prepared;
+            const refresh = () => {
+                const currentGrammar = grammarId === 'text' ? undefined : loaded.getLanguage(grammarId);
+                const currentTheme = loaded.getTheme(theme);
+                // Loading an embedded language rebuilds Shiki's grammar and invalidates its old states.
+                if (grammar !== currentGrammar || themeRegistration !== currentTheme) {
+                    grammar = currentGrammar;
+                    themeRegistration = currentTheme;
+                    state = undefined;
+                    values = [];
+                }
+            };
+            refresh();
+            while (values.length <= index) {
+                const block = values.length;
+                const rendered = render(loaded, code[block], grammarId, theme, state);
+                state = resets.has(block + 1) ? undefined : rendered.state;
+                values.push(rendered.value);
+                if (block < index) {
+                    // A jump deep into a file must leave room for input and painting between blocks.
+                    await new Promise((resolve) => setTimeout(resolve, 0));
+                    refresh();
+                }
+            }
+            return values[index];
+        });
+        // A failed theme or grammar load can be retried without rejecting every later request.
+        pending = result.then(() => undefined, () => undefined);
+        return result;
+    };
+}

package/dist/shiki-worker.d.ts

@@ -0,0 +1,65 @@
+import type { Highlighter, ThemeRegistration } from 'shiki';
+import type { LineToken } from './types.ts';
+export interface DiffSyntaxDocument {
+    readonly language: string;
+    readonly theme: string;
+    readonly blocks: readonly string[];
+    readonly resets: readonly number[];
+}
+export type DiffSyntaxInput = {
+    readonly type: 'start';
+    readonly themes: readonly ThemeRegistration[];
+    readonly maxLines: number;
+} | {
+    readonly type: 'request';
+    readonly generation: number;
+    readonly index: number;
+    readonly document?: DiffSyntaxDocument;
+} | {
+    readonly type: 'cancel';
+    readonly generation: number;
+} | {
+    readonly type: 'dispose';
+    readonly generation: number;
+};
+export interface DiffSyntaxTokens {
+    readonly type: 'tokens';
+    readonly generation: number;
+    readonly index: number;
+    readonly colors: readonly string[];
+    readonly foreground: string;
+    readonly background: string;
+    readonly lines: Uint32Array;
+    readonly tokens: Uint32Array;
+}
+export type DiffSyntaxOutput = DiffSyntaxTokens | {
+    readonly type: 'ready';
+} | {
+    readonly type: 'error';
+    readonly message: string;
+} | {
+    readonly type: 'failed';
+    readonly generation: number;
+    readonly index: number;
+    readonly reason: 'missing' | 'highlight';
+    readonly message: string;
+};
+export interface DiffSyntaxService {
+    handle(message: DiffSyntaxInput): Promise<void>;
+    dispose(): void;
+}
+export interface DiffSyntaxServiceOptions {
+    readonly highlighter: () => Promise<Highlighter>;
+    readonly send: (message: DiffSyntaxOutput, transfer?: Transferable[]) => void;
+    readonly yield?: () => Promise<void>;
+}
+export declare function lineTokensOf(packet: DiffSyntaxTokens, line: number, text: string): LineToken[];
+export declare function createSyntaxService(options: DiffSyntaxServiceOptions): DiffSyntaxService;
+export interface DiffSyntaxWorkerEndpoint {
+    addEventListener(type: 'message', listener: (event: MessageEvent<DiffSyntaxInput>) => void): void;
+    removeEventListener(type: 'message', listener: (event: MessageEvent<DiffSyntaxInput>) => void): void;
+    postMessage(message: DiffSyntaxOutput, options?: {
+        transfer: Transferable[];
+    }): void;
+}
+export declare function serveDiffSyntax(endpoint: DiffSyntaxWorkerEndpoint): () => void;