ydb-embedded-ui 6.0.1 → 6.2.0

package/dist/styles/mixins.scss

@@ -96,13 +96,6 @@
 
 @mixin query-data-table() {
     & .data-table {
-        $_: &;
-
-        &__table {
-            border-spacing: 0;
-            border-collapse: separate;
-        }
-
         &__th,
         &__td {
             vertical-align: middle;
@@ -114,11 +107,6 @@
             }
         }
 
-        &__row,
-        &__sticky th {
-            height: 40px;
-        }
-
         &__th {
             box-shadow: inset 0 -1px 0 0 var(--g-tabs-color-divider);
         }
@@ -170,41 +158,6 @@
     }
 }
 
-@mixin table-styles {
-    & .data-table {
-        &__table {
-            width: 100%;
-        }
-
-        &__row,
-        &__sticky th {
-            height: 40px;
-        }
-
-        &__box {
-            .data-table__table-wrapper {
-                padding-bottom: 20px;
-            }
-
-            &_sticky-head_fixed {
-                overflow: initial;
-            }
-        }
-    }
-}
-
-@mixin table-sticky-styles {
-    & .data-table {
-        &__th {
-            height: auto;
-        }
-    }
-
-    & {
-        padding-bottom: 20px;
-    }
-}
-
 @mixin json-tree-styles {
     // stylelint-disable
     font-family: var(--g-font-family-monospace) !important;

package/dist/types/api/autocomplete.d.ts

@@ -0,0 +1,21 @@
+/**
+ * endpoint: /viewer/json/autocomplete
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+ */
+export interface TQueryAutocomplete {
+    Success: boolean;
+    Error?: string[];
+    Result: TAutocompleteResult;
+}
+interface TAutocompleteResult {
+    Entities: TAutocompleteEntity[];
+    Total?: number;
+}
+export interface TAutocompleteEntity {
+    Name: string;
+    Type: AutocompleteEntityType;
+    Parent: string;
+}
+export type AutocompleteEntityType = 'unknown' | 'dir' | 'table' | 'pers_queue_group' | 'sub_domain' | 'rtmr_volume' | 'block_store_volume' | 'kesus' | 'solomon_volume' | 'table_index' | 'ext_sub_domain' | 'file_store' | 'column_store' | 'column_table' | 'cdc_stream' | 'sequence' | 'replication' | 'blob_depot' | 'external_table' | 'external_data_source' | 'view' | 'column' | 'index';
+export {};

package/dist/types/api/autocomplete.js

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

package/dist/types/api/restartPDisk.d.ts

@@ -0,0 +1,4 @@
+export interface RestartPDiskResponse {
+    result?: boolean;
+    error?: string;
+}

package/dist/types/api/restartPDisk.js

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

package/dist/utils/constants.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="react" />
+import type { Settings } from '@gravity-ui/react-data-table';
 export declare const AUTO_RELOAD_INTERVAL: number;
 export declare const DEFAULT_POLLING_INTERVAL: number;
 export declare const KILOBYTE = 1000;
@@ -66,19 +68,32 @@ export declare const DEFAULT_IS_TENANT_SUMMARY_COLLAPSED = "default-is-tenant-su
 export declare const DEFAULT_IS_TENANT_COMMON_INFO_COLLAPSED = "default-is-tenant-common-info-collapsed";
 export declare const DEFAULT_IS_QUERY_RESULT_COLLAPSED = "default-is-query-result-collapsed";
 export declare const DEFAULT_CLUSTER_TAB_KEY = "default-cluster-tab";
-export declare const DEFAULT_TABLE_SETTINGS: {
-    readonly displayIndices: false;
-    readonly stickyHead: "moving";
-    readonly syncHeadOnResize: true;
-    readonly dynamicRender: true;
-    readonly highlightRows: true;
-};
+export declare const DEFAULT_TABLE_SETTINGS: Settings;
 export declare const TENANT_OVERVIEW_TABLES_SETTINGS: {
     readonly stickyHead: "fixed";
     readonly dynamicRender: false;
-    readonly displayIndices: false;
-    readonly syncHeadOnResize: true;
-    readonly highlightRows: true;
+    readonly displayIndices?: boolean | undefined;
+    readonly stickyTop?: number | "auto" | undefined;
+    readonly syncHeadOnResize?: boolean | undefined;
+    readonly stickyFooter?: import("@gravity-ui/react-data-table").HeadPosition | undefined;
+    readonly stickyBottom?: number | "auto" | undefined;
+    readonly dynamicInnerRef?: import("react").Ref<ReactList> | undefined;
+    readonly dynamicRenderType?: "simple" | "uniform" | "variable" | undefined;
+    readonly dynamicItemSizeEstimator?: any;
+    readonly dynamicItemSizeGetter?: any;
+    readonly dynamicRenderMinSize?: number | undefined;
+    readonly dynamicRenderUseStaticSize?: boolean | undefined;
+    readonly dynamicRenderThreshold?: number | undefined;
+    readonly dynamicRenderScrollParentGetter?: any;
+    readonly dynamicRenderScrollParentViewportSizeGetter?: (() => number) | undefined;
+    readonly sortable?: boolean | undefined;
+    readonly externalSort?: boolean | undefined;
+    readonly disableSortReset?: boolean | undefined;
+    readonly defaultOrder?: import("@gravity-ui/react-data-table").OrderType | undefined;
+    readonly defaultResizeable?: boolean | undefined;
+    readonly highlightRows?: boolean | undefined;
+    readonly stripedRows?: boolean | undefined;
+    readonly headerMod?: "multiline" | "pre" | undefined;
 };
 export declare const QUERY_INITIAL_MODE_KEY = "query_initial_mode";
 export declare const LAST_USED_QUERY_ACTION_KEY = "last_used_query_action";
@@ -88,3 +103,4 @@ export declare const USE_BACKEND_PARAMS_FOR_TABLES_KEY = "useBackendParamsForTab
 export declare const QUERY_USE_MULTI_SCHEMA_KEY = "queryUseMultiSchema";
 export declare const USE_CLUSTER_BALANCER_AS_BACKEND_KEY = "useClusterBalancerAsBacked";
 export declare const ENABLE_AUTOCOMPLETE = "enableAutocomplete";
+export declare const AUTOCOMPLETE_ON_ENTER = "autocompleteOnEnter";

package/dist/utils/constants.js

@@ -101,3 +101,4 @@ export const USE_BACKEND_PARAMS_FOR_TABLES_KEY = 'useBackendParamsForTables';
 export const QUERY_USE_MULTI_SCHEMA_KEY = 'queryUseMultiSchema';
 export const USE_CLUSTER_BALANCER_AS_BACKEND_KEY = 'useClusterBalancerAsBacked';
 export const ENABLE_AUTOCOMPLETE = 'enableAutocomplete';
+export const AUTOCOMPLETE_ON_ENTER = 'autocompleteOnEnter';

package/dist/utils/hooks/useTableResize.d.ts

@@ -1,7 +1,2 @@
-import type { Column as DataTableColumn } from '@gravity-ui/react-data-table';
-import type { Column as VirtualTableColumn } from '../../components/VirtualTable';
-export type Column<T> = VirtualTableColumn<T> & DataTableColumn<T>;
-export type TableColumnsWidthSetup = Record<string, number>;
-export type HandleTableColumnsResize = (newSetup: TableColumnsWidthSetup) => void;
-export declare const updateColumnsWidth: <T>(columns: Column<T>[], columnsWidthSetup: TableColumnsWidthSetup) => Column<T>[];
-export declare const useTableResize: (localStorageKey: string) => [TableColumnsWidthSetup, HandleTableColumnsResize];
+import type { ColumnWidthByName, HandleResize } from '@gravity-ui/react-data-table';
+export declare const useTableResize: (localStorageKey?: string) => [ColumnWidthByName, HandleResize];

package/dist/utils/hooks/useTableResize.js

@@ -1,29 +1,17 @@
 import React from 'react';
-import { DEFAULT_RESIZEABLE } from '../../components/VirtualTable';
+import { useTableResize as libUseTableResize } from '@gravity-ui/react-data-table';
 import { settingsManager } from '../../services/settings';
-export const updateColumnsWidth = (columns, columnsWidthSetup) => {
-    return columns.map((column) => {
-        var _a, _b;
-        const resizeable = (_a = column.resizeable) !== null && _a !== void 0 ? _a : DEFAULT_RESIZEABLE;
-        if (!resizeable) {
-            return column;
-        }
-        return Object.assign(Object.assign({}, column), { width: (_b = columnsWidthSetup[column.name]) !== null && _b !== void 0 ? _b : column.width });
-    });
-};
 export const useTableResize = (localStorageKey) => {
-    const [tableColumnsWidthSetup, setTableColumnsWidth] = React.useState(() => {
-        const setupFromLS = settingsManager.readUserSettingsValue(localStorageKey, {});
-        return setupFromLS;
-    });
-    const handleSetupChange = React.useCallback((newSetup) => {
-        setTableColumnsWidth((previousSetup) => {
-            // ResizeObserver callback may be triggered only for currently resized column
-            // or for the whole set of columns
-            const setup = Object.assign(Object.assign({}, previousSetup), newSetup);
-            settingsManager.setUserSettingsValue(localStorageKey, setup);
-            return setup;
-        });
+    const getSizes = React.useCallback(() => {
+        if (!localStorageKey) {
+            return {};
+        }
+        return settingsManager.readUserSettingsValue(localStorageKey, {});
+    }, [localStorageKey]);
+    const saveSizes = React.useCallback((value) => {
+        if (localStorageKey) {
+            settingsManager.setUserSettingsValue(localStorageKey, value);
+        }
     }, [localStorageKey]);
-    return [tableColumnsWidthSetup, handleSetupChange];
+    return libUseTableResize({ saveSizes, getSizes });
 };

package/dist/utils/monaco/index.js

@@ -1,4 +1,6 @@
 import { registerSExpressionLanguage } from './s-expression/registerLanguage';
+import { registerYqlLanguage } from './yql/registerLanguage';
 export function registerLanguages() {
     registerSExpressionLanguage();
+    registerYqlLanguage();
 }

package/dist/utils/monaco/{yqlSuggestions → yql}/constants.d.ts

@@ -1,3 +1,4 @@
+export declare const LANGUAGE_YQL_ID = "yql";
 export declare const SimpleTypes: string[];
 export declare const SimpleFunctions: string[];
 export declare const AggregateFunctions: string[];

package/dist/utils/monaco/{yqlSuggestions → yql}/constants.js

@@ -1,3 +1,4 @@
+export const LANGUAGE_YQL_ID = 'yql';
 export const SimpleTypes = [
     'String',
     'Bool',

package/dist/utils/monaco/{yqlSuggestions → yql}/generateSuggestions.d.ts

@@ -1,5 +1,5 @@
-import type { ColumnAliasSuggestion, KeywordSuggestion, YqlAutocompleteResult } from '@gravity-ui/websql-autocomplete';
-import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type { ColumnAliasSuggestion, KeywordSuggestion, YQLEntity, YqlAutocompleteResult } from '@gravity-ui/websql-autocomplete';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 export declare function generateColumnsSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestColumns: YqlAutocompleteResult['suggestColumns'] | undefined, database: string): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateColumnAliasesSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestColumnAliases?: ColumnAliasSuggestion[]): {
     label: string;
@@ -17,7 +17,7 @@ export declare function generateKeywordsSuggestion(rangeToInsertSuggestion: mona
     range: monaco.IRange;
     sortText: string;
 }[];
-export declare function generateEntitiesSuggestion(_rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateEntitiesSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestEntities: YQLEntity[], database: string, prefix?: string): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateSimpleFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateSimpleTypesSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateUdfSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;

package/dist/utils/monaco/{yqlSuggestions → yql}/generateSuggestions.js

@@ -1,3 +1,4 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { AggregateFunctions, Pragmas, SimpleFunctions, SimpleTypes, TableFunction, Udfs, WindowFunctions, } from './constants';
 const CompletionItemKind = {
     Method: 0,
@@ -30,6 +31,27 @@ const CompletionItemKind = {
     Snippet: 27,
 };
 const re = /[\s'"-/@]/;
+const suggestionEntityToAutocomplete = {
+    externalDataSource: ['external_data_source'],
+    replication: ['replication'],
+    table: ['table'],
+    tableStore: ['column_store'],
+    topic: ['pers_queue_group'],
+    view: ['view'],
+    //TODO: add after websql-autocomplete support indexex
+    // index: ['table_index', 'index'],
+};
+const commonSuggestionEntities = ['dir', 'unknown'];
+function filterAutocompleteEntities(autocompleteEntities, suggestions) {
+    const suggestionsSet = suggestions.reduce((acc, el) => {
+        const autocompleteEntity = suggestionEntityToAutocomplete[el];
+        if (autocompleteEntity) {
+            autocompleteEntity.forEach((el) => acc.add(el));
+        }
+        return acc;
+    }, new Set(commonSuggestionEntities));
+    return autocompleteEntities.filter(({ Type }) => suggestionsSet.has(Type));
+}
 function wrapStringToBackticks(value) {
     let result = value;
     if (value.match(re)) {
@@ -38,11 +60,29 @@ function wrapStringToBackticks(value) {
     return result;
 }
 function removeBackticks(value) {
-    let normalizedValue = value;
+    let sliceStart = 0;
+    let sliceEnd = value.length;
     if (value.startsWith('`')) {
-        normalizedValue = value.slice(1, -1);
+        sliceStart = 1;
+    }
+    if (value.endsWith('`')) {
+        sliceEnd = -1;
+    }
+    return value.slice(sliceStart, sliceEnd);
+}
+function removeStartSlash(value) {
+    if (value.startsWith('/')) {
+        return value.slice(1);
+    }
+    return value;
+}
+function normalizeEntityPrefix(value = '', database) {
+    let cleanedValue = removeStartSlash(removeBackticks(value));
+    const cleanedDatabase = removeStartSlash(database);
+    if (cleanedValue.startsWith(cleanedDatabase)) {
+        cleanedValue = cleanedValue.slice(cleanedDatabase.length);
     }
-    return normalizedValue;
+    return removeStartSlash(cleanedValue);
 }
 const SuggestionsWeight = {
     suggestTemplates: 0,
@@ -58,50 +98,6 @@ const SuggestionsWeight = {
     suggestUdfs: 10,
     suggestSimpleTypes: 11,
 };
-const KEEP_CACHE_MILLIS = 5 * 60 * 1000;
-function getColumnsWithCache() {
-    const cache = new Map();
-    return async (path) => {
-        var _a, _b, _c, _d;
-        const normalizedPath = removeBackticks(path);
-        const existed = cache.get(path);
-        if (existed) {
-            return existed;
-        }
-        const columns = [];
-        const data = await window.api.getDescribe({ path: normalizedPath });
-        if ((data === null || data === void 0 ? void 0 : data.Status) === 'StatusSuccess') {
-            const desc = data.PathDescription;
-            if ((_a = desc === null || desc === void 0 ? void 0 : desc.Table) === null || _a === void 0 ? void 0 : _a.Columns) {
-                for (const c of desc.Table.Columns) {
-                    if (c.Name) {
-                        columns.push(c.Name);
-                    }
-                }
-            }
-            if ((_c = (_b = desc === null || desc === void 0 ? void 0 : desc.ColumnTableDescription) === null || _b === void 0 ? void 0 : _b.Schema) === null || _c === void 0 ? void 0 : _c.Columns) {
-                for (const c of desc.ColumnTableDescription.Schema.Columns) {
-                    if (c.Name) {
-                        columns.push(c.Name);
-                    }
-                }
-            }
-            if ((_d = desc === null || desc === void 0 ? void 0 : desc.ExternalTableDescription) === null || _d === void 0 ? void 0 : _d.Columns) {
-                for (const c of desc.ExternalTableDescription.Columns) {
-                    if (c.Name) {
-                        columns.push(c.Name);
-                    }
-                }
-            }
-        }
-        cache.set(path, columns);
-        setTimeout(() => {
-            cache.delete(path);
-        }, KEEP_CACHE_MILLIS);
-        return columns;
-    };
-}
-const getColumns = getColumnsWithCache();
 function getSuggestionIndex(suggestionType) {
     return SuggestionsWeight[suggestionType];
 }
@@ -127,28 +123,63 @@ async function getSimpleTypes() {
     return SimpleTypes;
 }
 export async function generateColumnsSuggestion(rangeToInsertSuggestion, suggestColumns, database) {
-    var _a;
+    var _a, _b, _c;
     if (!(suggestColumns === null || suggestColumns === void 0 ? void 0 : suggestColumns.tables)) {
         return [];
     }
     const suggestions = [];
     const multi = suggestColumns.tables.length > 1;
-    for (const entity of (_a = suggestColumns.tables) !== null && _a !== void 0 ? _a : []) {
+    const normalizedTableNames = (_b = (_a = suggestColumns.tables) === null || _a === void 0 ? void 0 : _a.map((entity) => {
         let normalizedEntityName = removeBackticks(entity.name);
-        // if it's relative entity path
-        if (!normalizedEntityName.startsWith('/')) {
-            normalizedEntityName = `${database}/${normalizedEntityName}`;
+        if (!normalizedEntityName.endsWith('/')) {
+            normalizedEntityName = `${normalizedEntityName}/`;
         }
-        const fields = await getColumns(normalizedEntityName);
-        fields.forEach((columnName) => {
-            const normalizedName = wrapStringToBackticks(columnName);
+        return normalizeEntityPrefix(normalizedEntityName, database);
+    })) !== null && _b !== void 0 ? _b : [];
+    // remove duplicates if any
+    const filteredTableNames = Array.from(new Set(normalizedTableNames));
+    const autocompleteResponse = await window.api.autocomplete({
+        database,
+        table: filteredTableNames,
+        limit: 1000,
+    });
+    if (!autocompleteResponse.Success) {
+        return [];
+    }
+    const tableNameToAliasMap = (_c = suggestColumns.tables) === null || _c === void 0 ? void 0 : _c.reduce((acc, entity) => {
+        var _a;
+        const normalizedEntityName = normalizeEntityPrefix(removeBackticks(entity.name), database);
+        const aliases = (_a = acc[normalizedEntityName]) !== null && _a !== void 0 ? _a : [];
+        if (entity.alias) {
+            aliases.push(entity.alias);
+        }
+        acc[normalizedEntityName] = aliases;
+        return acc;
+    }, {});
+    autocompleteResponse.Result.Entities.forEach((col) => {
+        if (col.Type !== 'column') {
+            return;
+        }
+        const normalizedName = wrapStringToBackticks(col.Name);
+        const normalizedParentName = normalizeEntityPrefix(col.Parent, database);
+        const aliases = tableNameToAliasMap[normalizedParentName];
+        if (aliases === null || aliases === void 0 ? void 0 : aliases.length) {
+            aliases.forEach((a) => {
+                const columnNameSuggestion = `${a}.${normalizedName}`;
+                suggestions.push({
+                    label: columnNameSuggestion,
+                    insertText: columnNameSuggestion,
+                    kind: CompletionItemKind.Field,
+                    detail: 'Column',
+                    range: rangeToInsertSuggestion,
+                    sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')),
+                });
+            });
+        }
+        else {
             let columnNameSuggestion = normalizedName;
-            if (entity.alias) {
-                columnNameSuggestion = `${entity.alias}.${normalizedName}`;
-            }
-            else if (multi) {
-                // no need to wrap entity.name to backticks, because it's already with them if needed
-                columnNameSuggestion = `${entity.name}.${normalizedName}`;
+            if (multi) {
+                columnNameSuggestion = `${wrapStringToBackticks(normalizedParentName)}.${normalizedName}`;
             }
             suggestions.push({
                 label: columnNameSuggestion,
@@ -158,8 +189,8 @@ export async function generateColumnsSuggestion(rangeToInsertSuggestion, suggest
                 range: rangeToInsertSuggestion,
                 sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')),
             });
-        });
-    }
+        }
+    });
     return suggestions;
 }
 export function generateColumnAliasesSuggestion(rangeToInsertSuggestion, suggestColumnAliases) {
@@ -188,7 +219,36 @@ export function generateKeywordsSuggestion(rangeToInsertSuggestion, suggestKeywo
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestKeywords')),
     }));
 }
-export async function generateEntitiesSuggestion(_rangeToInsertSuggestion) {
+export async function generateEntitiesSuggestion(rangeToInsertSuggestion, suggestEntities, database, prefix) {
+    const normalizedPrefix = normalizeEntityPrefix(prefix, database);
+    const data = await window.api.autocomplete({ database, prefix: normalizedPrefix, limit: 1000 });
+    const withBackticks = prefix === null || prefix === void 0 ? void 0 : prefix.startsWith('`');
+    if (data.Success) {
+        const filteredEntities = filterAutocompleteEntities(data.Result.Entities, suggestEntities);
+        return filteredEntities.reduce((acc, { Name, Type }) => {
+            const isDir = Type === 'dir';
+            const label = isDir ? `${Name}/` : Name;
+            let labelAsSnippet;
+            if (isDir && !withBackticks) {
+                labelAsSnippet = `\`${label}$0\``;
+            }
+            acc.push({
+                label,
+                insertText: labelAsSnippet !== null && labelAsSnippet !== void 0 ? labelAsSnippet : label,
+                kind: isDir ? CompletionItemKind.Folder : CompletionItemKind.Text,
+                insertTextRules: labelAsSnippet
+                    ? monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet
+                    : monaco.languages.CompletionItemInsertTextRule.None,
+                detail: Type,
+                range: rangeToInsertSuggestion,
+                command: label.endsWith('/')
+                    ? { id: 'editor.action.triggerSuggest', title: '' }
+                    : undefined,
+                sortText: suggestionIndexToWeight(getSuggestionIndex('suggestEntity')),
+            });
+            return acc;
+        }, []);
+    }
     return [];
 }
 export async function generateSimpleFunctionsSuggestion(rangeToInsertSuggestion) {

package/dist/utils/monaco/yql/registerLanguage.d.ts

@@ -0,0 +1 @@
+export declare function registerYqlLanguage(): void;

package/dist/utils/monaco/yql/registerLanguage.js

@@ -0,0 +1,8 @@
+import * as monaco from 'monaco-editor';
+import { LANGUAGE_YQL_ID } from './constants';
+import { conf, getLanguage } from './yql';
+export function registerYqlLanguage() {
+    monaco.languages.register({ id: LANGUAGE_YQL_ID });
+    monaco.languages.setMonarchTokensProvider(LANGUAGE_YQL_ID, getLanguage());
+    monaco.languages.setLanguageConfiguration(LANGUAGE_YQL_ID, conf);
+}

package/dist/utils/monaco/{yqlSuggestions/registerCompletionItemProvider.js → yql/yql.completionItemProvider.js}

@@ -1,4 +1,5 @@
 import * as monaco from 'monaco-editor';
+import { LANGUAGE_YQL_ID } from './constants';
 import { createProvideSuggestionsFunction } from './yqlSuggestions';
 let completionProvider;
 function disableCodeSuggestions() {
@@ -8,8 +9,8 @@ function disableCodeSuggestions() {
 }
 export function registerYQLCompletionItemProvider(database) {
     disableCodeSuggestions();
-    completionProvider = monaco.languages.registerCompletionItemProvider('sql', {
-        triggerCharacters: [' ', '\n', '', ',', '.', '`', '('],
+    completionProvider = monaco.languages.registerCompletionItemProvider(LANGUAGE_YQL_ID, {
+        triggerCharacters: [' ', '', ',', '.', '`', '(', '/'],
         provideCompletionItems: createProvideSuggestionsFunction(database),
     });
 }

package/dist/utils/monaco/yql/yql.d.ts

@@ -0,0 +1,7 @@
+import type * as monaco from 'monaco-editor';
+export declare const conf: monaco.languages.LanguageConfiguration;
+interface LanguageOptions {
+    ansi?: boolean;
+}
+export declare function getLanguage({ ansi, }?: LanguageOptions): monaco.languages.IMonarchLanguage & Record<string, unknown>;
+export {};