@gravity-ui/querieskit 1.0.1

package/build/esm/components/HistoryPrivateIcon/HistoryPrivateIcon.scss

@@ -0,0 +1,7 @@
+.qp-history-private-icon {
+  color: var(--g-color-text-complementary);
+
+  &_open {
+    color: var(--g-color-text-positive-heavy);
+  }
+}

package/build/esm/components/HistoryPrivateIcon/index.d.ts

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

package/build/esm/components/HistoryPrivateIcon/index.js

@@ -0,0 +1,2 @@
+export { HistoryPrivateIcon } from "./HistoryPrivateIcon";
+// #sourceMappingURL=index.js.map

package/build/esm/components/HistoryPrivateIcon/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["HistoryPrivateIcon"],"sources":["index.ts"],"sourcesContent":["export {HistoryPrivateIcon} from './HistoryPrivateIcon';\n"],"mappings":"AAAA,SAAQA,kBAAkB","ignoreList":[]}

package/build/esm/components/MonacoEditor/MonacoEditor.d.ts

@@ -0,0 +1,15 @@
+import { FC } from 'react';
+import * as monaco from 'monaco-editor/editor/editor.api';
+import './monaco-yql-languages/monaco.contribution';
+export type MonacoEditorConfig = Omit<monaco.editor.IStandaloneEditorConstructionOptions, 'theme'>;
+type Props = {
+    value: string;
+    readOnly?: boolean;
+    language?: string;
+    theme?: string;
+    onClick?: (e: monaco.editor.IEditorMouseEvent) => void;
+    monacoConfig?: MonacoEditorConfig;
+    className?: string;
+};
+export declare const MonacoEditor: FC<Props>;
+export {};

package/build/esm/components/MonacoEditor/MonacoEditor.js

@@ -0,0 +1,99 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import React, { useEffect, useRef } from 'react';
+// @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.
+import * as monaco from 'monaco-editor/editor/editor.api';
+import "./monaco-yql-languages/monaco.contribution";
+import { MONACO_THEME_BY_UI, YT_LIGHT_MONACO_THEME } from "./MonacoEditorThemes";
+import { jsx as _jsx } from "react/jsx-runtime";
+var resolveTheme = function resolveTheme(theme) {
+  var _MONACO_THEME_BY_UI$t;
+  if (!theme) {
+    return YT_LIGHT_MONACO_THEME;
+  }
+  return (_MONACO_THEME_BY_UI$t = MONACO_THEME_BY_UI[theme]) !== null && _MONACO_THEME_BY_UI$t !== void 0 ? _MONACO_THEME_BY_UI$t : theme;
+};
+export var MonacoEditor = function MonacoEditor(_ref) {
+  var value = _ref.value,
+    language = _ref.language,
+    theme = _ref.theme,
+    readOnly = _ref.readOnly,
+    onClick = _ref.onClick,
+    monacoConfig = _ref.monacoConfig,
+    className = _ref.className;
+  var containerRef = useRef(null);
+  var editorRef = useRef(null);
+  var modelRef = useRef(null);
+  // Keeps the latest `onClick` without re-subscribing the mouse listener
+  // on every render (avoids stale closures without extra effect churn).
+  var onClickRef = useRef(onClick);
+  onClickRef.current = onClick;
+
+  // Create the editor + model once per mount, dispose both on unmount.
+  useEffect(function () {
+    if (!containerRef.current) return undefined;
+    var model = monaco.editor.createModel(value, language);
+    modelRef.current = model;
+    var editorInstance = monaco.editor.create(containerRef.current, _objectSpread({
+      model: model,
+      renderLineHighlight: 'none',
+      colorDecorators: true,
+      automaticLayout: true,
+      readOnly: readOnly,
+      minimap: {
+        enabled: false
+      },
+      lineNumbers: 'on',
+      suggestOnTriggerCharacters: true,
+      wordBasedSuggestions: 'off',
+      theme: resolveTheme(theme)
+    }, monacoConfig));
+    editorRef.current = editorInstance;
+    var mouseDownSubscription = editorInstance.onMouseDown(function (e) {
+      var _onClickRef$current;
+      (_onClickRef$current = onClickRef.current) === null || _onClickRef$current === void 0 || _onClickRef$current.call(onClickRef, e);
+    });
+    return function () {
+      mouseDownSubscription.dispose();
+      editorInstance.dispose();
+      model.dispose();
+      editorRef.current = null;
+      modelRef.current = null;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // Keep the model text in sync with the `value` prop after the initial mount.
+  useEffect(function () {
+    var model = modelRef.current;
+    if (model && model.getValue() !== value) {
+      model.setValue(value);
+    }
+  }, [value]);
+
+  // Keep the model language in sync with the `language` prop.
+  useEffect(function () {
+    var model = modelRef.current;
+    if (model && language !== undefined) {
+      monaco.editor.setModelLanguage(model, language);
+    }
+  }, [language]);
+
+  // Keep the editor theme in sync with the `theme` prop.
+  useEffect(function () {
+    monaco.editor.setTheme(resolveTheme(theme));
+  }, [theme]);
+
+  // Re-apply options (e.g. `readOnly`, `monacoConfig`) when they change.
+  useEffect(function () {
+    var _editorRef$current;
+    (_editorRef$current = editorRef.current) === null || _editorRef$current === void 0 || _editorRef$current.updateOptions(_objectSpread({
+      readOnly: readOnly
+    }, monacoConfig));
+  }, [readOnly, monacoConfig]);
+  return /*#__PURE__*/_jsx("div", {
+    ref: containerRef,
+    className: className
+  });
+};
+// #sourceMappingURL=MonacoEditor.js.map

package/build/esm/components/MonacoEditor/MonacoEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useEffect","useRef","monaco","MONACO_THEME_BY_UI","YT_LIGHT_MONACO_THEME","jsx","_jsx","resolveTheme","theme","_MONACO_THEME_BY_UI$t","MonacoEditor","_ref","value","language","readOnly","onClick","monacoConfig","className","containerRef","editorRef","modelRef","onClickRef","current","undefined","model","editor","createModel","editorInstance","create","_objectSpread","renderLineHighlight","colorDecorators","automaticLayout","minimap","enabled","lineNumbers","suggestOnTriggerCharacters","wordBasedSuggestions","mouseDownSubscription","onMouseDown","e","_onClickRef$current","call","dispose","getValue","setValue","setModelLanguage","setTheme","_editorRef$current","updateOptions","ref"],"sources":["MonacoEditor.tsx"],"sourcesContent":["import React, {FC, useEffect, useRef} from 'react';\n// @ts-ignore monaco-editor ships its own types but the default resolution\n// doesn't pick them up for this deep import path in this project setup.\nimport * as monaco from 'monaco-editor/editor/editor.api';\nimport './monaco-yql-languages/monaco.contribution';\nimport {MONACO_THEME_BY_UI, MonacoThemeName, YT_LIGHT_MONACO_THEME} from './MonacoEditorThemes';\n\nexport type MonacoEditorConfig = Omit<monaco.editor.IStandaloneEditorConstructionOptions, 'theme'>;\n\ntype Props = {\n    value: string;\n    readOnly?: boolean;\n    language?: string;\n    theme?: string;\n    onClick?: (e: monaco.editor.IEditorMouseEvent) => void;\n    monacoConfig?: MonacoEditorConfig;\n    className?: string;\n};\n\nconst resolveTheme = (theme?: string): MonacoThemeName => {\n    if (!theme) {\n        return YT_LIGHT_MONACO_THEME;\n    }\n    return (MONACO_THEME_BY_UI[theme] ?? theme) as MonacoThemeName;\n};\n\nexport const MonacoEditor: FC<Props> = ({\n    value,\n    language,\n    theme,\n    readOnly,\n    onClick,\n    monacoConfig,\n    className,\n}) => {\n    const containerRef = useRef<HTMLDivElement>(null);\n    const editorRef = useRef<monaco.editor.IStandaloneCodeEditor | null>(null);\n    const modelRef = useRef<monaco.editor.ITextModel | null>(null);\n    // Keeps the latest `onClick` without re-subscribing the mouse listener\n    // on every render (avoids stale closures without extra effect churn).\n    const onClickRef = useRef(onClick);\n    onClickRef.current = onClick;\n\n    // Create the editor + model once per mount, dispose both on unmount.\n    useEffect(() => {\n        if (!containerRef.current) return undefined;\n\n        const model = monaco.editor.createModel(value, language);\n        modelRef.current = model;\n\n        const editorInstance = monaco.editor.create(containerRef.current, {\n            model,\n            renderLineHighlight: 'none',\n            colorDecorators: true,\n            automaticLayout: true,\n            readOnly,\n            minimap: {\n                enabled: false,\n            },\n            lineNumbers: 'on',\n            suggestOnTriggerCharacters: true,\n            wordBasedSuggestions: 'off',\n            theme: resolveTheme(theme),\n            ...monacoConfig,\n        });\n        editorRef.current = editorInstance;\n\n        const mouseDownSubscription = editorInstance.onMouseDown((e) => {\n            onClickRef.current?.(e);\n        });\n\n        return () => {\n            mouseDownSubscription.dispose();\n            editorInstance.dispose();\n            model.dispose();\n            editorRef.current = null;\n            modelRef.current = null;\n        };\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, []);\n\n    // Keep the model text in sync with the `value` prop after the initial mount.\n    useEffect(() => {\n        const model = modelRef.current;\n        if (model && model.getValue() !== value) {\n            model.setValue(value);\n        }\n    }, [value]);\n\n    // Keep the model language in sync with the `language` prop.\n    useEffect(() => {\n        const model = modelRef.current;\n        if (model && language !== undefined) {\n            monaco.editor.setModelLanguage(model, language);\n        }\n    }, [language]);\n\n    // Keep the editor theme in sync with the `theme` prop.\n    useEffect(() => {\n        monaco.editor.setTheme(resolveTheme(theme));\n    }, [theme]);\n\n    // Re-apply options (e.g. `readOnly`, `monacoConfig`) when they change.\n    useEffect(() => {\n        editorRef.current?.updateOptions({\n            readOnly,\n            ...monacoConfig,\n        });\n    }, [readOnly, monacoConfig]);\n\n    return <div ref={containerRef} className={className}></div>;\n};\n"],"mappings":"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","ignoreList":[]}

package/build/esm/components/MonacoEditor/MonacoEditorThemes.d.ts

@@ -0,0 +1,6 @@
+export declare const YT_LIGHT_MONACO_THEME = "yt-light";
+export declare const YT_LIGHT_HC_MONACO_THEME = "yt-light-hc";
+export declare const YT_DARK_MONACO_THEME = "yt-dark";
+export declare const YT_DARK_HC_MONACO_THEME = "yt-dark-hc";
+export type MonacoThemeName = typeof YT_LIGHT_MONACO_THEME | typeof YT_LIGHT_HC_MONACO_THEME | typeof YT_DARK_MONACO_THEME | typeof YT_DARK_HC_MONACO_THEME | 'vs' | 'vs-dark' | 'hc-black' | 'hc-light';
+export declare const MONACO_THEME_BY_UI: Record<string, MonacoThemeName>;

package/build/esm/components/MonacoEditor/MonacoEditorThemes.js

@@ -0,0 +1,69 @@
+// @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.
+import * as monaco from 'monaco-editor/editor/editor.api';
+var lightRules = [{
+  token: 'string.tablepath',
+  foreground: '3e999f'
+}, {
+  token: 'path',
+  foreground: '3e999f',
+  fontStyle: 'underline'
+}, {
+  token: 'string.sql',
+  foreground: 'a31515'
+}];
+export var YT_LIGHT_MONACO_THEME = 'yt-light';
+monaco.editor.defineTheme(YT_LIGHT_MONACO_THEME, {
+  base: 'vs',
+  inherit: true,
+  rules: lightRules,
+  colors: {
+    'editorLineNumber.foreground': '#000000b3',
+    'editor.lineHighlightBackground': '#0000000a',
+    'editorGutter.background': '#0000000a'
+  }
+});
+export var YT_LIGHT_HC_MONACO_THEME = 'yt-light-hc';
+monaco.editor.defineTheme(YT_LIGHT_HC_MONACO_THEME, {
+  base: 'hc-light',
+  inherit: true,
+  rules: lightRules,
+  colors: {}
+});
+var darkRules = [{
+  token: 'string.tablepath',
+  foreground: '3e999f'
+}, {
+  token: 'path',
+  foreground: '3e999f',
+  fontStyle: 'underline'
+}, {
+  token: 'string.sql',
+  foreground: 'ce9178'
+}];
+export var YT_DARK_MONACO_THEME = 'yt-dark';
+monaco.editor.defineTheme(YT_DARK_MONACO_THEME, {
+  base: 'vs-dark',
+  inherit: true,
+  rules: darkRules,
+  colors: {
+    'editorLineNumber.foreground': '#ffffffb3',
+    'editor.lineHighlightBackground': '#ffffff0a',
+    'editorGutter.background': '#ffffff0a',
+    'editor.background': '#2d2c33'
+  }
+});
+export var YT_DARK_HC_MONACO_THEME = 'yt-dark-hc';
+monaco.editor.defineTheme(YT_DARK_HC_MONACO_THEME, {
+  base: 'hc-black',
+  inherit: true,
+  rules: darkRules,
+  colors: {}
+});
+export var MONACO_THEME_BY_UI = {
+  dark: YT_DARK_MONACO_THEME,
+  'dark-hc': YT_DARK_HC_MONACO_THEME,
+  light: YT_LIGHT_MONACO_THEME,
+  'light-hc': YT_LIGHT_HC_MONACO_THEME
+};
+// #sourceMappingURL=MonacoEditorThemes.js.map

package/build/esm/components/MonacoEditor/MonacoEditorThemes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["monaco","lightRules","token","foreground","fontStyle","YT_LIGHT_MONACO_THEME","editor","defineTheme","base","inherit","rules","colors","YT_LIGHT_HC_MONACO_THEME","darkRules","YT_DARK_MONACO_THEME","YT_DARK_HC_MONACO_THEME","MONACO_THEME_BY_UI","dark","light"],"sources":["MonacoEditorThemes.tsx"],"sourcesContent":["// @ts-ignore monaco-editor ships its own types but the default resolution\n// doesn't pick them up for this deep import path in this project setup.\nimport * as monaco from 'monaco-editor/editor/editor.api';\n\nconst lightRules = [\n    {token: 'string.tablepath', foreground: '3e999f'},\n    {token: 'path', foreground: '3e999f', fontStyle: 'underline'},\n    {token: 'string.sql', foreground: 'a31515'},\n];\n\nexport const YT_LIGHT_MONACO_THEME = 'yt-light';\nmonaco.editor.defineTheme(YT_LIGHT_MONACO_THEME, {\n    base: 'vs',\n    inherit: true,\n    rules: lightRules,\n    colors: {\n        'editorLineNumber.foreground': '#000000b3',\n        'editor.lineHighlightBackground': '#0000000a',\n        'editorGutter.background': '#0000000a',\n    },\n});\n\nexport const YT_LIGHT_HC_MONACO_THEME = 'yt-light-hc';\nmonaco.editor.defineTheme(YT_LIGHT_HC_MONACO_THEME, {\n    base: 'hc-light',\n    inherit: true,\n    rules: lightRules,\n    colors: {},\n});\n\nconst darkRules = [\n    {token: 'string.tablepath', foreground: '3e999f'},\n    {token: 'path', foreground: '3e999f', fontStyle: 'underline'},\n    {token: 'string.sql', foreground: 'ce9178'},\n];\n\nexport const YT_DARK_MONACO_THEME = 'yt-dark';\nmonaco.editor.defineTheme(YT_DARK_MONACO_THEME, {\n    base: 'vs-dark',\n    inherit: true,\n    rules: darkRules,\n    colors: {\n        'editorLineNumber.foreground': '#ffffffb3',\n        'editor.lineHighlightBackground': '#ffffff0a',\n        'editorGutter.background': '#ffffff0a',\n        'editor.background': '#2d2c33',\n    },\n});\n\nexport const YT_DARK_HC_MONACO_THEME = 'yt-dark-hc';\nmonaco.editor.defineTheme(YT_DARK_HC_MONACO_THEME, {\n    base: 'hc-black',\n    inherit: true,\n    rules: darkRules,\n    colors: {},\n});\n\nexport type MonacoThemeName =\n    | typeof YT_LIGHT_MONACO_THEME\n    | typeof YT_LIGHT_HC_MONACO_THEME\n    | typeof YT_DARK_MONACO_THEME\n    | typeof YT_DARK_HC_MONACO_THEME\n    | 'vs'\n    | 'vs-dark'\n    | 'hc-black'\n    | 'hc-light';\n\nexport const MONACO_THEME_BY_UI: Record<string, MonacoThemeName> = {\n    dark: YT_DARK_MONACO_THEME,\n    'dark-hc': YT_DARK_HC_MONACO_THEME,\n    light: YT_LIGHT_MONACO_THEME,\n    'light-hc': YT_LIGHT_HC_MONACO_THEME,\n};\n"],"mappings":"AAAA;AACA;AACA,OAAO,KAAKA,MAAM,MAAM,iCAAiC;AAEzD,IAAMC,UAAU,GAAG,CACf;EAACC,KAAK,EAAE,kBAAkB;EAAEC,UAAU,EAAE;AAAQ,CAAC,EACjD;EAACD,KAAK,EAAE,MAAM;EAAEC,UAAU,EAAE,QAAQ;EAAEC,SAAS,EAAE;AAAW,CAAC,EAC7D;EAACF,KAAK,EAAE,YAAY;EAAEC,UAAU,EAAE;AAAQ,CAAC,CAC9C;AAED,OAAO,IAAME,qBAAqB,GAAG,UAAU;AAC/CL,MAAM,CAACM,MAAM,CAACC,WAAW,CAACF,qBAAqB,EAAE;EAC7CG,IAAI,EAAE,IAAI;EACVC,OAAO,EAAE,IAAI;EACbC,KAAK,EAAET,UAAU;EACjBU,MAAM,EAAE;IACJ,6BAA6B,EAAE,WAAW;IAC1C,gCAAgC,EAAE,WAAW;IAC7C,yBAAyB,EAAE;EAC/B;AACJ,CAAC,CAAC;AAEF,OAAO,IAAMC,wBAAwB,GAAG,aAAa;AACrDZ,MAAM,CAACM,MAAM,CAACC,WAAW,CAACK,wBAAwB,EAAE;EAChDJ,IAAI,EAAE,UAAU;EAChBC,OAAO,EAAE,IAAI;EACbC,KAAK,EAAET,UAAU;EACjBU,MAAM,EAAE,CAAC;AACb,CAAC,CAAC;AAEF,IAAME,SAAS,GAAG,CACd;EAACX,KAAK,EAAE,kBAAkB;EAAEC,UAAU,EAAE;AAAQ,CAAC,EACjD;EAACD,KAAK,EAAE,MAAM;EAAEC,UAAU,EAAE,QAAQ;EAAEC,SAAS,EAAE;AAAW,CAAC,EAC7D;EAACF,KAAK,EAAE,YAAY;EAAEC,UAAU,EAAE;AAAQ,CAAC,CAC9C;AAED,OAAO,IAAMW,oBAAoB,GAAG,SAAS;AAC7Cd,MAAM,CAACM,MAAM,CAACC,WAAW,CAACO,oBAAoB,EAAE;EAC5CN,IAAI,EAAE,SAAS;EACfC,OAAO,EAAE,IAAI;EACbC,KAAK,EAAEG,SAAS;EAChBF,MAAM,EAAE;IACJ,6BAA6B,EAAE,WAAW;IAC1C,gCAAgC,EAAE,WAAW;IAC7C,yBAAyB,EAAE,WAAW;IACtC,mBAAmB,EAAE;EACzB;AACJ,CAAC,CAAC;AAEF,OAAO,IAAMI,uBAAuB,GAAG,YAAY;AACnDf,MAAM,CAACM,MAAM,CAACC,WAAW,CAACQ,uBAAuB,EAAE;EAC/CP,IAAI,EAAE,UAAU;EAChBC,OAAO,EAAE,IAAI;EACbC,KAAK,EAAEG,SAAS;EAChBF,MAAM,EAAE,CAAC;AACb,CAAC,CAAC;AAYF,OAAO,IAAMK,kBAAmD,GAAG;EAC/DC,IAAI,EAAEH,oBAAoB;EAC1B,SAAS,EAAEC,uBAAuB;EAClCG,KAAK,EAAEb,qBAAqB;EAC5B,UAAU,EAAEO;AAChB,CAAC","ignoreList":[]}

package/build/esm/components/MonacoEditor/index.d.ts

@@ -0,0 +1,5 @@
+export { MonacoEditor } from './MonacoEditor';
+export type { MonacoEditorConfig } from './MonacoEditor';
+export { MonacoLanguage } from './monaco-yql-languages';
+export { YT_DARK_HC_MONACO_THEME, YT_DARK_MONACO_THEME, YT_LIGHT_HC_MONACO_THEME, YT_LIGHT_MONACO_THEME, MONACO_THEME_BY_UI, } from './MonacoEditorThemes';
+export type { MonacoThemeName } from './MonacoEditorThemes';

package/build/esm/components/MonacoEditor/index.js

@@ -0,0 +1,4 @@
+export { MonacoEditor } from "./MonacoEditor";
+export { MonacoLanguage } from "./monaco-yql-languages";
+export { YT_DARK_HC_MONACO_THEME, YT_DARK_MONACO_THEME, YT_LIGHT_HC_MONACO_THEME, YT_LIGHT_MONACO_THEME, MONACO_THEME_BY_UI } from "./MonacoEditorThemes";
+// #sourceMappingURL=index.js.map

package/build/esm/components/MonacoEditor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MonacoEditor","MonacoLanguage","YT_DARK_HC_MONACO_THEME","YT_DARK_MONACO_THEME","YT_LIGHT_HC_MONACO_THEME","YT_LIGHT_MONACO_THEME","MONACO_THEME_BY_UI"],"sources":["index.ts"],"sourcesContent":["export {MonacoEditor} from './MonacoEditor';\nexport type {MonacoEditorConfig} from './MonacoEditor';\nexport {MonacoLanguage} from './monaco-yql-languages';\nexport {\n    YT_DARK_HC_MONACO_THEME,\n    YT_DARK_MONACO_THEME,\n    YT_LIGHT_HC_MONACO_THEME,\n    YT_LIGHT_MONACO_THEME,\n    MONACO_THEME_BY_UI,\n} from './MonacoEditorThemes';\nexport type {MonacoThemeName} from './MonacoEditorThemes';\n"],"mappings":"AAAA,SAAQA,YAAY;AAEpB,SAAQC,cAAc;AACtB,SACIC,uBAAuB,EACvBC,oBAAoB,EACpBC,wBAAwB,EACxBC,qBAAqB,EACrBC,kBAAkB","ignoreList":[]}

package/build/esm/components/MonacoEditor/monaco-yql-languages/_.contribution.d.ts

@@ -0,0 +1,57 @@
+import { type CancellationToken, 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[];
+    }>;
+}
+export declare function registerLanguage(def: ILang): void;
+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 declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
+    private _onDidChange;
+    private _diagnosticsOptions;
+    private _modeConfiguration;
+    private _languageId;
+    constructor(languageId: string, diagnosticsOptions: DiagnosticsOptions, modeConfiguration: ModeConfiguration);
+    get onDidChange(): IEvent<LanguageServiceDefaults>;
+    get languageId(): string;
+    get modeConfiguration(): ModeConfiguration;
+    get diagnosticsOptions(): DiagnosticsOptions;
+    setDiagnosticsOptions(options: DiagnosticsOptions): void;
+    setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+}
+export declare const modeConfigurationDefault: Required<ModeConfiguration>;
+export declare const diagnosticDefault: Required<DiagnosticsOptions>;
+export {};

package/build/esm/components/MonacoEditor/monaco-yql-languages/_.contribution.js

@@ -0,0 +1,143 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import "core-js/modules/es.object.create.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import { Emitter, languages } from 'monaco-editor';
+var languageDefinitions = {};
+var lazyLanguageLoaders = {};
+var LazyLanguageLoader = /*#__PURE__*/function () {
+  function LazyLanguageLoader(languageId) {
+    var _this = this;
+    _classCallCheck(this, LazyLanguageLoader);
+    this._languageId = void 0;
+    this._loadingTriggered = void 0;
+    this._lazyLoadPromise = void 0;
+    this._lazyLoadPromiseResolve = void 0;
+    this._lazyLoadPromiseReject = void 0;
+    this._languageId = languageId;
+    this._loadingTriggered = false;
+    this._lazyLoadPromise = new Promise(function (resolve, reject) {
+      _this._lazyLoadPromiseResolve = resolve;
+      _this._lazyLoadPromiseReject = reject;
+    });
+  }
+  return _createClass(LazyLanguageLoader, [{
+    key: "whenLoaded",
+    value: function whenLoaded() {
+      return this._lazyLoadPromise;
+    }
+  }, {
+    key: "load",
+    value: function load() {
+      var _this2 = this;
+      if (!this._loadingTriggered) {
+        this._loadingTriggered = true;
+        languageDefinitions[this._languageId].loader().then(function (mod) {
+          return _this2._lazyLoadPromiseResolve(mod);
+        }, function (err) {
+          return _this2._lazyLoadPromiseReject(err);
+        });
+      }
+      return this._lazyLoadPromise;
+    }
+  }], [{
+    key: "getOrCreate",
+    value: function getOrCreate(languageId) {
+      if (!lazyLanguageLoaders[languageId]) {
+        lazyLanguageLoaders[languageId] = new LazyLanguageLoader(languageId);
+      }
+      return lazyLanguageLoaders[languageId];
+    }
+  }]);
+}();
+export function registerLanguage(def) {
+  var languageId = def.id;
+  languageDefinitions[languageId] = def;
+  languages.register(def);
+  var lazyLanguageLoader = LazyLanguageLoader.getOrCreate(languageId);
+  languages.setMonarchTokensProvider(languageId, lazyLanguageLoader.whenLoaded().then(function (mod) {
+    return mod.language;
+  }));
+  languages.onLanguage(languageId, function () {
+    lazyLanguageLoader.load().then(function (mod) {
+      languages.setLanguageConfiguration(languageId, mod.conf);
+    });
+  });
+  lazyLanguageLoader.whenLoaded().then(function (mod) {
+    if (mod.provideSuggestionsFunction) {
+      languages.registerCompletionItemProvider(languageId, {
+        triggerCharacters: ['`', ':', '/', '', ' '],
+        provideCompletionItems: mod.provideSuggestionsFunction
+      });
+    }
+    if (mod.provideInlineSuggestionsFunction) {
+      languages.registerInlineCompletionsProvider(languageId, {
+        provideInlineCompletions: mod.provideInlineSuggestionsFunction,
+        disposeInlineCompletions: function disposeInlineCompletions() {}
+      });
+    }
+  });
+}
+export var LanguageServiceDefaultsImpl = /*#__PURE__*/function () {
+  function LanguageServiceDefaultsImpl(languageId, diagnosticsOptions, modeConfiguration) {
+    _classCallCheck(this, LanguageServiceDefaultsImpl);
+    this._onDidChange = new Emitter();
+    this._diagnosticsOptions = void 0;
+    this._modeConfiguration = void 0;
+    this._languageId = void 0;
+    this._languageId = languageId;
+    this.setDiagnosticsOptions(diagnosticsOptions);
+    this.setModeConfiguration(modeConfiguration);
+  }
+  return _createClass(LanguageServiceDefaultsImpl, [{
+    key: "onDidChange",
+    get: function get() {
+      return this._onDidChange.event;
+    }
+  }, {
+    key: "languageId",
+    get: function get() {
+      return this._languageId;
+    }
+  }, {
+    key: "modeConfiguration",
+    get: function get() {
+      return this._modeConfiguration;
+    }
+  }, {
+    key: "diagnosticsOptions",
+    get: function get() {
+      return this._diagnosticsOptions;
+    }
+  }, {
+    key: "setDiagnosticsOptions",
+    value: function setDiagnosticsOptions(options) {
+      this._diagnosticsOptions = options || Object.create(null);
+      this._onDidChange.fire(this);
+    }
+  }, {
+    key: "setModeConfiguration",
+    value: function setModeConfiguration(modeConfiguration) {
+      this._modeConfiguration = modeConfiguration || Object.create(null);
+      this._onDidChange.fire(this);
+    }
+  }]);
+}();
+export var modeConfigurationDefault = {
+  completionItems: true,
+  hovers: true,
+  documentSymbols: true,
+  definitions: true,
+  references: true,
+  documentHighlights: true,
+  rename: true,
+  colors: true,
+  foldingRanges: true,
+  diagnostics: true,
+  selectionRanges: true
+};
+export var diagnosticDefault = {
+  validate: true
+};
+// #sourceMappingURL=_.contribution.js.map

package/build/esm/components/MonacoEditor/monaco-yql-languages/_.contribution.js.map

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

package/build/esm/components/MonacoEditor/monaco-yql-languages/clickhouse/clickhouse.contribution.d.ts

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

package/build/esm/components/MonacoEditor/monaco-yql-languages/clickhouse/clickhouse.contribution.js

@@ -0,0 +1,36 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import { registerLanguage } from "../_.contribution";
+import { MonacoLanguage } from "../constants";
+registerLanguage({
+  id: MonacoLanguage.CHYT,
+  extensions: [],
+  loader: function () {
+    var _loader = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var lang;
+      return _regeneratorRuntime().wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 1;
+            return import("./clickhouse");
+          case 1:
+            lang = _context.sent;
+            return _context.abrupt("return", {
+              conf: lang.conf,
+              language: lang.language
+            });
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function loader() {
+      return _loader.apply(this, arguments);
+    }
+    return loader;
+  }()
+});
+// #sourceMappingURL=clickhouse.contribution.js.map

package/build/esm/components/MonacoEditor/monaco-yql-languages/clickhouse/clickhouse.contribution.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["registerLanguage","MonacoLanguage","id","CHYT","extensions","loader","_loader","_asyncToGenerator","_regeneratorRuntime","mark","_callee","lang","wrap","_context","prev","next","sent","abrupt","conf","language","stop","apply","arguments"],"sources":["clickhouse.contribution.ts"],"sourcesContent":["import {registerLanguage} from '../_.contribution';\nimport {MonacoLanguage} from '../constants';\n\nregisterLanguage({\n    id: MonacoLanguage.CHYT,\n    extensions: [],\n    loader: async () => {\n        const lang = await import('./clickhouse');\n        return {\n            conf: lang.conf,\n            language: lang.language,\n        };\n    },\n});\n"],"mappings":";;;;AAAA,SAAQA,gBAAgB;AACxB,SAAQC,cAAc;AAEtBD,gBAAgB,CAAC;EACbE,EAAE,EAAED,cAAc,CAACE,IAAI;EACvBC,UAAU,EAAE,EAAE;EACdC,MAAM;IAAA,IAAAC,OAAA,GAAAC,iBAAA,cAAAC,mBAAA,GAAAC,IAAA,CAAE,SAAAC,QAAA;MAAA,IAAAC,IAAA;MAAA,OAAAH,mBAAA,GAAAI,IAAA,WAAAC,QAAA;QAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;UAAA;YAAAF,QAAA,CAAAE,IAAA;YAAA,OACe,MAAM,eAAe,CAAC;UAAA;YAAnCJ,IAAI,GAAAE,QAAA,CAAAG,IAAA;YAAA,OAAAH,QAAA,CAAAI,MAAA,WACH;cACHC,IAAI,EAAEP,IAAI,CAACO,IAAI;cACfC,QAAQ,EAAER,IAAI,CAACQ;YACnB,CAAC;UAAA;UAAA;YAAA,OAAAN,QAAA,CAAAO,IAAA;QAAA;MAAA,GAAAV,OAAA;IAAA,CACJ;IAAA,SANDL,MAAMA,CAAA;MAAA,OAAAC,OAAA,CAAAe,KAAA,OAAAC,SAAA;IAAA;IAAA,OAANjB,MAAM;EAAA;AAOV,CAAC,CAAC","ignoreList":[]}

package/build/esm/components/MonacoEditor/monaco-yql-languages/clickhouse/clickhouse.d.ts

@@ -0,0 +1,3 @@
+import { type languages } from '../fillers/monaco-editor-core';
+export declare const conf: languages.LanguageConfiguration;
+export declare const language: languages.IMonarchLanguage & Record<string, unknown>;