@gravity-ui/querieskit 1.2.0 → 1.3.1

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,
-        };
-    },
-});

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

@@ -1,97 +0,0 @@
-export const keywords = [
-    'ALL',
-    'AND',
-    'AS',
-    'ASC',
-    'BETWEEN',
-    'BY',
-    'CASE',
-    'CAST',
-    'CREATE',
-    'CROSS',
-    'DELETE',
-    'DESC',
-    'DISTINCT',
-    'DROP',
-    'ELSE',
-    'END',
-    'EXCEPT',
-    'EXISTS',
-    'FALSE',
-    'FROM',
-    'FULL',
-    'GROUP',
-    'HAVING',
-    'IF',
-    'IN',
-    'INNER',
-    'INSERT',
-    'INTERSECT',
-    'INTO',
-    'IS',
-    'JOIN',
-    'LEFT',
-    'LIKE',
-    'LIMIT',
-    'NOT',
-    'NULL',
-    'OFFSET',
-    'ON',
-    'OR',
-    'ORDER',
-    'OUTER',
-    'RIGHT',
-    'SELECT',
-    'SET',
-    'TABLE',
-    'THEN',
-    'TRUE',
-    'UNION',
-    'UPDATE',
-    'USING',
-    'VALUES',
-    'WHEN',
-    'WHERE',
-    'WITH',
-];
-
-export const operators = ['MOD', 'INCLUDE', 'EXCLUDE', 'ILIKE', 'RLIKE', 'PIVOT', 'UNPIVOT'];
-
-export const builtinFunctions = [
-    'AVG',
-    'COUNT',
-    'MAX',
-    'MIN',
-    'SUM',
-    'ABS',
-    'COALESCE',
-    'CONCAT',
-    'LENGTH',
-    'LOWER',
-    'UPPER',
-    'SUBSTRING',
-    'TRIM',
-    'CAST',
-    'IFNULL',
-    'NVL',
-];
-
-export const typeKeywords = [
-    'BOOLEAN',
-    'TINYINT',
-    'SMALLINT',
-    'INT',
-    'INTEGER',
-    'BIGINT',
-    'FLOAT',
-    'DOUBLE',
-    'DATE',
-    'TIMESTAMP',
-    'STRING',
-    'BINARY',
-    'ARRAY',
-    'MAP',
-    'STRUCT',
-];
-
-export const scopeKeywords = ['CASE', 'END', 'WHEN', 'THEN', 'ELSE'];

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

@@ -1,170 +0,0 @@
-import {type languages} from '../fillers/monaco-editor-core';
-import {
-    builtinFunctions,
-    keywords,
-    operators,
-    scopeKeywords,
-    typeKeywords,
-} from './s-expressions.keywords';
-
-export const LANGUAGE_ID = 's-expression';
-
-const TokenClassConsts = {
-    BINARY: 'binary',
-    BINARY_ESCAPE: 'binary.escape',
-    COMMENT: 'comment',
-    COMMENT_QUOTE: 'comment.quote',
-    DELIMITER: 'delimiter',
-    IDENTIFIER: 'identifier',
-    KEYWORD: 'keyword',
-    KEYWORD_SCOPE: 'keyword.scope',
-    NUMBER: 'number',
-    NUMBER_FLOAT: 'number.float',
-    NUMBER_HEX: 'number.hex',
-    OPERATOR_KEYWORD: 'operator.keyword',
-    OPERATOR_SYMBOL: 'operator.symbol',
-    PREDEFINED: 'predefined',
-    STRING: 'string',
-    STRING_ESCAPE: 'string.escape',
-    TYPE: 'type',
-    VARIABLE: 'variable',
-    WHITE: 'white',
-};
-
-export const conf: languages.LanguageConfiguration = {
-    comments: {
-        lineComment: '#',
-    },
-    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: '`'},
-    ],
-};
-
-export const language: languages.IMonarchLanguage & Record<string, unknown> = {
-    defaultToken: 'text',
-    ignoreCase: true,
-    tokenPostfix: '.yql',
-
-    brackets: [
-        {open: '[', close: ']', token: 'delimiter.square'},
-        {open: '(', close: ')', token: 'delimiter.parenthesis'},
-        {open: '{', close: '}', token: 'delimiter.curly'},
-    ],
-
-    builtinFunctions,
-    builtinVariables: [],
-    keywords,
-    typeKeywords,
-    scopeKeywords,
-    operators,
-    pseudoColumns: [],
-
-    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
-
-    tokenizer: {
-        root: [
-            {include: '@comments'},
-            {include: '@whitespace'},
-            {include: '@pseudoColumns'},
-            {include: '@numbers'},
-            {include: '@binaries'},
-            {include: '@strings'},
-            {include: '@scopes'},
-            {include: '@complexDataTypes'},
-            [/[;,.]/, TokenClassConsts.DELIMITER],
-            [/[(){}[\]]/, '@brackets'],
-            [/yt\.`(\/\/.*?)`/g, {token: 'path'}],
-            [
-                /[\w@#$]+/,
-                {
-                    cases: {
-                        '@scopeKeywords': TokenClassConsts.KEYWORD_SCOPE,
-                        '@operators': TokenClassConsts.OPERATOR_KEYWORD,
-                        '@typeKeywords': TokenClassConsts.TYPE,
-                        '@builtinVariables': TokenClassConsts.VARIABLE,
-                        '@builtinFunctions': TokenClassConsts.PREDEFINED,
-                        '@keywords': TokenClassConsts.KEYWORD,
-                        '@default': TokenClassConsts.IDENTIFIER,
-                    },
-                },
-            ],
-            [/[<>=!%&+\-*/|~^]/, TokenClassConsts.OPERATOR_SYMBOL],
-        ],
-        whitespace: [[/[\s\t\r\n]+/, TokenClassConsts.WHITE]],
-        comments: [
-            [/--+.*/, TokenClassConsts.COMMENT],
-            [/\/\*/, {token: TokenClassConsts.COMMENT_QUOTE, next: '@comment'}],
-        ],
-        comment: [
-            [/[^*/]+/, TokenClassConsts.COMMENT],
-            [/\*\//, {token: TokenClassConsts.COMMENT_QUOTE, next: '@pop'}],
-            [/./, TokenClassConsts.COMMENT],
-        ],
-        pseudoColumns: [
-            [
-                /[$][A-Za-z_][\w@#$]*/,
-                {
-                    cases: {
-                        '@pseudoColumns': TokenClassConsts.PREDEFINED,
-                        '@default': TokenClassConsts.IDENTIFIER,
-                    },
-                },
-            ],
-        ],
-        numbers: [
-            [/0[xX][0-9a-fA-F]*/, TokenClassConsts.NUMBER_HEX],
-            [/[$][+-]*\d*(\.\d*)?/, TokenClassConsts.NUMBER],
-            [/((\d+(\.\d*)?)|(\.\d+))([eE][-+]?\d+)?/, TokenClassConsts.NUMBER_FLOAT],
-        ],
-        binaries: [
-            [/X'/i, {token: TokenClassConsts.BINARY, next: '@binarySingle'}],
-            [/X"/i, {token: TokenClassConsts.BINARY, next: '@binaryDouble'}],
-        ],
-        binarySingle: [
-            [/\d+/, TokenClassConsts.BINARY_ESCAPE],
-            [/''/, TokenClassConsts.BINARY],
-            [/'/, {token: TokenClassConsts.BINARY, next: '@pop'}],
-        ],
-        binaryDouble: [
-            [/\d+/, TokenClassConsts.BINARY_ESCAPE],
-            [/""/, TokenClassConsts.BINARY],
-            [/"/, {token: TokenClassConsts.BINARY, next: '@pop'}],
-        ],
-        strings: [
-            [/'/, {token: TokenClassConsts.STRING, next: '@stringSingle'}],
-            [/R'/i, {token: TokenClassConsts.STRING, next: '@stringSingle'}],
-            [/"/, {token: TokenClassConsts.STRING, next: '@stringDouble'}],
-            [/R"/i, {token: TokenClassConsts.STRING, next: '@stringDouble'}],
-        ],
-        stringSingle: [
-            [/[^']+/, TokenClassConsts.STRING_ESCAPE],
-            [/''/, TokenClassConsts.STRING],
-            [/'/, {token: TokenClassConsts.STRING, next: '@pop'}],
-        ],
-        stringDouble: [
-            [/[^"]+/, TokenClassConsts.STRING_ESCAPE],
-            [/""/, TokenClassConsts.STRING],
-            [/"/, {token: TokenClassConsts.STRING, next: '@pop'}],
-        ],
-        scopes: [],
-        complexDataTypes: [],
-    },
-};