@quillsql/admin 1.6.0 → 1.6.2

package/dist/esm/forms/virtual_tables/CreateEditVirtualTable.js

@@ -0,0 +1,288 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Table, SchemaListComponent, } from '@quillsql/react';
+import { useEffect, useMemo, useState } from 'react';
+import { useAdmin } from '../../AdminProvider';
+import { getQueryFromAiWithConnection, getVirtualTableData, } from '../../api/ConnectionClient';
+import SqlTextEditor from '../../components/SqlTextEditor';
+import { LoadingSpinner, MemoizedButton, MemoizedSecondaryButton, MemoizedTextInput, OverflowContainer, QuillToolTip, } from '../../components/UiComponents';
+import { TenantFieldModal } from '../client_onboard/CreateVirtualTables';
+import DynamicBanner from '../../components/DynamicBanner';
+import { getDuplicateColumns } from '../../public_components/VirtualTableManager';
+import { processColumnReference } from '../../utils/columnProcessing';
+import { processJoinASTWithDuplicateColumns } from '../../utils/astProcessing';
+import { SINGLE_TENANT } from '../../utils/constants';
+import { onlySingleDatabaseTenant } from '../../utils/tenants';
+import { QuillMultiSelectComponentWithCombo } from '../../components/QuillMultiSelectWithCombo';
+export default function CreateEditVirtualTable({ containerStyle, initialVirtualTable, closeEditVirtualTable: closeEditVirtualTable, addEditVirtualTable: addEditVirtualTable, LoadingComponent = () => _jsx(LoadingSpinner, {}), ButtonComponent = MemoizedButton, SecondaryButtonComponent = MemoizedSecondaryButton, TextInput = MemoizedTextInput, allTableData, schemaIsLoading, client, }) {
+    const name = initialVirtualTable?.name || '';
+    const [editVirtualTableQuery, setEditVirtualTableQuery] = useState(initialVirtualTable?.viewQuery || '');
+    const [ranVirtualTableQuery, setRanVirtualTableQuery] = useState(initialVirtualTable?.viewQuery || '');
+    const [askAIButtonLoading, setAskAIButtonLoading] = useState(false);
+    const [aiPrompt, setAIPrompt] = useState('');
+    const [virtualTableAddable, setVirtualTableAddable] = useState(false);
+    const [virtualTableOwners, setVirtualTableOwners] = useState(initialVirtualTable?.ownerTenantFields ??
+        client.ownerTenantFields?.filter((f) => f !== SINGLE_TENANT) ??
+        []);
+    const [failingTenant, setFailingTenant] = useState(undefined);
+    const [isLoading, setIsLoading] = useState(false);
+    const [tableSearchQuery, setTableSearchQuery] = useState('');
+    const [editorMounted, setEditorMounted] = useState(false);
+    const [displayedTableData, setDisplayedTableData] = useState(allTableData);
+    const [errorInfo, setErrorInfo] = useState({ show: false, message: '' });
+    const [tableData, setTableData] = useState(undefined);
+    const [runningQuery, setRunningQuery] = useState(false);
+    const { state, getToken, quillFetchWithToken } = useAdmin();
+    const addEditProcessVirtualTable = async (override = false) => {
+        const failingTenant = virtualTableOwners?.find((field) => tableData &&
+            !tableData.fields.find((col) => col.name === field?.replaceAll('"', '')));
+        if (!override && tableData && failingTenant) {
+            const tenant = client.allTenantTypes?.find((t) => t.tenantField === failingTenant);
+            setFailingTenant(tenant);
+            return;
+        }
+        addEditVirtualTable(initialVirtualTable ? 'edit' : 'add', ranVirtualTableQuery, virtualTableOwners, name, initialVirtualTable ? initialVirtualTable._id : undefined, tableData?.fields || [], override);
+    };
+    const dashboardOwnerTenants = useMemo(() => {
+        return client.allTenantTypes
+            ?.filter((t) => client.ownerTenantFields?.includes(t.tenantField))
+            .filter((t) => t.tenantField !== SINGLE_TENANT);
+    }, [client.ownerTenantFields, client.allTenantTypes]);
+    useEffect(() => {
+        setDisplayedTableData(allTableData);
+    }, [allTableData]);
+    // Run query on mount
+    useEffect(() => {
+        if (initialVirtualTable) {
+            handleRunQuery(initialVirtualTable.viewQuery);
+        }
+    }, []);
+    const handleRunSqlPrompt = async () => {
+        setErrorInfo({ show: false, message: '' });
+        setVirtualTableAddable(false);
+        setAskAIButtonLoading(true);
+        const results = await getQueryFromAiWithConnection(state.queryEndpoint, aiPrompt, state.client._id, getToken, state.client.schemaNames);
+        setEditVirtualTableQuery(results);
+        setAskAIButtonLoading(false);
+    };
+    const handleClickSchemaItem = async (event) => {
+        const name = event.target.textContent;
+        if (!name) {
+            return;
+        }
+        const newQuery = `SELECT * FROM ${processColumnReference(name, state.client.databaseType)};`;
+        if (!editVirtualTableQuery || editVirtualTableQuery.length === 0) {
+            setEditVirtualTableQuery(newQuery);
+        }
+        await navigator.clipboard.writeText(newQuery);
+    };
+    const handleRunQuery = async (overrideQuery, runOnce = false) => {
+        setRunningQuery(true);
+        const query = overrideQuery ? overrideQuery : editVirtualTableQuery;
+        // If this query has a limit at the end alert the user
+        if (/limit\s+\d+\s*;?\s*$/i.test(query)) {
+            setErrorInfo({
+                show: true,
+                message: 'Error: Please remove the limit at the end of your query.',
+            });
+            //TODO: Errors should have further justification/explanation in a -?- tooltip
+            return;
+        }
+        if (state.client.databaseType.toLowerCase() === 'mssql' &&
+            /\border\s+by\b/i.test(query.trim()) &&
+            !/top\s+\d+/i.test(query.trim())) {
+            setErrorInfo({
+                show: true,
+                message: 'Error: Queries with ORDER BY must include TOP.',
+            });
+            return;
+        }
+        setVirtualTableAddable(false);
+        setErrorInfo({ show: false, message: '' });
+        setTableData(undefined);
+        if (query.length === 0) {
+            setErrorInfo({ show: true, message: 'Error: Please enter a query.' });
+            setRunningQuery(false);
+            return;
+        }
+        setIsLoading(true);
+        const resp = await getVirtualTableData(state.client._id, query, state.client.databaseType, state.queryEndpoint, getToken);
+        if (!resp.success) {
+            setErrorInfo({ show: true, message: resp.error });
+            setTableData(undefined);
+            setVirtualTableAddable(false);
+            setIsLoading(false);
+            setRunningQuery(false);
+            return;
+        }
+        setErrorInfo({ show: false, message: '' });
+        // stringify all rows that are either jsonb or json
+        resp.rows = resp.rows.map((row) => {
+            for (const key in row) {
+                if (row[key] !== null && typeof row[key] === 'object') {
+                    row[key] = JSON.stringify(row[key]);
+                }
+            }
+            return row;
+        });
+        const duplicateColumns = getDuplicateColumns(resp.fields);
+        if (duplicateColumns.length > 0 && !runOnce) {
+            let parsedAST = resp.ast;
+            if (Array.isArray(resp.ast)) {
+                parsedAST = resp.ast[0];
+            }
+            const tableInfo = parsedAST.from.map((table) => {
+                const db = table.db ? `${table.db}.` : '';
+                return {
+                    tableName: `${db}${table.table}`,
+                    alias: table.as || `${db}${table.table}`,
+                };
+            });
+            const newAst = processJoinASTWithDuplicateColumns(duplicateColumns, tableInfo, allTableData, parsedAST);
+            const { data: jsonResponse } = await quillFetchWithToken({
+                client: {
+                    queryEndpoint: state.queryEndpoint,
+                    queryHeaders: state.queryHeaders,
+                    clientId: state.client._id,
+                    withCredentials: false,
+                },
+                task: 'sqlify',
+                metadata: {
+                    clientId: state.client._id,
+                    ast: { ...newAst },
+                    useNewNodeSql: true,
+                },
+                adminMode: true,
+            });
+            if (!jsonResponse) {
+                setErrorInfo({ show: true, message: 'Error parsing query' });
+                setRunningQuery(false);
+                return;
+            }
+            setEditVirtualTableQuery(jsonResponse.query);
+            await handleRunQuery(jsonResponse.query, true);
+            setRunningQuery(false);
+            return;
+        }
+        setTableData({ fields: resp.fields, rows: resp.rows });
+        setVirtualTableAddable(true);
+        setRanVirtualTableQuery(query);
+        setIsLoading(false);
+        setRunningQuery(false);
+    };
+    return (_jsx("div", { style: {
+            ...containerStyle,
+            gap: 6,
+            height: 'calc(100vh - 130px)',
+        }, children: _jsxs("div", { style: { display: 'flex', height: '100%', flexDirection: 'column' }, children: [_jsx(DynamicBanner, { header: initialVirtualTable
+                        ? `Edit "${initialVirtualTable.name}" Virtual Table`
+                        : 'Create Virtual Table', onExit: initialVirtualTable ? undefined : closeEditVirtualTable }), _jsxs("div", { style: {
+                        width: '100%',
+                        display: 'flex',
+                        height: '100%',
+                        flexDirection: 'row',
+                        paddingTop: '20px',
+                    }, children: [_jsxs("div", { style: {
+                                display: 'flex',
+                                flexDirection: 'column',
+                                gap: 20,
+                                width: '30%',
+                                minWidth: '250px',
+                                maxWidth: '350px',
+                            }, children: [_jsx("div", { style: {
+                                        paddingLeft: '20px',
+                                        paddingRight: '30px',
+                                    }, children: _jsx(TextInput, { placeholder: "Filter tables...", onChange: (e) => {
+                                            setTableSearchQuery(e.target.value);
+                                            setDisplayedTableData(allTableData.filter((table) => {
+                                                return (table.tableName
+                                                    ?.toLowerCase()
+                                                    ?.includes(e.target.value.toLowerCase().trim()) ||
+                                                    table.columns.some((col) => col.field
+                                                        ?.toLowerCase()
+                                                        ?.includes(e.target.value.toLowerCase().trim())));
+                                            }));
+                                        }, value: tableSearchQuery, id: 'edit-name', width: '100%' }) }), _jsx(SchemaListComponent, { schema: displayedTableData, theme: state.theme, LoadingComponent: LoadingComponent, loading: schemaIsLoading, width: '100%', onClick: handleClickSchemaItem })] }), _jsxs("div", { style: {
+                                display: 'flex',
+                                gap: 20,
+                                flexDirection: 'column',
+                                width: 'calc(100% - 250px)',
+                                maxHeight: '100%',
+                                overflowX: 'hidden',
+                                paddingRight: '24px',
+                            }, children: [_jsx(OverflowContainer, { children: _jsxs("div", { style: {
+                                            overflow: 'auto',
+                                            gap: 20,
+                                            display: 'flex',
+                                            flexDirection: 'column',
+                                            // height: '100%',
+                                        }, children: [_jsxs("div", { style: {
+                                                    display: 'flex',
+                                                    flexDirection: 'row',
+                                                    alignItems: 'flex-start',
+                                                    justifyContent: 'space-between',
+                                                    gap: 20,
+                                                    width: '100%',
+                                                }, children: [_jsx(TextInput, { onChange: (e) => {
+                                                            setAIPrompt(e.target.value);
+                                                        }, placeholder: 'Describe a query...', value: aiPrompt, id: 'ai-prompt', width: '100%' }), _jsx(QuillToolTip, { text: aiPrompt.trim().length > 500
+                                                            ? 'Prompt must be less than 500 characters'
+                                                            : '', enabled: aiPrompt.trim().length > 500, textStyle: {
+                                                            maxWidth: '77px',
+                                                            whiteSpace: 'normal',
+                                                        }, displayBelow: true, children: _jsx(ButtonComponent, { label: 'Ask AI', isLoading: askAIButtonLoading, onClick: handleRunSqlPrompt, disabled: aiPrompt.trim().length > 500 }) })] }), !schemaIsLoading && (_jsx(SqlTextEditor, { value: editVirtualTableQuery, setValue: (e) => {
+                                                    setEditVirtualTableQuery(e);
+                                                }, setEditorMounted: (didMount) => {
+                                                    setEditorMounted(didMount);
+                                                }, schema: displayedTableData, databaseType: state.client.databaseType })), editorMounted && (_jsxs("div", { style: {
+                                                    width: '100%',
+                                                    display: 'flex',
+                                                    flexDirection: 'row',
+                                                    justifyContent: 'space-between',
+                                                }, children: [_jsx(ButtonComponent, { label: 'Run query', onClick: () => {
+                                                            handleRunQuery();
+                                                        } }), !!dashboardOwnerTenants?.length && (_jsx(QuillMultiSelectComponentWithCombo, { label: 'Owner Tenants', width: 230, value: virtualTableOwners, options: dashboardOwnerTenants?.map((f) => {
+                                                            return { value: f.tenantField, label: f.name };
+                                                        }) ?? [], onChange: (e) => setVirtualTableOwners(e.target.value), allSelectedLabel: _jsx("div", { children: "All tenants" }), noneSelectedLabel: _jsx("div", { children: "No owners" }) }))] })), errorInfo.show ? (_jsx("div", { style: {
+                                                    fontSize: 15,
+                                                    fontWeight: '400',
+                                                    width: '100%',
+                                                }, children: _jsx("div", { style: {
+                                                        padding: 30,
+                                                        background: 'rgba(0,0,0,0.02)',
+                                                        display: 'inline-block',
+                                                        flex: 0,
+                                                        borderRadius: 6,
+                                                        width: '100%',
+                                                    }, children: errorInfo.message }) })) : null, (tableData || runningQuery) && (_jsx(Table, { containerStyle: {
+                                                    minHeight: 260,
+                                                    height: 75 +
+                                                        Math.min(Math.max(10, tableData?.rows.length ?? 10), 10) *
+                                                            37,
+                                                }, rows: tableData?.rows || [], columns: tableData?.fields || [], isLoading: isLoading }))] }) }), virtualTableAddable ? (_jsxs("div", { style: {
+                                        marginLeft: 'auto',
+                                        display: 'flex',
+                                        flexDirection: 'row',
+                                        gap: 12,
+                                        marginTop: 'auto',
+                                    }, children: [_jsx(SecondaryButtonComponent, { onClick: closeEditVirtualTable, label: 'Discard changes' }), _jsx(ButtonComponent, { label: `${initialVirtualTable ? 'Save changes' : 'Create virtual table'}`, onClick: () => {
+                                                const duplicateColumns = getDuplicateColumns(tableData?.fields);
+                                                if (duplicateColumns.length > 0) {
+                                                    alert(`Ambiguous column names found. Either use aliases or remove the column to make every column name unique: \n\n${duplicateColumns.join('\n')}`);
+                                                    return;
+                                                }
+                                                // If any owner tenants have been removed, confirm with the user
+                                                const removedTenant = initialVirtualTable?.ownerTenantFields?.find((field) => !virtualTableOwners.includes(field));
+                                                if (removedTenant) {
+                                                    alert('You may not remove owners from virtual tables at this time');
+                                                    return;
+                                                }
+                                                addEditProcessVirtualTable(onlySingleDatabaseTenant(client));
+                                            }, tooltipText: initialVirtualTable?.viewQuery === ranVirtualTableQuery
+                                                ? 'No changes made'
+                                                : undefined })] })) : isLoading || !initialVirtualTable ? null : (_jsx("div", { style: {
+                                        marginLeft: 'auto',
+                                        display: 'flex',
+                                        flexDirection: 'row',
+                                        gap: 12,
+                                    }, children: _jsx(SecondaryButtonComponent, { onClick: closeEditVirtualTable, label: 'Discard changes' }) }))] })] }), _jsx(TenantFieldModal, { isOpen: !!failingTenant, setClosed: () => setFailingTenant(undefined), tenant: failingTenant })] }) }));
+}

package/dist/esm/hooks/useDashboardManager.d.ts

@@ -0,0 +1,16 @@
+export declare const useDashboardManager: () => {
+    setSelectedDashboard: (name: string | null, reportId?: string) => void;
+    selectedDashboard: {
+        name: string;
+        id: string;
+        reports: import("@quillsql/react").QuillReport[];
+        tenantKeys: string[] | undefined;
+        createdAt: Date;
+        sectionOrder: {
+            _id: string;
+            section: string;
+            reportOrder: string[];
+        }[] | undefined;
+    } | undefined;
+};
+//# sourceMappingURL=useDashboardManager.d.ts.map

package/dist/esm/hooks/useDashboardManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDashboardManager.d.ts","sourceRoot":"","sources":["../../../src/hooks/useDashboardManager.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,mBAAmB;iCAQM,MAAM,GAAG,IAAI,aAAa,MAAM;;;;;;;;;;;;;CAuGrE,CAAC"}

package/dist/esm/hooks/useDashboardManager.js

@@ -0,0 +1,109 @@
+import { useDashboards } from '@quillsql/react';
+import { useAdmin } from '../AdminProvider';
+import { useMemo } from 'react';
+import { SAVED_QUERIES_DASHBOARD } from '../utils/constants';
+export const useDashboardManager = () => {
+    const { dashboards } = useDashboards();
+    const { state, dispatch } = useAdmin();
+    const selectedDashboard = useMemo(() => dashboards?.find((d) => d.name === state.selectedDashboard), [dashboards, state.selectedDashboard]);
+    const setSelectedDashboard = (name, reportId) => {
+        if (!name || name === SAVED_QUERIES_DASHBOARD) {
+            dispatch({
+                type: 'SET_SELECTED_DASHBOARD_NAME',
+                payload: {
+                    dashboard: null,
+                    reportId: null,
+                },
+            });
+            return;
+        }
+        dispatch({
+            type: 'SET_SELECTED_DASHBOARD_NAME',
+            payload: {
+                dashboard: name,
+                reportId,
+            },
+        });
+        const dashboard = dashboards?.find((d) => d.name === name);
+        if (!dashboard) {
+            return;
+        }
+        // if (asSingleDatabaseTenant(state.client)) {
+        //   clearSingleTenantState();
+        //   return;
+        // }
+        if (!dashboard?.tenantKeys) {
+            clearTenantState();
+        }
+        else if (dashboard.tenantKeys[0] !== state.selectedTenantField) {
+            const tenant = state.client.allTenantTypes?.find((t) => t.tenantField === dashboard.tenantKeys[0]);
+            if (!tenant) {
+                clearTenantState();
+                return;
+            }
+            else {
+                dispatch({
+                    type: 'SET_SELECTED_TENANT_FOREIGN_KEY',
+                    payload: tenant.tenantField,
+                });
+                dispatch({
+                    type: 'SET_SELECTED_TENANT_VALUES',
+                    payload: tenant.defaultId ? [tenant.defaultId] : [],
+                });
+                dispatch({
+                    type: 'SET_SELECTED_DASHBOARD_TENANT_IDS',
+                    payload: undefined,
+                });
+                dispatch({
+                    type: 'SET_MAPPABLE_DASHBOARD_TENANT_IDS',
+                    payload: undefined,
+                });
+                dispatch({
+                    type: 'SET_CURRENT_TENANT_IDENTITY',
+                    payload: [
+                        {
+                            tenantField: tenant.tenantField,
+                            tenantIds: tenant.defaultId ? [tenant.defaultId] : [],
+                        },
+                    ],
+                });
+            }
+        }
+    };
+    // const clearSingleTenantState = () => {
+    //   dispatch({
+    //     type: 'SET_CURRENT_TENANT_IDENTITY',
+    //     payload: undefined,
+    //   });
+    //   dispatch({
+    //     type: 'SET_SELECTED_TENANT_VALUES',
+    //     payload: undefined,
+    //   });
+    //   dispatch({
+    //     type: 'SET_SELECTED_DASHBOARD_TENANT_IDS',
+    //     payload: undefined,
+    //   });
+    // }
+    const clearTenantState = () => {
+        dispatch({
+            type: 'SET_CURRENT_TENANT_IDENTITY',
+            payload: undefined,
+        });
+        dispatch({
+            type: 'SET_SELECTED_TENANT_VALUES',
+            payload: undefined,
+        });
+        dispatch({
+            type: 'SET_SELECTED_TENANT_FOREIGN_KEY',
+            payload: undefined,
+        });
+        dispatch({
+            type: 'SET_SELECTED_DASHBOARD_TENANT_IDS',
+            payload: undefined,
+        });
+    };
+    return {
+        setSelectedDashboard,
+        selectedDashboard,
+    };
+};

package/dist/esm/hooks/useDatabaseSchema.d.ts

@@ -0,0 +1,5 @@
+export declare const useDatabaseSchema: () => {
+    schema: import("../utils/table").ColumnsByTable[] | null | undefined;
+    isLoading: boolean;
+};
+//# sourceMappingURL=useDatabaseSchema.d.ts.map

package/dist/esm/hooks/useDatabaseSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDatabaseSchema.d.ts","sourceRoot":"","sources":["../../../src/hooks/useDatabaseSchema.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB;;;CAuD7B,CAAC"}

package/dist/esm/hooks/useDatabaseSchema.js

@@ -0,0 +1,50 @@
+import { useAdmin } from '../AdminProvider';
+import { useEffect, useState } from 'react';
+import { getTableColumnsBySchema } from '../api/ConnectionClient';
+export const useDatabaseSchema = () => {
+    const { state, dispatch, getToken } = useAdmin();
+    const [isLoading, setIsLoading] = useState(state.databaseSchema?.id !== state.client.id);
+    useEffect(() => {
+        const fetchSchema = async () => {
+            if ((state.databaseSchema?.schema?.length ||
+                state.databaseSchema?.loading) &&
+                state.databaseSchema?.id === state.client.id)
+                return;
+            try {
+                dispatch({
+                    type: 'SET_DATABASE_SCHEMA',
+                    payload: {
+                        schema: state.databaseSchema?.schema ?? [],
+                        id: state.client.id,
+                        loading: true,
+                    },
+                });
+                setIsLoading(true);
+                const schema = await getTableColumnsBySchema(state.queryEndpoint, state.client.id, getToken);
+                dispatch({
+                    type: 'SET_DATABASE_SCHEMA',
+                    payload: {
+                        schema: schema.columnsByTable,
+                        id: state.client.id,
+                        loading: false,
+                    },
+                });
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        if (state.client.id) {
+            fetchSchema();
+        }
+    }, [state.client.id]);
+    return {
+        schema: isLoading || state.databaseSchema?.loading
+            ? null
+            : state.databaseSchema?.schema,
+        isLoading: isLoading || !!state.databaseSchema?.loading,
+    };
+};

package/dist/esm/hooks/useItemBeingEdited.d.ts

@@ -1,4 +1,3 @@
-import { PropsWithChildren } from 'react';
 export declare const useItemBeingEdited: () => void;
-export declare const ItemBeingEditedProvider: (props: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export declare const ItemBeingEditedProvider: () => import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=useItemBeingEdited.d.ts.map

package/dist/esm/hooks/useItemBeingEdited.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useItemBeingEdited.d.ts","sourceRoot":"","sources":["../../../src/hooks/useItemBeingEdited.tsx"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EAIlB,MAAM,OAAO,CAAC;AAsCf,eAAO,MAAM,kBAAkB,YAI9B,CAAC;AAEF,eAAO,MAAM,uBAAuB,UAAW,iBAAiB,4CAM/D,CAAC"}
+{"version":3,"file":"useItemBeingEdited.d.ts","sourceRoot":"","sources":["../../../src/hooks/useItemBeingEdited.tsx"],"names":[],"mappings":"AAeA,eAAO,MAAM,kBAAkB,YAE9B,CAAC;AAEF,eAAO,MAAM,uBAAuB,+CAMnC,CAAC"}

package/dist/esm/hooks/useItemBeingEdited.js

@@ -1,25 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 // @ts-nocheck
-import { createContext, useContext, useReducer, } from 'react';
+import { createContext, useContext } from 'react';
 /**
  * The actual context that this hook will monitor.
  */
 const ItemBeingEditedContext = createContext(null);
-const reducer = (_, action) => {
-    switch (action.type) {
-        case 'SET_ITEM': {
-            return action.value;
-        }
-        case 'CLEAR_ITEM': {
-            return null;
-        }
-        // No default necessary because action.type is a union of string literals
-    }
-};
 export const useItemBeingEdited = () => {
-    const [todos, dispatch] = useReducer(reducer, null);
-    const foo = useContext(ItemBeingEditedContext);
+    useContext(ItemBeingEditedContext);
 };
-export const ItemBeingEditedProvider = (props) => {
+export const ItemBeingEditedProvider = () => {
     return (_jsx(ItemBeingEditedContext.Provider, { value: { state, dispatch }, children: children }));
 };

package/dist/esm/hooks/useOnClickOutside.d.ts

@@ -1,3 +1,6 @@
-declare const useOnClickOutside: (ref: React.RefObject<HTMLDivElement>, handler: (event: any) => void) => void;
+declare const useOnClickOutside: (ref: React.RefObject<HTMLDivElement>, handler: {
+    (event: any): void;
+}, listening?: boolean) => void;
+export declare const getEffectiveZIndex: (element: HTMLElement) => number;
 export default useOnClickOutside;
 //# sourceMappingURL=useOnClickOutside.d.ts.map

package/dist/esm/hooks/useOnClickOutside.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useOnClickOutside.d.ts","sourceRoot":"","sources":["../../../src/hooks/useOnClickOutside.tsx"],"names":[],"mappings":"AAEA,QAAA,MAAM,iBAAiB,QAChB,MAAM,SAAS,CAAC,cAAc,CAAC,mBACjB,GAAG,KAAG,IAAI,SAgB9B,CAAC;AAEF,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"useOnClickOutside.d.ts","sourceRoot":"","sources":["../../../src/hooks/useOnClickOutside.tsx"],"names":[],"mappings":"AAEA,QAAA,MAAM,iBAAiB,QAChB,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,WAC3B;IAAE,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI,CAAA;CAAE,cACnB,OAAO,SA2BpB,CAAC;AAEF,eAAO,MAAM,kBAAkB,YAAa,WAAW,KAAG,MAoBzD,CAAC;AAqBF,eAAe,iBAAiB,CAAC"}

package/dist/esm/hooks/useOnClickOutside.js

@@ -1,18 +1,59 @@
-import { useEffect } from "react";
-const useOnClickOutside = (ref, handler) => {
+import { useEffect } from 'react';
+const useOnClickOutside = (ref, handler, listening) => {
     useEffect(() => {
         const listener = (event) => {
-            if (!ref.current || ref.current.contains(event.target)) {
+            if (!ref.current ||
+                ref.current.contains(event.target) ||
+                event.target.closest('[data-portal-ignore]')) {
                 return;
             }
+            event.preventDefault();
+            event.stopPropagation();
             handler(event);
         };
-        document.addEventListener("mousedown", listener);
-        document.addEventListener("touchstart", listener);
+        if (listening !== false) {
+            document.addEventListener('click', listener);
+            document.addEventListener('touchstart', listener);
+        }
+        else {
+            document.removeEventListener('click', listener);
+            document.removeEventListener('touchstart', listener);
+        }
         return () => {
-            document.removeEventListener("mousedown", listener);
-            document.removeEventListener("touchstart", listener);
+            document.removeEventListener('click', listener);
+            document.removeEventListener('touchstart', listener);
         };
-    }, [ref, handler]);
+    }, [ref, handler, listening]);
+};
+export const getEffectiveZIndex = (element) => {
+    let zIndexSum = 0;
+    let currentElement = element;
+    while (currentElement && currentElement !== document.body) {
+        const computedStyle = window.getComputedStyle(currentElement);
+        const zIndex = computedStyle.zIndex;
+        // If the element creates a stacking context, apply its z-index
+        if (createsStackingContext(computedStyle)) {
+            if (zIndex !== 'auto' && !isNaN(parseInt(zIndex, 10))) {
+                zIndexSum = Math.max(zIndexSum, parseInt(zIndex, 10));
+            }
+        }
+        // Move up to the parent element
+        currentElement = currentElement.parentElement;
+    }
+    return zIndexSum;
+};
+// Determines if an element creates a stacking context
+const createsStackingContext = (computedStyle) => {
+    return (computedStyle.position === 'absolute' ||
+        computedStyle.position === 'relative' ||
+        computedStyle.position === 'fixed' ||
+        computedStyle.position === 'sticky' ||
+        computedStyle.transform !== 'none' ||
+        computedStyle.opacity !== '1' ||
+        computedStyle.filter !== 'none' ||
+        computedStyle.perspective !== 'none' ||
+        computedStyle.willChange !== 'auto' ||
+        computedStyle.contain === 'paint' ||
+        computedStyle.clipPath !== 'none');
 };
 export default useOnClickOutside;

package/dist/esm/hooks/useTenants.d.ts

@@ -0,0 +1,13 @@
+import { QuillTenant } from '../utils/tenants';
+export declare const useTenants: () => {
+    dashboardTenants: QuillTenant[] | undefined;
+    dashboardOwnerTenant: QuillTenant | undefined;
+    selectedTenantValues: (string | number)[] | undefined;
+    selectedTenantType: QuillTenant;
+    selectedDashboardTenantIds: (string | number)[] | undefined;
+    dashboardTenantIdsLoading: boolean | undefined;
+    setSelectedTenantType: (value: string) => Promise<void>;
+    setSelectedTenantValues: (values: string[]) => Promise<void>;
+    setSelectedDashboardTenantIds: (values: string[]) => void;
+};
+//# sourceMappingURL=useTenants.d.ts.map

package/dist/esm/hooks/useTenants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTenants.d.ts","sourceRoot":"","sources":["../../../src/hooks/useTenants.tsx"],"names":[],"mappings":"AACA,OAAO,EAAoB,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAKjE,eAAO,MAAM,UAAU;;;;;;;mCA6CuB,MAAM;sCAsDH,MAAM,EAAE;4CAoDR,MAAM,EAAE;CA+DxD,CAAC"}