@gravity-ui/querieskit 1.3.0 → 1.3.1

package/src/components/MonacoEditor/monaco-yql-languages/_.contribution.ts

@@ -1,193 +0,0 @@
-import {
-    type CancellationToken,
-    Emitter,
-    type IEvent,
-    type Position,
-    type editor,
-    languages,
-} from 'monaco-editor';
-
-interface ILang extends languages.ILanguageExtensionPoint {
-    loader: () => Promise<ILangImpl>;
-}
-
-interface ILangImpl {
-    conf: languages.LanguageConfiguration;
-    language: languages.IMonarchLanguage;
-    provideSuggestionsFunction?: (
-        model: editor.ITextModel,
-        monacoCursorPosition: Position,
-        _context: languages.CompletionContext,
-        _token: CancellationToken,
-    ) =>
-        | {suggestions: languages.CompletionItem[]}
-        | Promise<{suggestions: languages.CompletionItem[]}>;
-    provideInlineSuggestionsFunction?: (
-        model: editor.ITextModel,
-        monacoCursorPosition: Position,
-        _context: languages.InlineCompletionContext,
-        _token: CancellationToken,
-    ) => Promise<{items: languages.InlineCompletion[]}>;
-}
-
-const languageDefinitions: {[languageId: string]: ILang} = {};
-const lazyLanguageLoaders: {[languageId: string]: LazyLanguageLoader} = {};
-
-class LazyLanguageLoader {
-    public static getOrCreate(languageId: string): LazyLanguageLoader {
-        if (!lazyLanguageLoaders[languageId]) {
-            lazyLanguageLoaders[languageId] = new LazyLanguageLoader(languageId);
-        }
-        return lazyLanguageLoaders[languageId];
-    }
-
-    private readonly _languageId: string;
-    private _loadingTriggered: boolean;
-    private _lazyLoadPromise: Promise<ILangImpl>;
-    private _lazyLoadPromiseResolve!: (value: ILangImpl) => void;
-    private _lazyLoadPromiseReject!: (err: unknown) => void;
-
-    constructor(languageId: string) {
-        this._languageId = languageId;
-        this._loadingTriggered = false;
-        this._lazyLoadPromise = new Promise((resolve, reject) => {
-            this._lazyLoadPromiseResolve = resolve;
-            this._lazyLoadPromiseReject = reject;
-        });
-    }
-
-    public whenLoaded(): Promise<ILangImpl> {
-        return this._lazyLoadPromise;
-    }
-
-    public load(): Promise<ILangImpl> {
-        if (!this._loadingTriggered) {
-            this._loadingTriggered = true;
-            languageDefinitions[this._languageId].loader().then(
-                (mod) => this._lazyLoadPromiseResolve(mod),
-                (err) => this._lazyLoadPromiseReject(err),
-            );
-        }
-        return this._lazyLoadPromise;
-    }
-}
-
-export function registerLanguage(def: ILang): void {
-    const languageId = def.id;
-
-    languageDefinitions[languageId] = def;
-    languages.register(def);
-
-    const lazyLanguageLoader = LazyLanguageLoader.getOrCreate(languageId);
-    languages.setMonarchTokensProvider(
-        languageId,
-        lazyLanguageLoader.whenLoaded().then((mod) => mod.language),
-    );
-    languages.onLanguage(languageId, () => {
-        lazyLanguageLoader.load().then((mod) => {
-            languages.setLanguageConfiguration(languageId, mod.conf);
-        });
-    });
-    lazyLanguageLoader.whenLoaded().then((mod) => {
-        if (mod.provideSuggestionsFunction) {
-            languages.registerCompletionItemProvider(languageId, {
-                triggerCharacters: ['`', ':', '/', '', ' '],
-                provideCompletionItems: mod.provideSuggestionsFunction,
-            });
-        }
-        if (mod.provideInlineSuggestionsFunction) {
-            languages.registerInlineCompletionsProvider(languageId, {
-                provideInlineCompletions: mod.provideInlineSuggestionsFunction,
-                disposeInlineCompletions: () => {},
-            });
-        }
-    });
-}
-
-export interface ModeConfiguration {
-    readonly completionItems?: boolean;
-    readonly hovers?: boolean;
-    readonly documentSymbols?: boolean;
-    readonly definitions?: boolean;
-    readonly references?: boolean;
-    readonly documentHighlights?: boolean;
-    readonly rename?: boolean;
-    readonly colors?: boolean;
-    readonly foldingRanges?: boolean;
-    readonly diagnostics?: boolean;
-    readonly selectionRanges?: boolean;
-}
-
-export interface DiagnosticsOptions {
-    readonly validate?: boolean;
-}
-
-export interface LanguageServiceDefaults {
-    readonly languageId: string;
-    readonly onDidChange: IEvent<LanguageServiceDefaults>;
-    readonly diagnosticsOptions: DiagnosticsOptions;
-    readonly modeConfiguration: ModeConfiguration;
-    setDiagnosticsOptions(options: DiagnosticsOptions): void;
-    setModeConfiguration(modeConfiguration: ModeConfiguration): void;
-}
-
-export class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
-    private _onDidChange = new Emitter<LanguageServiceDefaults>();
-    private _diagnosticsOptions!: DiagnosticsOptions;
-    private _modeConfiguration!: ModeConfiguration;
-    private _languageId: string;
-
-    constructor(
-        languageId: string,
-        diagnosticsOptions: DiagnosticsOptions,
-        modeConfiguration: ModeConfiguration,
-    ) {
-        this._languageId = languageId;
-        this.setDiagnosticsOptions(diagnosticsOptions);
-        this.setModeConfiguration(modeConfiguration);
-    }
-
-    public get onDidChange(): IEvent<LanguageServiceDefaults> {
-        return this._onDidChange.event;
-    }
-
-    public get languageId(): string {
-        return this._languageId;
-    }
-
-    public get modeConfiguration(): ModeConfiguration {
-        return this._modeConfiguration;
-    }
-
-    public get diagnosticsOptions(): DiagnosticsOptions {
-        return this._diagnosticsOptions;
-    }
-
-    public setDiagnosticsOptions(options: DiagnosticsOptions): void {
-        this._diagnosticsOptions = options || Object.create(null);
-        this._onDidChange.fire(this);
-    }
-
-    public setModeConfiguration(modeConfiguration: ModeConfiguration): void {
-        this._modeConfiguration = modeConfiguration || Object.create(null);
-        this._onDidChange.fire(this);
-    }
-}
-
-export const modeConfigurationDefault: Required<ModeConfiguration> = {
-    completionItems: true,
-    hovers: true,
-    documentSymbols: true,
-    definitions: true,
-    references: true,
-    documentHighlights: true,
-    rename: true,
-    colors: true,
-    foldingRanges: true,
-    diagnostics: true,
-    selectionRanges: true,
-};
-
-export const diagnosticDefault: Required<DiagnosticsOptions> = {
-    validate: true,
-};

package/src/components/MonacoEditor/monaco-yql-languages/clickhouse/clickhouse.contribution.ts

@@ -1,14 +0,0 @@
-import {registerLanguage} from '../_.contribution';
-import {MonacoLanguage} from '../constants';
-
-registerLanguage({
-    id: MonacoLanguage.CHYT,
-    extensions: [],
-    loader: async () => {
-        const lang = await import('./clickhouse');
-        return {
-            conf: lang.conf,
-            language: lang.language,
-        };
-    },
-});

package/src/components/MonacoEditor/monaco-yql-languages/clickhouse/clickhouse.keywords.ts

@@ -1,146 +0,0 @@
-export const keywords = [
-    'AND',
-    'ANY',
-    'AS',
-    'ASC',
-    'ATTACH',
-    'BETWEEN',
-    'CASE',
-    'CAST',
-    'CREATE',
-    'CROSS',
-    'DATABASE',
-    'DATABASES',
-    'DEFAULT',
-    'DELETE',
-    'DESC',
-    'DESCRIBE',
-    'DETACH',
-    'DISTINCT',
-    'DROP',
-    'ELSE',
-    'END',
-    'FOREIGN',
-    'FROM',
-    'GRANT',
-    'HAVING',
-    'IF',
-    'INNER',
-    'INSERT',
-    'JOIN',
-    'KEY',
-    'LEFT',
-    'NATURAL',
-    'NOT',
-    'OFFSET',
-    'ON',
-    'OPTIMIZE',
-    'OR',
-    'OUTER',
-    'PREWHERE',
-    'PRIMARY',
-    'PROCESSLIST',
-    'REFERENCES',
-    'RIGHT',
-    'SELECT',
-    'SHOW',
-    'TABLE',
-    'THEN',
-    'TO',
-    'TOTALS',
-    'TYPE',
-    'UNION',
-    'UPDATE',
-    'USE',
-    'WHEN',
-    'WHERE',
-    'WITH',
-];
-
-export const constants = ['true', 'false', 'NULL'];
-
-export const functionsCaseSensitive = [
-    'arrayJoin',
-    'count',
-    'sum',
-    'avg',
-    'min',
-    'max',
-    'uniq',
-    'groupArray',
-    'toString',
-    'toDate',
-    'toDateTime',
-    'formatDateTime',
-    'now',
-    'today',
-    'if',
-    'multiIf',
-    'coalesce',
-    'dictGet',
-];
-
-export const functionsCaseInsensitive = [
-    'abs',
-    'avg',
-    'cast',
-    'coalesce',
-    'concat',
-    'count',
-    'if',
-    'length',
-    'lower',
-    'max',
-    'min',
-    'now',
-    'substring',
-    'sum',
-    'upper',
-];
-
-export const tableFunctions = [
-    'cluster',
-    'file',
-    'numbers',
-    'remote',
-    'url',
-    'values',
-    'view',
-    'ytSubquery',
-];
-
-export const tableEngines = ['Buffer', 'Memory', 'YtTable'];
-
-export const dataTypeFamiliesCaseSensitive = [
-    'Array',
-    'Date',
-    'DateTime',
-    'Float32',
-    'Float64',
-    'Int8',
-    'Int16',
-    'Int32',
-    'Int64',
-    'Map',
-    'Nullable',
-    'String',
-    'UInt8',
-    'UInt16',
-    'UInt32',
-    'UInt64',
-    'UUID',
-];
-
-export const dataTypeFamiliesCaseInsensitive = [
-    'BIGINT',
-    'BOOLEAN',
-    'DATE',
-    'DATETIME',
-    'DOUBLE',
-    'FLOAT',
-    'INT',
-    'INTEGER',
-    'STRING',
-    'TEXT',
-    'TIMESTAMP',
-];

package/src/components/MonacoEditor/monaco-yql-languages/clickhouse/clickhouse.ts

@@ -1,217 +0,0 @@
-import {type languages} from '../fillers/monaco-editor-core';
-import {
-    constants,
-    dataTypeFamiliesCaseInsensitive,
-    dataTypeFamiliesCaseSensitive,
-    functionsCaseInsensitive,
-    functionsCaseSensitive,
-    keywords,
-    tableEngines,
-    tableFunctions,
-} from './clickhouse.keywords';
-
-export const conf: languages.LanguageConfiguration = {
-    comments: {
-        lineComment: '--',
-        blockComment: ['```', '```'],
-    },
-    brackets: [
-        ['{', '}'],
-        ['[', ']'],
-        ['(', ')'],
-    ],
-    autoClosingPairs: [
-        {open: '{', close: '}'},
-        {open: '[', close: ']'},
-        {open: '(', close: ')'},
-        {open: '"', close: '"'},
-        {open: "'", close: "'"},
-        {open: '`', close: '`'},
-    ],
-    surroundingPairs: [
-        {open: '{', close: '}'},
-        {open: '[', close: ']'},
-        {open: '(', close: ')'},
-        {open: '"', close: '"'},
-        {open: "'", close: "'"},
-        {open: '`', close: '`'},
-    ],
-};
-
-const keywordsCaseInsensitive = getCaseInsensitiveRegExp(keywords);
-const typeKeywordsCaseInsensitive = getCaseInsensitiveRegExp(
-    oneWordPatterns(dataTypeFamiliesCaseInsensitive),
-);
-const builtinFunctionsCaseInsensitive = getCaseInsensitiveRegExp(functionsCaseInsensitive);
-
-export const language: languages.IMonarchLanguage & Record<string, unknown> = {
-    defaultToken: 'text',
-
-    brackets: [
-        {open: '[', close: ']', token: 'delimiter.square'},
-        {open: '(', close: ')', token: 'delimiter.parenthesis'},
-        {open: '{', close: '}', token: 'delimiter.curly'},
-    ],
-
-    keywords,
-
-    keywordsDouble: [
-        `${caseInsensitiveRegExp('GROUP')}\\W+${caseInsensitiveRegExp('BY')}`,
-        `${caseInsensitiveRegExp('ON')}\\W+${caseInsensitiveRegExp('CLUSTER')}`,
-        `${caseInsensitiveRegExp('ORDER')}\\W+${caseInsensitiveRegExp('BY')}`,
-        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+\\W*,\\W*\\d+`,
-        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+\\W+${caseInsensitiveRegExp('BY')}\\W+`,
-        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+`,
-        `${caseInsensitiveRegExp('RENAME')}\\W+${caseInsensitiveRegExp('TABLE')}`,
-        `${caseInsensitiveRegExp('IF')}\\W+${caseInsensitiveRegExp(
-            'NOT',
-        )}\\W+${caseInsensitiveRegExp('EXISTS')}`,
-        `${caseInsensitiveRegExp('IF')}\\W+${caseInsensitiveRegExp('EXISTS')}`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+Vertical`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+JSONCompact`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+JSONEachRow`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+TSKV`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedWithNames`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedWithNamesAndTypes`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedRaw`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+BlockTabSeparated`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+CSVWithNames`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+CSV`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+JSON`,
-        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparated`,
-    ].join('|'),
-
-    typeKeywords: dataTypeFamiliesCaseSensitive,
-    typeKeywordsDouble: getCaseInsensitiveRegExp(
-        manyWordsPatterns(dataTypeFamiliesCaseInsensitive),
-    ),
-    constants,
-
-    builtinFunctions: functionsCaseSensitive,
-
-    tableFunctions,
-    tableEngines,
-
-    operators: [
-        '+',
-        '-',
-        '/',
-        '//',
-        '%',
-        '<@>',
-        '@>',
-        '<@',
-        '&',
-        '^',
-        '~',
-        '<',
-        '>',
-        '<=',
-        '=>',
-        '==',
-        '!=',
-        '<>',
-        '=',
-    ],
-
-    symbols: /[=><!~?:&|+\-*/^%]+/,
-    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
-    variables: /[\w]+(?:\[[\w\]]+|=-]>[\w]+)?/,
-
-    tokenizer: {
-        root: [
-            {include: '@whitespace'},
-            {include: '@comments'},
-            {include: '@numbers'},
-            {include: '@strings'},
-            [/[$@:](@variables)/, 'variable'],
-            [/\{(@variables)\}/, 'variable'],
-            [/[?;,.]/, 'delimiter'],
-            [/[{}()[\]]/, '@brackets'],
-            [/(\w+\.)*`\/\/(.*?)`/g, {token: 'path'}],
-            [/@keywordsDouble/, 'keyword'],
-            [/@typeKeywordsDouble/, 'keyword.type'],
-            [
-                /[a-zA-Z_$][\w$]*/,
-                {
-                    cases: {
-                        [keywordsCaseInsensitive]: {token: 'keyword'},
-                        '@constants': {token: 'constant'},
-                        '@builtinFunctions': {token: 'constant.other.color'},
-                        [builtinFunctionsCaseInsensitive]: {token: 'constant.other.color'},
-                        '@tableFunctions': {token: 'constant.other.color'},
-                        '@tableEngines': {token: 'constant.other.color'},
-                        '@typeKeywords': {token: 'keyword.type'},
-                        [typeKeywordsCaseInsensitive]: {token: 'keyword.type'},
-                        '@default': 'identifier',
-                    },
-                },
-            ],
-            [
-                /@symbols/,
-                {
-                    cases: {
-                        '@operators': 'operator.sql',
-                        '@default': '',
-                    },
-                },
-            ],
-        ],
-        whitespace: [[/\s+/, 'white']],
-        comments: [
-            [/--+.*/, 'comment'],
-            [/\/\*/, {token: 'comment.quote', next: '@cppComment'}],
-        ],
-        comment: [
-            [/[^`]+/, 'comment'],
-            [/./, 'comment'],
-        ],
-        cppComment: [
-            [/[^*/]+/, 'comment'],
-            [/./, 'comment'],
-        ],
-        numbers: [[/[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b/, 'number']],
-        strings: [
-            [/'/, {token: 'string', next: '@stringSingle'}],
-            [/"/, {token: 'string.tablepath', next: '@stringDouble'}],
-        ],
-        stringSingle: [
-            [/[^\\']/, 'string'],
-            [/@escapes/, 'string.escape'],
-            [/\\./, 'string.escape.invalid'],
-            [/'/, {token: 'string', next: '@pop'}],
-        ],
-        stringDouble: [
-            [/[^\\"]/, 'string.tablepath'],
-            [/@escapes/, 'string.tablepath'],
-            [/\\./, 'string.tablepath'],
-            [/"/, {token: 'string.tablepath', next: '@pop'}],
-        ],
-    },
-};
-
-function caseInsensitiveRegExp(pattern: string) {
-    return pattern
-        .split('')
-        .map((char) => {
-            if (/[a-zA-Z]/.test(char)) {
-                return `[${char.toLowerCase()}${char.toUpperCase()}]`;
-            }
-            return char;
-        })
-        .join('');
-}
-
-function getCaseInsensitiveRegExp(patterns: string[]) {
-    return `(${patterns
-        .map((pattern) => caseInsensitiveRegExp(pattern).replace(/\s+/g, '\\s'))
-        .join('|')})`;
-}
-
-function oneWordPatterns(patterns: string[]) {
-    return patterns.filter((pattern) => /^\S*$/.test(pattern));
-}
-
-function manyWordsPatterns(patterns: string[]) {
-    return patterns.filter((pattern) => /\s/.test(pattern)).sort((a, b) => b.localeCompare(a));
-}

package/src/components/MonacoEditor/monaco-yql-languages/constants.ts

@@ -1,6 +0,0 @@
-export enum MonacoLanguage {
-    YQL = 'yql',
-    YTQL = 'yql_ansi',
-    CHYT = 'clickhouse',
-    SPYT = 's-expression',
-}

package/src/components/MonacoEditor/monaco-yql-languages/fillers/monaco-editor-core.ts

@@ -1,3 +0,0 @@
-// @ts-ignore monaco-editor ships its own types but the default resolution
-// doesn't pick them up for this deep import path in this project setup.
-export * from 'monaco-editor/editor/editor.api';

package/src/components/MonacoEditor/monaco-yql-languages/index.ts

@@ -1 +0,0 @@
-export {MonacoLanguage} from './constants';

package/src/components/MonacoEditor/monaco-yql-languages/monaco.contribution.ts

@@ -1,5 +0,0 @@
-import './clickhouse/clickhouse.contribution';
-import './yql/yql.contribution';
-import './yql_ansi/yql_ansi.contribution';
-import './s-expressions/s-expressions.contribution';
-import './themes/themes.contribution';

package/src/components/MonacoEditor/monaco-yql-languages/s-expressions/s-expressions.contribution.ts

@@ -1,14 +0,0 @@
-import {registerLanguage} from '../_.contribution';
-import {MonacoLanguage} from '../constants';
-
-registerLanguage({
-    id: MonacoLanguage.SPYT,
-    extensions: [],
-    loader: async () => {
-        const lang = await import('./s-expressions');
-        return {
-            conf: lang.conf,
-            language: lang.language,
-        };
-    },
-});