monaco-yql-languages 1.2.1 → 1.4.0

package/build/completion.d.ts

@@ -2,7 +2,7 @@ import type { CancellationToken, Position, editor, languages } from './fillers/m
 export type CompletionListProvider = {
     (content: string, offset: number, signal?: AbortSignal | null): Promise<string[]>;
 };
-export declare function provideCompletionItems(getCompletionList: CompletionListProvider): (model: editor.ITextModel, position: Position, context: languages.CompletionContext, token: CancellationToken) => languages.ProviderResult<languages.CompletionList>;
+export declare function provideCompletionItems(getCompletionList: CompletionListProvider, preserveOrder?: boolean): (model: editor.ITextModel, position: Position, context: languages.CompletionContext, token: CancellationToken) => languages.ProviderResult<languages.CompletionList>;
 export type CompletionLists = Partial<Record<`${Uncapitalize<keyof typeof languages.CompletionItemKind>}List`, Readonly<string[]>>>;
 export declare function getCompletionItemsProvider(completions: CompletionLists, completionItemKind: typeof languages.CompletionItemKind): {
     provideCompletionItems(model: editor.ITextModel, position: Position, _context: languages.CompletionContext, _token: CancellationToken): languages.CompletionList | undefined;

package/build/completion.js

@@ -1,5 +1,6 @@
+import { suggestionIndexToWeight } from './utils';
 const allUpperCaseRe = new RegExp('^[$A-Z_\\s]+$');
-export function provideCompletionItems(getCompletionList) {
+export function provideCompletionItems(getCompletionList, preserveOrder) {
     return (model, position, context, token) => {
         const controller = new AbortController();
         const signal = controller.signal;
@@ -49,7 +50,12 @@ export function provideCompletionItems(getCompletionList) {
                     range,
                 });
             }
-            return { suggestions, incomplete: suggestions.length > 0 };
+            return {
+                suggestions: preserveOrder
+                    ? suggestions.map((item, index) => (Object.assign(Object.assign({}, item), { sortText: suggestionIndexToWeight(index) })))
+                    : suggestions,
+                incomplete: suggestions.length > 0,
+            };
         });
     };
 }

package/build/utils.d.ts

@@ -0,0 +1 @@
+export declare function suggestionIndexToWeight(index: number): string;

package/build/utils.js

@@ -0,0 +1,11 @@
+const alphabet = 'abcdefghijklmnopqrstuvwxyz';
+export function suggestionIndexToWeight(index) {
+    const characterInsideAlphabet = alphabet[index];
+    if (characterInsideAlphabet) {
+        return characterInsideAlphabet;
+    }
+    const duplicateTimes = Math.floor(index / alphabet.length);
+    const remains = index % alphabet.length;
+    const lastCharacter = alphabet.slice(-1);
+    return lastCharacter.repeat(duplicateTimes) + alphabet[remains];
+}

package/build/yql/autocomplete/__tests__/generateSuggestions.test.d.ts

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

package/build/yql/autocomplete/__tests__/generateSuggestions.test.js

@@ -0,0 +1,307 @@
+import { generateColumnsSuggestion, generateEntitiesSuggestion } from '../generateSuggestions';
+jest.mock('../../../fillers/monaco-editor-core', () => ({
+    languages: {
+        CompletionItemKind: {
+            Variable: 1,
+        },
+        CompletionItemInsertTextRule: {
+            None: 0,
+            InsertAsSnippet: 1,
+        },
+    },
+    IRange: {
+        startLineNumber: 1,
+        startColumn: 1,
+        endLineNumber: 1,
+        endColumn: 1,
+    },
+}));
+jest.mock('../utils', () => ({
+    suggestionIndexToWeight: (_index) => '0',
+    removeStringDuplicates: (value) => value !== null && value !== void 0 ? value : [],
+    isVariable: (_value) => false,
+    removeBackticks: (value) => value,
+    wrapStringToBackticks: (value) => value,
+    getSuggestionIndex: (_value) => 0,
+}));
+const mockRange = {
+    startLineNumber: 1,
+    startColumn: 1,
+    endLineNumber: 1,
+    endColumn: 1,
+};
+describe('generateColumnsSuggestion', () => {
+    it('should return an empty array if suggestColumns is undefined', async () => {
+        expect(await generateColumnsSuggestion(mockRange, undefined, [], [])).toEqual([]);
+        expect(await generateColumnsSuggestion(mockRange, { tables: [] }, [], [])).toEqual([]);
+    });
+    it('should generate suggestions for a single table with columns', async () => {
+        const result = await generateColumnsSuggestion(mockRange, {
+            tables: [{ name: 'table1', columns: ['col1', 'col2'] }],
+        }, [], []);
+        expect(result).toEqual([
+            {
+                label: { label: 'col1', description: undefined },
+                insertText: 'col1',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'aa',
+            },
+            {
+                label: { label: 'col2', description: undefined },
+                insertText: 'col2',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'ab',
+            },
+        ]);
+    });
+    it('should generate suggestions for multiple tables with columns', async () => {
+        const result = await generateColumnsSuggestion(mockRange, {
+            tables: [
+                { name: 'table1', columns: ['col1'] },
+                { name: 'table2', columns: ['col2'] },
+            ],
+        }, [], []);
+        expect(result).toEqual([
+            {
+                label: { label: 'table1.col1', description: undefined },
+                insertText: 'table1.col1',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'aa',
+            },
+            {
+                label: { label: 'table2.col2', description: undefined },
+                insertText: 'table2.col2',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'ab',
+            },
+        ]);
+    });
+    it('should generate suggestions for tables with aliases', async () => {
+        const result = await generateColumnsSuggestion(mockRange, {
+            tables: [{ name: 'table1', columns: ['col1'], alias: 't1' }],
+        }, [], []);
+        expect(result).toEqual([
+            {
+                label: { label: 't1.col1', description: undefined },
+                insertText: 't1.col1',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'aa',
+            },
+        ]);
+    });
+    it('should handle variables as table sources', async () => {
+        const result = await generateColumnsSuggestion(mockRange, {
+            tables: [{ name: '$var1', columns: ['col1'] }],
+            all: false,
+        }, [{ name: 'var1', value: { columns: ['col1'] } }], []);
+        expect(result).toEqual([
+            {
+                label: { label: 'col1', description: undefined },
+                insertText: 'col1',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'aa',
+            },
+        ]);
+    });
+    it('should generate all columns suggestion when multiple tables are present', async () => {
+        const result = await generateColumnsSuggestion(mockRange, {
+            tables: [
+                { name: 'table1', columns: ['col1'] },
+                { name: 'table2', columns: ['col2'] },
+            ],
+            all: true,
+        }, [], []);
+        expect(result).toEqual([
+            {
+                label: { label: 'table1.col1', description: undefined },
+                insertText: 'table1.col1',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'aa',
+            },
+            {
+                label: { label: 'table2.col2', description: undefined },
+                insertText: 'table2.col2',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'ab',
+            },
+            {
+                label: 'table1.col1, table2.col2',
+                insertText: 'table1.col1, table2.col2',
+                kind: 1,
+                range: mockRange,
+                sortText: 'a',
+            },
+        ]);
+    });
+    it('should handle fetched columns', async () => {
+        const fetchedColumns = [
+            { name: 'col3', parent: 'table1', detail: 'detail3' },
+        ];
+        const result = await generateColumnsSuggestion(mockRange, {
+            tables: [{ name: 'table1', columns: ['col1'] }],
+        }, [], fetchedColumns);
+        expect(result).toEqual([
+            {
+                label: { label: 'col3', description: 'detail3' },
+                insertText: 'col3',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'aa',
+            },
+            {
+                label: { label: 'col1', description: undefined },
+                insertText: 'col1',
+                kind: 1,
+                detail: 'Column',
+                range: mockRange,
+                sortText: 'ab',
+            },
+        ]);
+    });
+    it('should handle empty tables', async () => {
+        const result = await generateColumnsSuggestion(mockRange, {
+            tables: [{ name: 'table1', columns: [] }],
+        }, [], []);
+        expect(result).toEqual([]);
+    });
+});
+describe('generateEntitiesSuggestion', () => {
+    it('should return an empty array if there are no entities', async () => {
+        const result = await generateEntitiesSuggestion(mockRange, []);
+        expect(result).toEqual([]);
+    });
+    it('should generate suggestions for multiple entities', async () => {
+        const entities = [
+            { value: 'entity1', isDir: false },
+            { value: 'entity2', isDir: true },
+        ];
+        const suggestions = await generateEntitiesSuggestion(mockRange, entities, 'ent');
+        expect(suggestions).toEqual([
+            {
+                label: 'entity1',
+                insertText: 'entity1',
+                kind: undefined,
+                insertTextRules: 0,
+                detail: undefined,
+                range: {
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: 1,
+                    endColumn: 1,
+                },
+                command: undefined,
+                sortText: 'aa',
+            },
+            {
+                label: 'entity2/',
+                insertText: '`entity2/$0`',
+                kind: undefined,
+                insertTextRules: 1,
+                detail: undefined,
+                range: {
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: 1,
+                    endColumn: 1,
+                },
+                command: { id: 'editor.action.triggerSuggest', title: '' },
+                sortText: 'ab',
+            },
+        ]);
+    });
+    it('should generate suggestions with prefix with backtick', async () => {
+        const entities = [
+            { value: 'entity1', isDir: false },
+            { value: 'entity2', isDir: true },
+        ];
+        const suggestions = await generateEntitiesSuggestion(mockRange, entities, '`ent');
+        expect(suggestions).toEqual([
+            {
+                label: 'entity1',
+                insertText: 'entity1',
+                kind: undefined,
+                insertTextRules: 0,
+                detail: undefined,
+                range: {
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: 1,
+                    endColumn: 1,
+                },
+                command: undefined,
+                sortText: 'aa',
+            },
+            {
+                label: 'entity2/',
+                insertText: 'entity2/',
+                kind: undefined,
+                insertTextRules: 0,
+                detail: undefined,
+                range: {
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: 1,
+                    endColumn: 1,
+                },
+                command: { id: 'editor.action.triggerSuggest', title: '' },
+                sortText: 'ab',
+            },
+        ]);
+    });
+    it('should handle entities with descriptions', async () => {
+        const entities = [
+            { value: 'entity1', detail: 'description1', isDir: true },
+            { value: 'entity2', isDir: false },
+        ];
+        const suggestions = await generateEntitiesSuggestion(mockRange, entities);
+        expect(suggestions).toEqual([
+            {
+                label: 'entity1/',
+                insertText: '`entity1/$0`',
+                kind: undefined,
+                insertTextRules: 1,
+                detail: 'description1',
+                range: {
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: 1,
+                    endColumn: 1,
+                },
+                command: { id: 'editor.action.triggerSuggest', title: '' },
+                sortText: 'aa',
+            },
+            {
+                label: 'entity2',
+                insertText: 'entity2',
+                kind: undefined,
+                insertTextRules: 0,
+                detail: undefined,
+                range: {
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: 1,
+                    endColumn: 1,
+                },
+                command: undefined,
+                sortText: 'ab',
+            },
+        ]);
+    });
+});

package/build/yql/autocomplete/__tests__/utils.test.d.ts

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

package/build/yql/autocomplete/__tests__/utils.test.js

@@ -0,0 +1,51 @@
+import { suggestionIndexToWeight } from '../../../utils';
+import { wrapStringToBackticks } from '../utils';
+describe('wrapStringToBackticks', () => {
+    it('should return the same string if it already starts and ends with backticks', () => {
+        expect(wrapStringToBackticks('`test`')).toBe('`test`');
+    });
+    it('should wrap the string with backticks if it contains special symbols', () => {
+        expect(wrapStringToBackticks("test'")).toBe("`test'`");
+        expect(wrapStringToBackticks('test "')).toBe('`test "`');
+        expect(wrapStringToBackticks('test-')).toBe('`test-`');
+        expect(wrapStringToBackticks('test@')).toBe('`test@`');
+        expect(wrapStringToBackticks('test/')).toBe('`test/`');
+        expect(wrapStringToBackticks('test\' " - / @')).toBe('`test\' " - / @`');
+    });
+    it('should not wrap the string with backticks if it is empty', () => {
+        expect(wrapStringToBackticks('')).toBe('');
+    });
+    it('should not wrap the string with backticks if it does not contain special symbols', () => {
+        expect(wrapStringToBackticks('test1234')).toBe('test1234');
+    });
+    it('should handle strings with only special symbols', () => {
+        expect(wrapStringToBackticks("'")).toBe("`'`");
+        expect(wrapStringToBackticks('-')).toBe('`-`');
+        expect(wrapStringToBackticks('@')).toBe('`@`');
+        expect(wrapStringToBackticks('/')).toBe('`/`');
+    });
+    it('should handle strings with leading and trailing spaces', () => {
+        expect(wrapStringToBackticks('  test  ')).toBe('`  test  `');
+    });
+    it('should handle strings with only spaces', () => {
+        expect(wrapStringToBackticks('   ')).toBe('`   `');
+    });
+});
+describe('suggestionIndexToWeight', () => {
+    it('should return a single character for indices within the alphabet', () => {
+        expect(suggestionIndexToWeight(0)).toBe('a');
+        expect(suggestionIndexToWeight(25)).toBe('z');
+    });
+    it('should handle indices beyond the alphabet length', () => {
+        expect(suggestionIndexToWeight(26)).toBe('za');
+        expect(suggestionIndexToWeight(51)).toBe('zz');
+        expect(suggestionIndexToWeight(78)).toBe('zzza');
+    });
+    it('should correctly handle edge cases', () => {
+        expect(suggestionIndexToWeight(0)).toBe('a');
+        expect(suggestionIndexToWeight(25)).toBe('z');
+        expect(suggestionIndexToWeight(26)).toBe('za');
+        expect(suggestionIndexToWeight(51)).toBe('zz');
+        expect(suggestionIndexToWeight(700)).toBe('zzzzzzzzzzzzzzzzzzzzzzzzzzy');
+    });
+});

package/build/yql/autocomplete/generateSuggestions.d.ts

@@ -0,0 +1,38 @@
+import type { ColumnAliasSuggestion, KeywordSuggestion, VariableSuggestion } from '@gravity-ui/websql-autocomplete/shared';
+import type { YqlAutocompleteResult } from '@gravity-ui/websql-autocomplete/yql';
+import * as monaco from '../../fillers/monaco-editor-core';
+import type { FetchedColumn, FetchedEntity } from './types';
+export declare function generateSimpleTypesSuggestion(rangeToInsertSuggestion: monaco.IRange, simpleTypes?: string[]): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateEntitiesSuggestion(rangeToInsertSuggestion: monaco.IRange, fetchedEntities: FetchedEntity[], prefix?: string): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateKeywordsSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestKeywords?: KeywordSuggestion[]): {
+    label: string;
+    insertText: string;
+    kind: monaco.languages.CompletionItemKind;
+    detail: string;
+    range: monaco.IRange;
+    sortText: string;
+}[];
+export declare function generateVariableSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestVariables?: VariableSuggestion[]): {
+    label: string;
+    insertText: string;
+    kind: monaco.languages.CompletionItemKind;
+    detail: string;
+    range: monaco.IRange;
+    sortText: string;
+}[];
+export declare function generateSimpleFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange, functions?: string[]): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateAggregateFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange, aggreagteFunctions?: string[]): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateWindowFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange, windowFunctions?: string[]): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateTableFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange, tableFunctions?: string[]): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateUdfSuggestion(rangeToInsertSuggestion: monaco.IRange, udfs?: string[]): Promise<monaco.languages.CompletionItem[]>;
+export declare function generatePragmasSuggestion(rangeToInsertSuggestion: monaco.IRange, pragmas?: string[]): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateEntitySettingsSuggestion(rangeToInsertSuggestion: monaco.IRange, entitySettings?: string[]): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateColumnAliasesSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestColumnAliases?: ColumnAliasSuggestion[]): {
+    label: string;
+    insertText: string;
+    kind: monaco.languages.CompletionItemKind;
+    detail: string;
+    range: monaco.IRange;
+    sortText: string;
+}[];
+export declare function generateColumnsSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestColumns: YqlAutocompleteResult['suggestColumns'], suggestVariables: YqlAutocompleteResult['suggestVariables'], fetchedColumns: FetchedColumn[]): Promise<monaco.languages.CompletionItem[]>;

package/build/yql/autocomplete/generateSuggestions.js

@@ -0,0 +1,241 @@
+import * as monaco from '../../fillers/monaco-editor-core';
+import { getSuggestionIndex, isVariable, removeBackticks, removeStringDuplicates, wrapStringToBackticks, } from './utils';
+import { suggestionIndexToWeight } from '../../utils';
+export async function generateSimpleTypesSuggestion(rangeToInsertSuggestion, simpleTypes = []) {
+    return simpleTypes.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.TypeParameter,
+        detail: 'Type',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestSimpleTypes')),
+    }));
+}
+export async function generateEntitiesSuggestion(rangeToInsertSuggestion, fetchedEntities, prefix = '') {
+    const withBackticks = prefix === null || prefix === void 0 ? void 0 : prefix.startsWith('`');
+    return fetchedEntities.reduce((acc, { value, detail, isDir }) => {
+        const label = isDir ? `${value}/` : value;
+        let labelAsSnippet;
+        if (isDir && !withBackticks) {
+            labelAsSnippet = `\`${label}$0\``;
+        }
+        const suggestionIndex = acc.length;
+        acc.push({
+            label,
+            insertText: labelAsSnippet !== null && labelAsSnippet !== void 0 ? labelAsSnippet : label,
+            kind: isDir
+                ? monaco.languages.CompletionItemKind.Folder
+                : monaco.languages.CompletionItemKind.Text,
+            insertTextRules: labelAsSnippet
+                ? monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet
+                : monaco.languages.CompletionItemInsertTextRule.None,
+            detail: detail,
+            range: rangeToInsertSuggestion,
+            command: label.endsWith('/')
+                ? { id: 'editor.action.triggerSuggest', title: '' }
+                : undefined,
+            // first argument is responsible for sorting groups of suggestions, the second - to preserve suggestions order returned from backend
+            sortText: suggestionIndexToWeight(getSuggestionIndex('suggestEntity')) +
+                suggestionIndexToWeight(suggestionIndex),
+        });
+        return acc;
+    }, []);
+}
+export function generateKeywordsSuggestion(rangeToInsertSuggestion, suggestKeywords = []) {
+    return suggestKeywords.map((keywordSuggestion) => ({
+        label: keywordSuggestion.value,
+        insertText: keywordSuggestion.value,
+        kind: monaco.languages.CompletionItemKind.Keyword,
+        detail: 'Keyword',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestKeywords')),
+    }));
+}
+export function generateVariableSuggestion(rangeToInsertSuggestion, suggestVariables = []) {
+    return suggestVariables.map(({ name }) => {
+        const variable = '$' + name;
+        return {
+            label: variable,
+            insertText: variable,
+            kind: monaco.languages.CompletionItemKind.Variable,
+            detail: 'Variable',
+            range: rangeToInsertSuggestion,
+            sortText: suggestionIndexToWeight(getSuggestionIndex('suggestVariables')),
+        };
+    });
+}
+export async function generateSimpleFunctionsSuggestion(rangeToInsertSuggestion, functions = []) {
+    return functions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'Function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestFunctions')),
+    }));
+}
+export async function generateAggregateFunctionsSuggestion(rangeToInsertSuggestion, aggreagteFunctions = []) {
+    return aggreagteFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'Aggregate function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestAggregateFunctions')),
+    }));
+}
+export async function generateWindowFunctionsSuggestion(rangeToInsertSuggestion, windowFunctions = []) {
+    return windowFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'Window function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestWindowFunctions')),
+    }));
+}
+export async function generateTableFunctionsSuggestion(rangeToInsertSuggestion, tableFunctions = []) {
+    return tableFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'Table function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestTableFunctions')),
+    }));
+}
+export async function generateUdfSuggestion(rangeToInsertSuggestion, udfs = []) {
+    return udfs.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'UDF',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestUdfs')),
+    }));
+}
+export async function generatePragmasSuggestion(rangeToInsertSuggestion, pragmas = []) {
+    return pragmas.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Module,
+        detail: 'Pragma',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestPragmas')),
+    }));
+}
+export async function generateEntitySettingsSuggestion(rangeToInsertSuggestion, entitySettings = []) {
+    return entitySettings.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Property,
+        detail: 'Setting',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestEntitySettings')),
+    }));
+}
+export function generateColumnAliasesSuggestion(rangeToInsertSuggestion, suggestColumnAliases = []) {
+    return suggestColumnAliases.map((columnAliasSuggestion) => ({
+        label: columnAliasSuggestion.name,
+        insertText: columnAliasSuggestion.name,
+        kind: monaco.languages.CompletionItemKind.Variable,
+        detail: 'Column alias',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumnAliases')),
+    }));
+}
+export async function generateColumnsSuggestion(rangeToInsertSuggestion, suggestColumns, suggestVariables, fetchedColumns) {
+    var _a;
+    if (!(suggestColumns === null || suggestColumns === void 0 ? void 0 : suggestColumns.tables)) {
+        return [];
+    }
+    const suggestions = [];
+    const allColumnsSuggestion = suggestColumns.all ? [] : undefined;
+    const multi = suggestColumns.tables.length > 1;
+    const tableNames = suggestColumns.tables.map((entity) => entity.name);
+    const filteredTableNames = removeStringDuplicates(tableNames);
+    const variableSources = filteredTableNames.filter(isVariable);
+    const columnsFromVariable = [];
+    if (variableSources.length) {
+        variableSources.forEach((source) => {
+            var _a, _b, _c, _d;
+            const newColumns = (_d = (_c = (_b = (_a = suggestVariables === null || suggestVariables === void 0 ? void 0 : suggestVariables
+            // Variable name from suggestions doesn't include $ sign
+            .find((variable) => source.slice(1) === variable.name)) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.columns) === null || _c === void 0 ? void 0 : _c.map((col) => ({
+                name: col,
+                parent: source,
+            }))) !== null && _d !== void 0 ? _d : [];
+            columnsFromVariable.push(...newColumns);
+        });
+    }
+    const predefinedColumns = suggestColumns.tables.reduce((acc, entity) => {
+        const columns = entity.columns;
+        if (columns) {
+            acc.push(...columns.map((col) => ({
+                name: col,
+                parent: entity.name,
+            })));
+        }
+        return acc;
+    }, []);
+    const tableNameToAliasMap = (_a = suggestColumns.tables) === null || _a === void 0 ? void 0 : _a.reduce((acc, entity) => {
+        var _a;
+        const name = removeBackticks(entity.name);
+        const aliases = (_a = acc[name]) !== null && _a !== void 0 ? _a : [];
+        if (entity.alias) {
+            aliases.push(entity.alias);
+        }
+        acc[name] = aliases;
+        return acc;
+    }, {});
+    [...fetchedColumns, ...columnsFromVariable, ...predefinedColumns].forEach((col) => {
+        const normalizedName = wrapStringToBackticks(col.name);
+        const aliases = tableNameToAliasMap[removeBackticks(col.parent)];
+        const currentSuggestionIndex = suggestions.length;
+        if (aliases === null || aliases === void 0 ? void 0 : aliases.length) {
+            aliases.forEach((a) => {
+                const columnNameSuggestion = `${a}.${normalizedName}`;
+                suggestions.push({
+                    label: { label: columnNameSuggestion, description: col.detail },
+                    insertText: columnNameSuggestion,
+                    kind: monaco.languages.CompletionItemKind.Variable,
+                    detail: 'Column',
+                    range: rangeToInsertSuggestion,
+                    sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')) +
+                        suggestionIndexToWeight(currentSuggestionIndex),
+                });
+                allColumnsSuggestion === null || allColumnsSuggestion === void 0 ? void 0 : allColumnsSuggestion.push(columnNameSuggestion);
+            });
+        }
+        else {
+            let columnNameSuggestion = normalizedName;
+            if (multi) {
+                columnNameSuggestion = `${wrapStringToBackticks(col.parent)}.${normalizedName}`;
+            }
+            suggestions.push({
+                label: {
+                    label: columnNameSuggestion,
+                    description: col.detail,
+                },
+                insertText: columnNameSuggestion,
+                kind: monaco.languages.CompletionItemKind.Variable,
+                detail: 'Column',
+                range: rangeToInsertSuggestion,
+                sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')) +
+                    suggestionIndexToWeight(currentSuggestionIndex),
+            });
+            allColumnsSuggestion === null || allColumnsSuggestion === void 0 ? void 0 : allColumnsSuggestion.push(columnNameSuggestion);
+        }
+    });
+    if (allColumnsSuggestion && allColumnsSuggestion.length > 1) {
+        const allColumns = allColumnsSuggestion.join(', ');
+        suggestions.push({
+            label: allColumns,
+            insertText: allColumns,
+            kind: monaco.languages.CompletionItemKind.Variable,
+            range: rangeToInsertSuggestion,
+            sortText: suggestionIndexToWeight(getSuggestionIndex('suggestAllColumns')),
+        });
+    }
+    return suggestions;
+}

package/build/yql/autocomplete/index.d.ts

@@ -0,0 +1,3 @@
+export { type YQLAutocompleteConfig } from './yqlAutocomplete';
+export * from './types';
+export { registerCompletionItemProvider } from './registerProvider';

package/build/yql/autocomplete/index.js

@@ -0,0 +1,2 @@
+export * from './types';
+export { registerCompletionItemProvider } from './registerProvider';

package/build/yql/autocomplete/registerProvider.d.ts

@@ -0,0 +1,2 @@
+import type { YQLAutocompleteConfig } from './yqlAutocomplete';
+export declare function registerCompletionItemProvider(langId: string, triggerCharacters: string[], config: YQLAutocompleteConfig): void;

package/build/yql/autocomplete/registerProvider.js

@@ -0,0 +1,17 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { getSuggestionsGetter } from './yqlAutocomplete';
+const completionProvider = new Map();
+function disableCodeSuggestions(langId) {
+    const provider = completionProvider.get(langId);
+    if (provider) {
+        provider.dispose();
+    }
+}
+export function registerCompletionItemProvider(langId, triggerCharacters, config) {
+    disableCodeSuggestions(langId);
+    const provider = monaco.languages.registerCompletionItemProvider(langId, {
+        triggerCharacters: triggerCharacters,
+        provideCompletionItems: getSuggestionsGetter(config),
+    });
+    completionProvider.set(langId, provider);
+}

package/build/yql/autocomplete/types.d.ts

@@ -0,0 +1,16 @@
+import type { YQLEntity } from '@gravity-ui/websql-autocomplete/yql';
+export type CursorPosition = {
+    lineNumber: number;
+    column: number;
+};
+export type AutocompleteEntityType = YQLEntity | 'directory';
+export type FetchedEntity = {
+    value: string;
+    isDir: boolean;
+    detail?: string;
+};
+export type FetchedColumn = {
+    name: string;
+    detail?: string;
+    parent: string;
+};

package/build/yql/autocomplete/types.js

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

package/build/yql/autocomplete/utils.d.ts

@@ -0,0 +1,9 @@
+import type { YqlAutocompleteResult } from '@gravity-ui/websql-autocomplete/yql';
+type SuggestionType = keyof Omit<YqlAutocompleteResult, 'errors' | 'suggestDatabases'> | 'suggestAllColumns';
+export declare function getSuggestionIndex(suggestionType: SuggestionType): number;
+export declare function isVariable(value: string): boolean;
+export declare function removeStringDuplicates(value?: string[]): string[];
+export declare function getEntitiesToFetchColumns(suggestColumns: YqlAutocompleteResult['suggestColumns']): string[];
+export declare function wrapStringToBackticks(value: string): string;
+export declare function removeBackticks(value: string): string;
+export {};

package/build/yql/autocomplete/utils.js

@@ -0,0 +1,57 @@
+const SuggestionsWeight = {
+    suggestTemplates: 0,
+    suggestPragmas: 1,
+    suggestEntity: 2,
+    suggestAllColumns: 3,
+    suggestColumns: 4,
+    suggestColumnAliases: 5,
+    suggestVariables: 6,
+    suggestTableIndexes: 7,
+    suggestTableHints: 8,
+    suggestEntitySettings: 9,
+    suggestKeywords: 10,
+    suggestAggregateFunctions: 11,
+    suggestTableFunctions: 12,
+    suggestWindowFunctions: 13,
+    suggestFunctions: 14,
+    suggestSimpleTypes: 15,
+    suggestUdfs: 16,
+};
+export function getSuggestionIndex(suggestionType) {
+    return SuggestionsWeight[suggestionType];
+}
+export function isVariable(value) {
+    return value.startsWith('$');
+}
+export function removeStringDuplicates(value = []) {
+    return Array.from(new Set(value));
+}
+export function getEntitiesToFetchColumns(suggestColumns) {
+    var _a;
+    const names = (_a = suggestColumns === null || suggestColumns === void 0 ? void 0 : suggestColumns.tables) === null || _a === void 0 ? void 0 : _a.map((entity) => entity.name);
+    // remove duplicates if any
+    const filteredTableNames = removeStringDuplicates(names);
+    return filteredTableNames.filter((name) => !isVariable(name));
+}
+const specialSymbols = /[\s'"-/@]/;
+export function wrapStringToBackticks(value) {
+    if (value.startsWith('`') && value.endsWith('`')) {
+        return value;
+    }
+    let result = value;
+    if (value.match(specialSymbols)) {
+        result = `\`${value}\``;
+    }
+    return result;
+}
+export function removeBackticks(value) {
+    let sliceStart = 0;
+    let sliceEnd = value.length;
+    if (value.startsWith('`')) {
+        sliceStart = 1;
+    }
+    if (value.endsWith('`')) {
+        sliceEnd = -1;
+    }
+    return value.slice(sliceStart, sliceEnd);
+}

package/build/yql/autocomplete/yqlAutocomplete.d.ts

@@ -0,0 +1,51 @@
+import type { YQLEntity } from '@gravity-ui/websql-autocomplete/yql';
+import type Monaco from 'monaco-editor';
+import type { FetchedColumn, FetchedEntity } from './types';
+export type YQLAutocompleteConfig = {
+    getQueryParser?: YQLAutocomplete['getQueryParser'];
+    getUdfs?: YQLAutocomplete['getUdfs'];
+    getSimpleTypes?: YQLAutocomplete['getSimpleTypes'];
+    getPragmas?: YQLAutocomplete['getPragmas'];
+    getWindowFunctions?: YQLAutocomplete['getWindowFunctions'];
+    getTableFunctions?: YQLAutocomplete['getTableFunctions'];
+    getAggregateFunctions?: YQLAutocomplete['getAggregateFunctions'];
+    getSimpleFunctions?: YQLAutocomplete['getSimpleFunctions'];
+    getEntitySettings?: YQLAutocomplete['getEntitySettings'];
+    fetchEntities?: YQLAutocomplete['fetchEntities'];
+    fetchEntityColumns?: YQLAutocomplete['fetchEntityColumns'];
+};
+export declare class YQLAutocomplete {
+    constructor({ getQueryParser, getUdfs, getSimpleTypes, getPragmas, getWindowFunctions, getTableFunctions, getAggregateFunctions, getSimpleFunctions, getEntitySettings, fetchEntities, fetchEntityColumns, }: YQLAutocompleteConfig);
+    getSuggestions(input: string, offset: number): Promise<Monaco.languages.CompletionItem[]>;
+    parseInput(input: string, offset: number): Promise<import("@gravity-ui/websql-autocomplete/yql").YqlAutocompleteResult>;
+    getQueryParser(): Promise<typeof import("@gravity-ui/websql-autocomplete/yql").parseYqlQuery>;
+    getSimpleTypes(_prefix?: string): Promise<string[]>;
+    getUdfs(_prefix?: string): Promise<string[]>;
+    getPragmas(_prefix?: string): Promise<string[]>;
+    getWindowFunctions(_prefix?: string): Promise<string[]>;
+    getTableFunctions(_prefix?: string): Promise<string[]>;
+    getAggregateFunctions(_prefix?: string): Promise<string[]>;
+    getSimpleFunctions(_prefix?: string): Promise<string[]>;
+    /**
+     * Fetches entity settings based on provided entity type.
+     * @param entityType
+     * @returns  A promise that resolves to an array of entity settings.
+     */
+    getEntitySettings(_entityType: YQLEntity): Promise<string[]>;
+    /**
+     * Fetches entities based on the provided prefix and needed entity types.
+     * @param prefix - The prefix to filter entities.
+     * @param neededEntityTypes - An array of entity types to fetch.
+     * @returns A promise that resolves to an array of fetched entities.
+     */
+    fetchEntities(_prefix: string, _neededEntityTypes: YQLEntity[]): Promise<FetchedEntity[]>;
+    /**
+     * Fetches columns for the specified entities.
+     * @param entityNames - An array of entity names to fetch columns for.
+     * @returns A promise that resolves to an array of fetched columns.
+     */
+    fetchEntityColumns(_entityNames: string[]): Promise<FetchedColumn[]>;
+}
+export declare function getSuggestionsGetter(config?: YQLAutocompleteConfig): (model: Monaco.editor.ITextModel, monacoCursorPosition: Monaco.Position, _context: Monaco.languages.CompletionContext, _token: Monaco.CancellationToken) => Promise<{
+    suggestions: Monaco.languages.CompletionItem[];
+}>;

package/build/yql/autocomplete/yqlAutocomplete.js

@@ -0,0 +1,211 @@
+import { generateAggregateFunctionsSuggestion, generateColumnAliasesSuggestion, generateColumnsSuggestion, generateEntitiesSuggestion, generateEntitySettingsSuggestion, generateKeywordsSuggestion, generatePragmasSuggestion, generateSimpleFunctionsSuggestion, generateSimpleTypesSuggestion, generateTableFunctionsSuggestion, generateUdfSuggestion, generateVariableSuggestion, generateWindowFunctionsSuggestion, } from './generateSuggestions';
+import { getEntitiesToFetchColumns } from './utils';
+function getCursorPosition(input, offset) {
+    const lines = input.slice(0, offset).split('\n');
+    // parser suggest to get cursor position where lineNumber and column starts from 1
+    return {
+        lineNumber: lines.length,
+        column: lines[lines.length - 1].length + 1,
+    };
+}
+const prefixRegexp = /([^\s]+)$/;
+function getCursorPrefix(input, offset, re = prefixRegexp) {
+    const prevText = input.slice(0, offset);
+    const match = prevText.match(re);
+    if (match && match[1]) {
+        return match[1];
+    }
+    return '';
+}
+const prefixToReplaceRegexp = /([^\\/\s`]+)$/;
+function getRangeToInsertSuggestion(input, offset) {
+    const cursorPosition = getCursorPosition(input, offset);
+    const cursorPrefix = getCursorPrefix(input, offset, prefixToReplaceRegexp);
+    return {
+        startColumn: cursorPosition.column - cursorPrefix.length,
+        startLineNumber: cursorPosition.lineNumber,
+        endColumn: cursorPosition.column,
+        endLineNumber: cursorPosition.lineNumber,
+    };
+}
+export class YQLAutocomplete {
+    constructor({ getQueryParser, getUdfs, getSimpleTypes, getPragmas, getWindowFunctions, getTableFunctions, getAggregateFunctions, getSimpleFunctions, getEntitySettings, fetchEntities, fetchEntityColumns, }) {
+        if (getQueryParser) {
+            this.getQueryParser = getQueryParser;
+        }
+        if (getUdfs) {
+            this.getUdfs = getUdfs;
+        }
+        if (getSimpleTypes) {
+            this.getSimpleTypes = getSimpleTypes;
+        }
+        if (getPragmas) {
+            this.getPragmas = getPragmas;
+        }
+        if (getWindowFunctions) {
+            this.getWindowFunctions = getWindowFunctions;
+        }
+        if (getTableFunctions) {
+            this.getTableFunctions = getTableFunctions;
+        }
+        if (getAggregateFunctions) {
+            this.getAggregateFunctions = getAggregateFunctions;
+        }
+        if (getSimpleFunctions) {
+            this.getSimpleFunctions = getSimpleFunctions;
+        }
+        if (getEntitySettings) {
+            this.getEntitySettings = getEntitySettings;
+        }
+        if (fetchEntities) {
+            this.fetchEntities = fetchEntities;
+        }
+        if (fetchEntityColumns) {
+            this.fetchEntityColumns = fetchEntityColumns;
+        }
+    }
+    async getSuggestions(input, offset) {
+        const parseResult = await this.parseInput(input, offset);
+        let entitiesSuggestions = [];
+        let functionsSuggestions = [];
+        let aggregateFunctionsSuggestions = [];
+        let windowFunctionsSuggestions = [];
+        let tableFunctionsSuggestions = [];
+        let udfsSuggestions = [];
+        let simpleTypesSuggestions = [];
+        let pragmasSuggestions = [];
+        let entitySettingsSuggestions = [];
+        let columnsSuggestions = [];
+        let variableSuggestions = [];
+        const rangeToInsertSuggestion = getRangeToInsertSuggestion(input, offset);
+        const cursorPrefix = getCursorPrefix(input, offset);
+        if (parseResult.suggestSimpleTypes) {
+            const simpleTypes = await this.getSimpleTypes(cursorPrefix);
+            simpleTypesSuggestions = await generateSimpleTypesSuggestion(rangeToInsertSuggestion, simpleTypes);
+        }
+        if (parseResult.suggestEntity) {
+            const fetchedEntities = await this.fetchEntities(cursorPrefix, parseResult.suggestEntity);
+            entitiesSuggestions = await generateEntitiesSuggestion(rangeToInsertSuggestion, fetchedEntities, cursorPrefix);
+        }
+        if (parseResult.suggestVariables) {
+            variableSuggestions = generateVariableSuggestion(rangeToInsertSuggestion, parseResult.suggestVariables);
+        }
+        if (parseResult.suggestFunctions) {
+            const simpleFunctions = await this.getSimpleFunctions(cursorPrefix);
+            functionsSuggestions = await generateSimpleFunctionsSuggestion(rangeToInsertSuggestion, simpleFunctions);
+        }
+        if (parseResult.suggestAggregateFunctions) {
+            const aggregateFunctions = await this.getAggregateFunctions(cursorPrefix);
+            aggregateFunctionsSuggestions = await generateAggregateFunctionsSuggestion(rangeToInsertSuggestion, aggregateFunctions);
+        }
+        if (parseResult.suggestWindowFunctions) {
+            const windowFunctions = await this.getWindowFunctions(cursorPrefix);
+            windowFunctionsSuggestions = await generateWindowFunctionsSuggestion(rangeToInsertSuggestion, windowFunctions);
+        }
+        if (parseResult.suggestTableFunctions) {
+            const tableFunctions = await this.getTableFunctions(cursorPrefix);
+            tableFunctionsSuggestions = await generateTableFunctionsSuggestion(rangeToInsertSuggestion, tableFunctions);
+        }
+        if (parseResult.suggestUdfs) {
+            const udfs = await this.getUdfs(cursorPrefix);
+            udfsSuggestions = await generateUdfSuggestion(rangeToInsertSuggestion, udfs);
+        }
+        if (parseResult.suggestPragmas) {
+            const pragmas = await this.getPragmas(cursorPrefix);
+            pragmasSuggestions = await generatePragmasSuggestion(rangeToInsertSuggestion, pragmas);
+        }
+        if (parseResult.suggestEntitySettings) {
+            const entitySettings = await this.getEntitySettings(parseResult.suggestEntitySettings);
+            entitySettingsSuggestions = await generateEntitySettingsSuggestion(rangeToInsertSuggestion, entitySettings);
+        }
+        const keywordsSuggestions = generateKeywordsSuggestion(rangeToInsertSuggestion, parseResult.suggestKeywords);
+        const columnAliasSuggestion = await generateColumnAliasesSuggestion(rangeToInsertSuggestion, parseResult.suggestColumnAliases);
+        if (parseResult.suggestColumns) {
+            const entities = getEntitiesToFetchColumns(parseResult.suggestColumns);
+            const fetchedColumns = await this.fetchEntityColumns(entities);
+            columnsSuggestions = await generateColumnsSuggestion(rangeToInsertSuggestion, parseResult.suggestColumns, parseResult.suggestVariables, fetchedColumns);
+        }
+        const suggestions = [
+            ...entitiesSuggestions,
+            ...functionsSuggestions,
+            ...windowFunctionsSuggestions,
+            ...tableFunctionsSuggestions,
+            ...udfsSuggestions,
+            ...simpleTypesSuggestions,
+            ...pragmasSuggestions,
+            ...columnAliasSuggestion,
+            ...columnsSuggestions,
+            ...keywordsSuggestions,
+            ...aggregateFunctionsSuggestions,
+            ...entitySettingsSuggestions,
+            ...variableSuggestions,
+        ];
+        return suggestions;
+    }
+    async parseInput(input, offset) {
+        const cursorPosition = getCursorPosition(input, offset);
+        const parseQuery = await this.getQueryParser();
+        const cursorForParsing = {
+            line: cursorPosition.lineNumber,
+            column: cursorPosition.column,
+        };
+        return parseQuery(input, cursorForParsing);
+    }
+    async getQueryParser() {
+        const { parseYqlQuery: parseQuery } = await import('@gravity-ui/websql-autocomplete/yql');
+        return parseQuery;
+    }
+    async getSimpleTypes(_prefix) {
+        return [];
+    }
+    async getUdfs(_prefix) {
+        return [];
+    }
+    async getPragmas(_prefix) {
+        return [];
+    }
+    async getWindowFunctions(_prefix) {
+        return [];
+    }
+    async getTableFunctions(_prefix) {
+        return [];
+    }
+    async getAggregateFunctions(_prefix) {
+        return [];
+    }
+    async getSimpleFunctions(_prefix) {
+        return [];
+    }
+    /**
+     * Fetches entity settings based on provided entity type.
+     * @param entityType
+     * @returns  A promise that resolves to an array of entity settings.
+     */
+    async getEntitySettings(_entityType) {
+        return [];
+    }
+    /**
+     * Fetches entities based on the provided prefix and needed entity types.
+     * @param prefix - The prefix to filter entities.
+     * @param neededEntityTypes - An array of entity types to fetch.
+     * @returns A promise that resolves to an array of fetched entities.
+     */
+    async fetchEntities(_prefix, _neededEntityTypes) {
+        return [];
+    }
+    /**
+     * Fetches columns for the specified entities.
+     * @param entityNames - An array of entity names to fetch columns for.
+     * @returns A promise that resolves to an array of fetched columns.
+     */
+    async fetchEntityColumns(_entityNames) {
+        return [];
+    }
+}
+export function getSuggestionsGetter(config = {}) {
+    const autocompleteInstance = new YQLAutocomplete(config);
+    return async (model, monacoCursorPosition, _context, _token) => {
+        const suggestions = await autocompleteInstance.getSuggestions(model.getValue(), model.getOffsetAt(monacoCursorPosition));
+        return { suggestions };
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monaco-yql-languages",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "YQL languages for the Monaco Editor, based on monaco-languages.",
   "author": "YDB",
   "license": "MIT",
@@ -20,25 +20,33 @@
     "prettier": "prettier \"**/*.{md,yaml,yml}\"",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run lint && npm run build",
-    "test": "echo \"Error: no test specified\" && exit 0"
+    "test": "jest"
   },
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/ydb-platform/monaco-yql-languages.git"
   },
   "devDependencies": {
-    "@gravity-ui/eslint-config": "^3.1.1",
+    "@commitlint/config-conventional": "^19.7.1",
+    "@gravity-ui/eslint-config": "^3.3.0",
     "@gravity-ui/prettier-config": "^1.1.0",
     "@gravity-ui/stylelint-config": "^4.0.1",
     "@gravity-ui/tsconfig": "^1.0.0",
-    "eslint": "^8.10.0",
-    "husky": "^9.0.11",
-    "monaco-editor": "^0.32.1",
-    "prettier": "^3.2.5",
+    "@gravity-ui/websql-autocomplete": "^13.7.0",
+    "@jest/types": "^29.6.3",
+    "@types/jest": "^29.5.14",
+    "eslint": "^8.57.1",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "monaco-editor": "^0.52.2",
+    "prettier": "^3.4.2",
     "rimraf": "^3.0.2",
-    "typescript": "^5.4.2"
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3"
   },
   "peerDependencies": {
+    "@gravity-ui/websql-autocomplete": "^13.7.0",
     "monaco-editor": ">=0.27.0"
   },
   "nano-staged": {