@antscorp/antsomi-ui 2.0.103 → 2.0.104

package/es/components/organism/SQLGeneration/constants.d.ts

@@ -0,0 +1,48 @@
+export declare const SQL_GENERATION_CONSTANTS: {
+    readonly POPOVER_WIDTH: 600;
+    readonly POPOVER_MAX_WIDTH: 800;
+    readonly TEXTAREA_MIN_ROWS: 3;
+    readonly TEXTAREA_MAX_ROWS: 6;
+    readonly MODAL_WIDTH: 800;
+    readonly PLACEHOLDER_TEXTS: {
+        readonly PROMPT: "Enter a prompt to generate a query";
+        readonly SEARCH_TABLES: "Search for tables...";
+        readonly REFINE_PROMPT: "Refine";
+        readonly NO_RESULT: "No SQL generated yet";
+    };
+    readonly LOADING_TEXTS: {
+        readonly GENERATING: "Generating SQL...";
+    };
+    readonly RESULT_TEXTS: {
+        readonly PROCESSED_DATA: "This query will process {size} when run.";
+    };
+    readonly BUTTON_TEXTS: {
+        readonly GENERATE: "Generate";
+        readonly EDIT: "Edit";
+        readonly INSERT: "Insert";
+        readonly EDIT_TABLE_SOURCES: "Edit Table Sources";
+        readonly QUERY_SUMMARY: "Query Summary";
+        readonly APPLY: "Apply";
+        readonly CLOSE: "Close";
+        readonly CANCEL: "Cancel";
+    };
+    readonly TITLES: {
+        readonly MAIN: "Generate SQL with AI";
+        readonly EDIT_TABLE_SOURCES: "Edit table sources";
+        readonly TABLE_ASSET: "Table asset";
+        readonly RATING: {
+            readonly THUMBS_UP: "This is helpful";
+            readonly THUMBS_DOWN: "This is not helpful";
+            readonly MORE_FEEDBACK: "More feedback";
+        };
+    };
+    readonly MESSAGES: {
+        readonly LOADING: "Generating SQL...";
+        readonly NO_RESULT: "No SQL generated yet";
+        readonly PROCESSING_INFO: "This query will process {size} when run.";
+        readonly TABLE_SOURCES_INFO: "Metadata associated with the selected tables will be used to refine your suggestion.";
+    };
+};
+export declare const DEFAULT_RESULT_SETTINGS: {
+    showDiff: boolean;
+};

package/es/components/organism/SQLGeneration/constants.js

@@ -0,0 +1,48 @@
+export const SQL_GENERATION_CONSTANTS = {
+    POPOVER_WIDTH: 600,
+    POPOVER_MAX_WIDTH: 800,
+    TEXTAREA_MIN_ROWS: 3,
+    TEXTAREA_MAX_ROWS: 6,
+    MODAL_WIDTH: 800,
+    PLACEHOLDER_TEXTS: {
+        PROMPT: 'Enter a prompt to generate a query',
+        SEARCH_TABLES: 'Search for tables...',
+        REFINE_PROMPT: 'Refine',
+        NO_RESULT: 'No SQL generated yet',
+    },
+    LOADING_TEXTS: {
+        GENERATING: 'Generating SQL...',
+    },
+    RESULT_TEXTS: {
+        PROCESSED_DATA: 'This query will process {size} when run.',
+    },
+    BUTTON_TEXTS: {
+        GENERATE: 'Generate',
+        EDIT: 'Edit',
+        INSERT: 'Insert',
+        EDIT_TABLE_SOURCES: 'Edit Table Sources',
+        QUERY_SUMMARY: 'Query Summary',
+        APPLY: 'Apply',
+        CLOSE: 'Close',
+        CANCEL: 'Cancel',
+    },
+    TITLES: {
+        MAIN: 'Generate SQL with AI',
+        EDIT_TABLE_SOURCES: 'Edit table sources',
+        TABLE_ASSET: 'Table asset',
+        RATING: {
+            THUMBS_UP: 'This is helpful',
+            THUMBS_DOWN: 'This is not helpful',
+            MORE_FEEDBACK: 'More feedback',
+        },
+    },
+    MESSAGES: {
+        LOADING: 'Generating SQL...',
+        NO_RESULT: 'No SQL generated yet',
+        PROCESSING_INFO: 'This query will process {size} when run.',
+        TABLE_SOURCES_INFO: 'Metadata associated with the selected tables will be used to refine your suggestion.',
+    },
+};
+export const DEFAULT_RESULT_SETTINGS = {
+    showDiff: false,
+};

package/es/components/organism/SQLGeneration/hooks/index.d.ts

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

package/es/components/organism/SQLGeneration/hooks/index.js

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

package/es/components/organism/SQLGeneration/hooks/useKeyboardNavigation.d.ts

@@ -0,0 +1,14 @@
+export interface KeyboardNavigationOptions {
+    onEscape?: () => void;
+    onEnter?: () => void;
+    onCtrlEnter?: () => void;
+    onArrowUp?: () => void;
+    onArrowDown?: () => void;
+    onArrowLeft?: () => void;
+    onArrowRight?: () => void;
+    disabled?: boolean;
+}
+export declare const useKeyboardNavigation: (options?: KeyboardNavigationOptions) => {
+    handleKeyDown: (event: KeyboardEvent) => void;
+};
+export declare const useSQLGenerationKeyboard: () => void;

package/es/components/organism/SQLGeneration/hooks/useKeyboardNavigation.js

@@ -0,0 +1,123 @@
+import { useEffect, useCallback } from 'react';
+import { useSQLGenerationStore } from '../store/provider';
+import { selectHasResult, selectIsEditingPrompt, selectIsRefining, selectIsLoading, } from '../selectors';
+export const useKeyboardNavigation = (options = {}) => {
+    const { onEscape, onEnter, onCtrlEnter, onArrowUp, onArrowDown, onArrowLeft, onArrowRight, disabled = false, } = options;
+    const handleKeyDown = useCallback((event) => {
+        if (disabled)
+            return;
+        const { key, ctrlKey, metaKey, altKey, shiftKey } = event;
+        const isModifierPressed = ctrlKey || metaKey || altKey || shiftKey;
+        // Prevent handling if user is typing in an input/textarea
+        const target = event.target;
+        const isInputElement = ['INPUT', 'TEXTAREA'].includes(target.tagName) || target.contentEditable === 'true';
+        switch (key) {
+            case 'Escape':
+                if (onEscape) {
+                    event.preventDefault();
+                    onEscape();
+                }
+                break;
+            case 'Enter':
+                if ((ctrlKey || metaKey) && onCtrlEnter) {
+                    event.preventDefault();
+                    onCtrlEnter();
+                }
+                else if (!isModifierPressed && !isInputElement && onEnter) {
+                    event.preventDefault();
+                    onEnter();
+                }
+                break;
+            case 'ArrowUp':
+                if (!isInputElement && onArrowUp) {
+                    event.preventDefault();
+                    onArrowUp();
+                }
+                break;
+            case 'ArrowDown':
+                if (!isInputElement && onArrowDown) {
+                    event.preventDefault();
+                    onArrowDown();
+                }
+                break;
+            case 'ArrowLeft':
+                if (!isInputElement && onArrowLeft) {
+                    event.preventDefault();
+                    onArrowLeft();
+                }
+                break;
+            case 'ArrowRight':
+                if (!isInputElement && onArrowRight) {
+                    event.preventDefault();
+                    onArrowRight();
+                }
+                break;
+            default:
+                break;
+        }
+    }, [disabled, onEscape, onEnter, onCtrlEnter, onArrowUp, onArrowDown, onArrowLeft, onArrowRight]);
+    useEffect(() => {
+        if (disabled)
+            return;
+        document.addEventListener('keydown', handleKeyDown);
+        return () => {
+            document.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [handleKeyDown, disabled]);
+    return { handleKeyDown };
+};
+// Hook for SQL Generation specific keyboard shortcuts
+export const useSQLGenerationKeyboard = () => {
+    const hasResults = useSQLGenerationStore(selectHasResult);
+    const isEditingPrompt = useSQLGenerationStore(selectIsEditingPrompt);
+    const isRefining = useSQLGenerationStore(selectIsRefining);
+    const isLoading = useSQLGenerationStore(selectIsLoading);
+    const setIsOpen = useSQLGenerationStore(s => s.setIsOpen);
+    const setIsEditingPrompt = useSQLGenerationStore(s => s.setIsEditingPrompt);
+    const generateSQL = useSQLGenerationStore(s => s.generateSQL);
+    const refineSQL = useSQLGenerationStore(s => s.refineSQL);
+    const setCurrentResultKey = useSQLGenerationStore(s => s.setCurrentResultKey);
+    const resultAllKeys = useSQLGenerationStore(s => s.results.allKeys);
+    const currentResultKey = useSQLGenerationStore(s => s.currentResultKey);
+    const handleEscape = useCallback(() => {
+        if (isEditingPrompt) {
+            setIsEditingPrompt(false);
+        }
+        else {
+            setIsOpen(false);
+        }
+    }, [isEditingPrompt, setIsEditingPrompt, setIsOpen]);
+    const handleCtrlEnter = useCallback(() => {
+        if (isLoading)
+            return;
+        if (isRefining) {
+            refineSQL();
+        }
+        else if (!hasResults) {
+            generateSQL();
+        }
+    }, [isLoading, isRefining, hasResults, refineSQL, generateSQL]);
+    const handleArrowLeft = useCallback(() => {
+        if (hasResults && resultAllKeys.length > 1) {
+            const currentIndex = resultAllKeys.indexOf(currentResultKey || '');
+            if (currentIndex > 0) {
+                setCurrentResultKey(resultAllKeys[currentIndex - 1]);
+            }
+        }
+    }, [hasResults, resultAllKeys, currentResultKey, setCurrentResultKey]);
+    const handleArrowRight = useCallback(() => {
+        if (hasResults && resultAllKeys.length > 1) {
+            const currentIndex = resultAllKeys.indexOf(currentResultKey || '');
+            if (currentIndex < resultAllKeys.length - 1) {
+                setCurrentResultKey(resultAllKeys[currentIndex + 1]);
+            }
+        }
+    }, [hasResults, resultAllKeys, currentResultKey, setCurrentResultKey]);
+    useKeyboardNavigation({
+        onEscape: handleEscape,
+        onCtrlEnter: handleCtrlEnter,
+        onArrowLeft: handleArrowLeft,
+        onArrowRight: handleArrowRight,
+        disabled: false,
+    });
+};

package/es/components/organism/SQLGeneration/index.d.ts

@@ -0,0 +1,10 @@
+export { SQLGeneration } from './SQLGeneration';
+export type { SQLGenerationProps, SQLGenerationResult, TableSource } from './types';
+export { SQLGenerationProvider, useSQLGenerationStore, type SQLGenerationProviderProps, } from './store';
+export declare const SQLGenerationIntegrations: {
+    readonly useAntsomiSqlWS: (params?: {
+        triggerTitle: string;
+    } | undefined) => {
+        setAceEditor: (editor: import("react-ace/lib/types").IAceEditor) => void;
+    };
+};

package/es/components/organism/SQLGeneration/index.js

@@ -0,0 +1,6 @@
+import { useAntsomiSqlWS } from './integrations/AntsomiSqlWS';
+export { SQLGeneration } from './SQLGeneration';
+export { SQLGenerationProvider, useSQLGenerationStore, } from './store';
+export const SQLGenerationIntegrations = {
+    useAntsomiSqlWS,
+};

package/es/components/organism/SQLGeneration/index.scss

@@ -0,0 +1 @@
+@use './integrations/AceEditor';

package/es/components/organism/SQLGeneration/integrations/AceEditor/index.d.ts

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

package/es/components/organism/SQLGeneration/integrations/AceEditor/index.js

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

package/es/components/organism/SQLGeneration/integrations/AceEditor/index.scss

@@ -0,0 +1,4 @@
+.ace-sqlgen-placeholder {
+  display: inline-block;
+  cursor: pointer;
+}

package/es/components/organism/SQLGeneration/integrations/AceEditor/useAceEditor.d.ts

@@ -0,0 +1,9 @@
+import type { IAceEditor } from 'react-ace/lib/types';
+export type Params = {
+    triggerTitle?: string;
+    maxRetries?: number;
+    baseDelay?: number;
+};
+export declare const useAceEditor: (params?: Params) => {
+    setAceEditor: (editor: IAceEditor) => void;
+};

package/es/components/organism/SQLGeneration/integrations/AceEditor/useAceEditor.js

@@ -0,0 +1,24 @@
+import { useCallback } from 'react';
+import { useEnhancePlaceholder } from './useEnhancePlaceholder';
+import { useInsertQuery } from './useInsertQuery';
+import { useSQLGenerationStore } from '../../store';
+export const useAceEditor = (params) => {
+    const setIsOpen = useSQLGenerationStore(s => s.setIsOpen);
+    const resetStore = useSQLGenerationStore(s => s.reset);
+    const { setAceEditor: setAceEditorForPlaceholder } = useEnhancePlaceholder({
+        triggerTitle: params?.triggerTitle,
+        maxRetries: params?.maxRetries,
+        baseDelay: params?.baseDelay,
+    });
+    const { setAceEditor: setAceEditorForInsertQuery } = useInsertQuery({
+        onInsertQueryDone: () => {
+            setIsOpen(false);
+            resetStore();
+        },
+    });
+    const setAceEditor = useCallback((editor) => {
+        setAceEditorForPlaceholder(editor);
+        setAceEditorForInsertQuery(editor);
+    }, [setAceEditorForPlaceholder, setAceEditorForInsertQuery]);
+    return { setAceEditor };
+};

package/es/components/organism/SQLGeneration/integrations/AceEditor/useEnhancePlaceholder.d.ts

@@ -0,0 +1,10 @@
+import type { IAceEditor } from 'react-ace/lib/types';
+type Params = {
+    triggerTitle?: string;
+    maxRetries?: number;
+    baseDelay?: number;
+};
+export declare const useEnhancePlaceholder: (params?: Params) => {
+    setAceEditor: (editor: IAceEditor) => void;
+};
+export {};

package/es/components/organism/SQLGeneration/integrations/AceEditor/useEnhancePlaceholder.js

@@ -0,0 +1,172 @@
+import { useCallback, useRef, useEffect } from 'react';
+import { useUnmount } from '@antscorp/antsomi-ui/es/hooks';
+import { useSQLGenerationStore } from '../../store';
+export const useEnhancePlaceholder = (params) => {
+    const { triggerTitle = 'generate SQL with AI', maxRetries = 5, baseDelay = 100 } = params || {};
+    const timeoutRef = useRef();
+    const mutationObserverRef = useRef(null);
+    const editorRef = useRef(null);
+    const placeholderRef = useRef(null);
+    const triggerRef = useRef(null);
+    const retryCountRef = useRef(0);
+    const isDestroyedRef = useRef(false);
+    const setModalSqlGenerationOpen = useSQLGenerationStore(state => state.setIsOpen);
+    const syncPlaceholderEl = useCallback((editor) => {
+        if (isDestroyedRef.current)
+            return false;
+        const selectedEl = editor.renderer.container.querySelector('.ace_placeholder');
+        if (selectedEl && selectedEl instanceof HTMLDivElement) {
+            placeholderRef.current = selectedEl;
+            return true;
+        }
+        return false;
+    }, []);
+    const waitForPlaceholder = useCallback((editor, retryCount = 0) => new Promise(resolve => {
+        if (isDestroyedRef.current) {
+            resolve(null);
+            return;
+        }
+        // Try to find placeholder immediately
+        if (syncPlaceholderEl(editor)) {
+            resolve(placeholderRef.current);
+            return;
+        }
+        // If max retries reached, resolve with null
+        if (retryCount >= maxRetries) {
+            // eslint-disable-next-line no-console
+            console.warn(`AceEditor placeholder not found after ${maxRetries} retries`);
+            resolve(null);
+            return;
+        }
+        // Use exponential backoff: baseDelay * 2^retryCount
+        const delay = baseDelay * 2 ** retryCount;
+        timeoutRef.current = setTimeout(() => {
+            if (isDestroyedRef.current) {
+                resolve(null);
+                return;
+            }
+            waitForPlaceholder(editor, retryCount + 1).then(resolve);
+        }, delay);
+    }), [syncPlaceholderEl, maxRetries, baseDelay]);
+    const updatePlaceholderVisibility = useCallback(async (forceWait = false) => {
+        const editor = editorRef.current;
+        if (!editor || isDestroyedRef.current)
+            return;
+        // If placeholder not found and we need to wait for it
+        if (!placeholderRef.current || forceWait) {
+            clearTimeout(timeoutRef.current);
+            const placeholder = await waitForPlaceholder(editor, 0);
+            if (!placeholder || isDestroyedRef.current)
+                return;
+        }
+        if (!placeholderRef.current)
+            return;
+        const content = editor.session.getValue();
+        const isEmpty = content.length === 0;
+        const appendTriggerEl = (placeholderEl) => {
+            // Avoid duplicate triggers
+            if (triggerRef.current && placeholderEl.contains(triggerRef.current)) {
+                return;
+            }
+            let triggerEl;
+            if (triggerRef.current) {
+                triggerEl = triggerRef.current;
+            }
+            else {
+                triggerEl = document.createElement('span');
+                triggerRef.current = triggerEl;
+            }
+            triggerEl.classList.add('ace-sqlgen-placeholder');
+            triggerEl.innerHTML = ` or <u class='trigger-title'>${triggerTitle}</u>`;
+            triggerEl.addEventListener('click', () => {
+                setModalSqlGenerationOpen(true);
+            });
+            placeholderEl.appendChild(triggerEl);
+        };
+        if (isEmpty && placeholderRef.current) {
+            appendTriggerEl(placeholderRef.current);
+        }
+        if (!isEmpty && triggerRef.current) {
+            triggerRef.current.remove();
+            triggerRef.current = null;
+        }
+    }, [setModalSqlGenerationOpen, triggerTitle, waitForPlaceholder]);
+    // Setup MutationObserver to watch for DOM changes
+    const setupMutationObserver = useCallback((editor) => {
+        if (mutationObserverRef.current) {
+            mutationObserverRef.current.disconnect();
+        }
+        mutationObserverRef.current = new MutationObserver(mutations => {
+            if (isDestroyedRef.current)
+                return;
+            let shouldUpdate = false;
+            mutations.forEach(mutation => {
+                // Check if placeholder-related nodes were added/removed
+                if (mutation.type === 'childList') {
+                    const addedNodes = Array.from(mutation.addedNodes);
+                    const removedNodes = Array.from(mutation.removedNodes);
+                    const hasPlaceholderChanges = [...addedNodes, ...removedNodes].some(node => node instanceof Element &&
+                        (node.classList?.contains('ace_placeholder') ||
+                            node.querySelector?.('.ace_placeholder')));
+                    if (hasPlaceholderChanges) {
+                        shouldUpdate = true;
+                    }
+                }
+            });
+            if (shouldUpdate) {
+                // Small delay to ensure DOM is stable
+                setTimeout(() => {
+                    if (!isDestroyedRef.current) {
+                        updatePlaceholderVisibility(true);
+                    }
+                }, 50);
+            }
+        });
+        // Observe the editor container for changes
+        mutationObserverRef.current.observe(editor.renderer.container, {
+            childList: true,
+            subtree: true,
+        });
+    }, [updatePlaceholderVisibility]);
+    const setAceEditorRef = useCallback((editor) => {
+        if (isDestroyedRef.current)
+            return;
+        editorRef.current = editor;
+        retryCountRef.current = 0;
+        // Setup mutation observer to watch for DOM changes
+        setupMutationObserver(editor);
+        // Initial placeholder setup
+        updatePlaceholderVisibility(true);
+        const eventCb = () => {
+            if (!isDestroyedRef.current) {
+                updatePlaceholderVisibility();
+            }
+        };
+        editor.on('change', eventCb);
+        editor.on('blur', eventCb);
+        editor.on('focus', eventCb);
+    }, [updatePlaceholderVisibility, setupMutationObserver]);
+    // Cleanup function
+    const cleanup = useCallback(() => {
+        isDestroyedRef.current = true;
+        clearTimeout(timeoutRef.current);
+        if (mutationObserverRef.current) {
+            mutationObserverRef.current.disconnect();
+            mutationObserverRef.current = null;
+        }
+        if (triggerRef.current) {
+            triggerRef.current.remove();
+            triggerRef.current = null;
+        }
+        placeholderRef.current = null;
+        editorRef.current = null;
+    }, []);
+    useUnmount(cleanup);
+    // Also cleanup on component re-render if needed
+    useEffect(() => () => {
+        if (isDestroyedRef.current) {
+            cleanup();
+        }
+    }, [cleanup]);
+    return { setAceEditor: setAceEditorRef };
+};

package/es/components/organism/SQLGeneration/integrations/AceEditor/useInsertQuery.d.ts

@@ -0,0 +1,8 @@
+import type { IAceEditor } from 'react-ace/lib/types';
+type Params = {
+    onInsertQueryDone?: () => void;
+};
+export declare const useInsertQuery: (params?: Params) => {
+    setAceEditor: (editor: IAceEditor) => void;
+};
+export {};

package/es/components/organism/SQLGeneration/integrations/AceEditor/useInsertQuery.js

@@ -0,0 +1,21 @@
+import { useCallback, useRef } from 'react';
+import { useSQLGenerationStore } from '../../store';
+export const useInsertQuery = (params) => {
+    const { onInsertQueryDone } = params || {};
+    const editorRef = useRef(null);
+    const setState = useSQLGenerationStore(s => s.setState);
+    const setAceEditorRef = useCallback((editor) => {
+        editorRef.current = editor;
+        setState({
+            onInsertSQL: sql => {
+                const content = editor.session.getValue();
+                const isEmpty = content.length === 0;
+                if (isEmpty) {
+                    editor.insert(sql);
+                    onInsertQueryDone?.();
+                }
+            },
+        });
+    }, [setState, onInsertQueryDone]);
+    return { setAceEditor: setAceEditorRef };
+};

package/es/components/organism/SQLGeneration/integrations/AntsomiAI/index.d.ts

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

package/es/components/organism/SQLGeneration/integrations/AntsomiAI/index.js

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

package/es/components/organism/SQLGeneration/integrations/AntsomiAI/useAntsomiAI.d.ts

@@ -0,0 +1 @@
+export declare const useAntsomiAI: () => void;

package/es/components/organism/SQLGeneration/integrations/AntsomiAI/useAntsomiAI.js

@@ -0,0 +1,35 @@
+import { useAppConfigContext } from '@antscorp/antsomi-ui/es/providers';
+import { useSQLGenerationStore } from '../../store';
+import { AntsomiAIQueries } from '@antscorp/antsomi-ui/es/queries/AI';
+import { useEffect } from 'react';
+export const useAntsomiAI = () => {
+    const setState = useSQLGenerationStore(s => s.setState);
+    const { appConfig } = useAppConfigContext();
+    const { generateSQLAsync } = AntsomiAIQueries.useSqlGeneration({
+        env: appConfig.env || 'production',
+        auth: {
+            token: appConfig.auth?.token || '',
+            userId: +(appConfig.auth?.userId || 0),
+            accountId: +(appConfig.auth?.accountId || 0),
+            portalId: +(appConfig.auth?.portalId || 0),
+        },
+    });
+    useEffect(() => {
+        setState({
+            onGenerateSQL: async (prompt, context) => {
+                const data = await generateSQLAsync({
+                    prompt,
+                    selected_tables: context.selectedTables,
+                    history: {
+                        pass_turns: context.history.pastTurns,
+                    },
+                });
+                const generationResult = {
+                    ...data,
+                    sqlSuggestion: data.sql_suggestion,
+                };
+                return generationResult;
+            },
+        });
+    }, [generateSQLAsync, setState]);
+};

package/es/components/organism/SQLGeneration/integrations/AntsomiSqlWS/index.d.ts

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

package/es/components/organism/SQLGeneration/integrations/AntsomiSqlWS/index.js

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

package/es/components/organism/SQLGeneration/integrations/AntsomiSqlWS/useAntsomiSqlWS.d.ts

@@ -0,0 +1,7 @@
+type Params = {
+    triggerTitle: string;
+};
+export declare const useAntsomiSqlWS: (params?: Params) => {
+    setAceEditor: (editor: import("react-ace/lib/types").IAceEditor) => void;
+};
+export {};

package/es/components/organism/SQLGeneration/integrations/AntsomiSqlWS/useAntsomiSqlWS.js

@@ -0,0 +1,10 @@
+import { useAceEditor } from '../AceEditor/useAceEditor';
+import { useAntsomiAI } from '../AntsomiAI';
+export const useAntsomiSqlWS = (params) => {
+    const { triggerTitle } = params || {};
+    const { setAceEditor } = useAceEditor({
+        triggerTitle,
+    });
+    useAntsomiAI();
+    return { setAceEditor };
+};