@quillsql/react 2.15.2 → 2.15.4

package/dist/esm/Context.js

@@ -1,1425 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import equal from 'fast-deep-equal';
-import { createContext, useEffect, useMemo, useReducer, useRef, useState, } from 'react';
-import { convertPresetOptionsToSelectableList, defaultOptionsV2, } from './DateRangePicker/dateRangePickerUtils';
-import { InternalFilterType, } from './models/Filter';
-import { defaultQuillTheme } from './QuillProvider';
-import { fetchClient } from './utils/client';
-import { getDashboard as requestGetDashboard } from './utils/dashboard';
-import { quillFetch, parseFetchResponse } from './utils/dataFetcher';
-import { createDefaultDateFilter, mergeCustomFilters, } from './utils/filterProcessing';
-import { processReportResponse } from './utils/report';
-import { getSchemaInfo } from './utils/schema';
-const dummySetter = () => { };
-export const SchemaDataContext = createContext([
-    {
-        schema: [],
-        customFields: null,
-        isSchemaLoading: true,
-        schemaWithCustomFields: [],
-    },
-    dummySetter,
-]);
-export const ThemeContext = createContext([null, dummySetter]);
-export const ClientContext = createContext([null, false, dummySetter]);
-const dashboardReducer = (state = {}, action) => {
-    switch (action.type) {
-        case 'UPDATE_DASHBOARD_ITEM':
-            if (!action.id || !action.data || !action.dashboard) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.dashboard]: {
-                    ...state[action.dashboard],
-                    [action.id]: {
-                        ...state[action.dashboard]?.[action.id],
-                        ...action.data,
-                    },
-                },
-            };
-        case 'ADD_DASHBOARD_ITEM':
-            if (!action.id || !action.data || !action.dashboard) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.dashboard]: {
-                    ...state[action.dashboard],
-                    [action.id]: action.data,
-                },
-            };
-        case 'REMOVE_DASHBOARD_ITEM':
-            if (!action.id) {
-                return state;
-            }
-            return Object.fromEntries(Object.entries(state).map(([key, value]) => [
-                key,
-                Object.fromEntries(Object.entries(value).filter(([k]) => k !== action.id)),
-            ]));
-        case 'CLEAR_DASHBOARDS':
-            return {};
-        case 'CLEAR_DASHBOARD':
-            if (!action.dashboard) {
-                return state;
-            }
-            return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.dashboard));
-        default:
-            return state;
-    }
-};
-export const DashboardContext = createContext([{}, dummySetter]);
-const dashboardConfigReducer = (state = {}, action) => {
-    switch (action.type) {
-        case 'UPDATE_DASHBOARD':
-            if (!action.id || !action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.id]: {
-                    ...state[action.id],
-                    ...action.data,
-                },
-            };
-        case 'ADD_DASHBOARD':
-            if (!action.id || !action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.id]: { config: action.data, loading: false },
-            };
-        case 'UPDATE_DASHBOARDS': {
-            if (!action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                ...action.data.reduce((acc, dashboard) => {
-                    acc[dashboard.name] = {
-                        config: {
-                            ...state[dashboard.name]?.config,
-                            ...dashboard,
-                        },
-                        loading: state[dashboard.name]?.loading ?? false,
-                    };
-                    return acc;
-                }, {}),
-            };
-        }
-        case 'ADD_DASHBOARDS': {
-            if (!action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                ...action.data.reduce((acc, dashboard) => {
-                    acc[dashboard.name] = { config: dashboard, loading: false };
-                    return acc;
-                }, {}),
-            };
-        }
-        case 'DELETE_DASHBOARD':
-            if (!action.id) {
-                return state;
-            }
-            return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.id));
-        case 'SET_DASHBOARD_DATA':
-            if (!action.data) {
-                return state;
-            }
-            return action.data.reduce((acc, dashboard) => {
-                acc[dashboard.name] = { config: dashboard, loading: false };
-                return acc;
-            }, {});
-        case 'CLEAR_DASHBOARDS':
-            return {};
-        case 'SET_DASHBOARD_LOADING':
-            if (action.data === undefined || !action.id || !state[action.id]) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.id]: {
-                    ...state[action.id],
-                    loading: action.data,
-                },
-            };
-        default:
-            return state;
-    }
-};
-export const DashboardConfigContext = createContext({
-    dashboardConfig: {},
-    isLoading: true,
-    dashboardConfigDispatch: dummySetter,
-    loadDashboard: async () => undefined,
-});
-const reportsReducer = (state = {}, action) => {
-    switch (action.type) {
-        case 'ADD_REPORT':
-            if (!action.id || !action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.id]: { ...action.data, id: action.id },
-            };
-        case 'DELETE_REPORT':
-            if (!action.id) {
-                return state;
-            }
-            return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.id));
-        case 'UPDATE_REPORT':
-            if (!action.id || !action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.id]: {
-                    ...state[action.id],
-                    ...action.data,
-                },
-            };
-        case 'CLEAR_REPORTS':
-            return {};
-        default:
-            return state;
-    }
-};
-const reportsLoadingStateReducer = (state = {}, action) => {
-    switch (action.type) {
-        case 'SET_REPORT_LOADING':
-            return { ...state, [action.id]: action.data };
-        default:
-            return state;
-    }
-};
-export const ReportsContext = createContext({
-    reports: {},
-    reportsDispatch: dummySetter,
-    fetchIndividualReport: async () => { },
-    reportsLoadingState: {},
-    reportsLoadingStateDispatch: dummySetter,
-});
-const customReportFiltersReducer = (state, action) => {
-    switch (action.type) {
-        case 'ADD_CUSTOM_REPORT_FILTERS':
-            if (!action.data) {
-                const newState = { ...state };
-                delete newState[action.reportId];
-                return newState;
-            }
-            return {
-                ...state,
-                [action.reportId]: action.data,
-            };
-        case 'DELETE_CUSTOM_REPORT_FILTERS':
-            return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.reportId));
-        default:
-            return state;
-    }
-};
-const reportFiltersReducer = (state = {}, action) => {
-    switch (action.type) {
-        case 'ADD_REPORT_FILTERS':
-            if (!action.data || !action.id) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.id]: {
-                    ...action.data.reduce((acc, filter) => {
-                        acc[filter.filter.label] = filter;
-                        return acc;
-                    }, {}),
-                },
-            };
-        case 'UPDATE_REPORT_FILTER':
-            if (!action.id || !action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.id]: {
-                    ...state[action.id],
-                    [action.data.filter.label]: action.data,
-                },
-            };
-        case 'CLEAR_REPORT_FILTERS':
-            if (!action.id) {
-                return {};
-            }
-            else {
-                return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.id));
-            }
-        default:
-            return state;
-    }
-};
-export const ReportFiltersContext = createContext({
-    reportFilters: {},
-    customReportFilters: {},
-    reportFiltersDispatch: dummySetter,
-    customReportFiltersDispatch: dummySetter,
-    loadFiltersForReport: async () => { },
-    abortLoadingFilters: () => { },
-});
-const customDashboardFiltersReducer = (state, action) => {
-    switch (action.type) {
-        case 'ADD_CUSTOM_DASHBOARD_FILTERS':
-            if (!action.data) {
-                const newState = { ...state };
-                delete newState[action.dashboardName];
-                return newState;
-            }
-            return {
-                ...state,
-                [action.dashboardName]: action.data,
-            };
-        case 'DELETE_CUSTOM_DASHBOARD_FILTERS':
-            return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.dashboardName));
-        default:
-            return state;
-    }
-};
-const dashboardFiltersReducer = (state, action) => {
-    switch (action.type) {
-        case 'SET_INITIAL_DASHBOARD_FILTERS':
-            return {
-                ...state,
-                ...action.data,
-            };
-        case 'UPDATE_DASHBOARD_FILTER':
-            if (!action.dashboardName || !action.filterName || !action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.dashboardName]: {
-                    ...state[action.dashboardName],
-                    [action.filterName]: action.data,
-                },
-            };
-        case 'ADD_DASHBOARD_FILTERS':
-            if (!action.dashboardName || !action.data) {
-                return state;
-            }
-            return {
-                ...state,
-                [action.dashboardName]: action.data,
-            };
-        case 'DELETE_DASHBOARD_FILTERS':
-            if (!action.dashboardName) {
-                return state;
-            }
-            return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.dashboardName));
-        case 'CLEAR_DASHBOARD_FILTERS':
-            return {};
-        default:
-            return state;
-    }
-};
-export const DashboardFiltersContext = createContext({
-    dashboardFilters: {},
-    dashboardCustomFilters: {},
-    dispatch: dummySetter,
-    customFilterDispatch: dummySetter,
-    loadFiltersForDashboard: async () => { },
-});
-export const TenantContext = createContext({});
-export const FetchContext = createContext({
-    getToken: async () => '',
-    quillFetchWithToken: async () => ({ data: null }),
-});
-export const EventTrackingContext = createContext({
-    eventTracking: null,
-});
-// TODO: track errors per dashboard in the same way as loading state
-export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoint, queryHeaders, withCredentials, tenants, flags, isAdmin, getAuthorizationToken = async () => '', eventTracking = null, }) => {
-    // get client from session storage
-    const [client, setClient] = useState(typeof window !== 'undefined' && sessionStorage
-        ? JSON.parse(sessionStorage.getItem('quill-client') ?? 'null')
-        : null);
-    const populatedClient = useMemo(() => {
-        if (!client || client.clientId !== publicKey)
-            return null;
-        return {
-            ...client,
-            publicKey,
-            _id: publicKey,
-            id: publicKey,
-            queryHeaders: queryHeaders,
-            queryEndpoint: queryEndpoint,
-            withCredentials: withCredentials ?? false,
-            currentTenants: tenants,
-            currentFlags: flags,
-        };
-    }, [
-        client,
-        publicKey,
-        JSON.stringify(queryHeaders),
-        queryEndpoint,
-        withCredentials,
-        tenants,
-        flags,
-    ]);
-    const [isClientLoading, setIsClientLoading] = useState(false);
-    const [isDashboardsLoading, setIsDashboardsLoading] = useState(true);
-    const [theme, setTheme] = useState(null);
-    const [schemaData, setSchemaData] = useState({
-        schema: [],
-        customFields: null,
-        isSchemaLoading: true,
-        schemaWithCustomFields: [],
-    });
-    const fetchDashboardsAbortController = useRef(null);
-    const fetchDashboardsProcessId = useRef(0);
-    const [dashboard, dispatch] = useReducer(dashboardReducer, {});
-    const [dashboardConfig, dashboardConfigDispatch] = useReducer(dashboardConfigReducer, {});
-    const [dashboardFilters, dashboardFiltersDispatch] = useReducer(dashboardFiltersReducer, {});
-    const [dashboardCustomFilters, customFilterDispatch] = useReducer(customDashboardFiltersReducer, {});
-    const [customReportFilters, customReportFiltersDispatch] = useReducer(customReportFiltersReducer, {});
-    const filterOptionsAbortControllers = useRef(new Set());
-    const [reportFilters, reportFiltersDispatch] = useReducer(reportFiltersReducer, {});
-    const reportFilterOptionsAbortControllers = useRef({});
-    const [reports, reportsDispatch] = useReducer(reportsReducer, {});
-    const [reportsLoadingState, reportsLoadingStateDispatch] = useReducer(reportsLoadingStateReducer, {});
-    const reportsAbortControllers = useRef({});
-    const fetchSchemaAbortController = useRef(null);
-    const fetchSchemaProcessId = useRef(0);
-    const currentTenant = useRef(null);
-    const currentPublicKey = useRef(null);
-    const loadDashboardProcessId = useRef({});
-    // SETS INITIAL THEME
-    useEffect(() => {
-        if (!theme) {
-            const populatedTheme = {
-                ...initialTheme,
-                fontFamily: initialTheme.fontFamily ?? defaultQuillTheme.fontFamily,
-                backgroundColor: initialTheme.backgroundColor ?? defaultQuillTheme.backgroundColor,
-                hoverBackgroundColor: initialTheme.hoverBackgroundColor ??
-                    defaultQuillTheme.hoverBackgroundColor,
-                hoverPrimaryButtonColor: initialTheme.hoverPrimaryButtonColor ??
-                    defaultQuillTheme.hoverPrimaryButtonColor,
-                primaryTextColor: initialTheme.primaryTextColor ?? defaultQuillTheme.primaryTextColor,
-                secondaryTextColor: initialTheme.secondaryTextColor ??
-                    defaultQuillTheme.secondaryTextColor,
-                chartLabelFontFamily: initialTheme.chartLabelFontFamily ??
-                    defaultQuillTheme.chartLabelFontFamily,
-                chartLabelColor: initialTheme.chartLabelColor ?? defaultQuillTheme.chartLabelColor,
-                chartTickColor: initialTheme.chartTickColor ?? defaultQuillTheme.chartTickColor,
-                chartColors: initialTheme?.chartColors && initialTheme?.chartColors?.length > 0
-                    ? initialTheme.chartColors
-                    : defaultQuillTheme.chartColors,
-                borderColor: initialTheme.borderColor ?? defaultQuillTheme.borderColor,
-                borderWidth: initialTheme.borderWidth ?? defaultQuillTheme.borderWidth,
-                primaryButtonColor: initialTheme.primaryButtonColor ??
-                    defaultQuillTheme.primaryButtonColor,
-                secondaryButtonColor: initialTheme.secondaryButtonColor ??
-                    defaultQuillTheme.secondaryButtonColor,
-                labelFontWeight: initialTheme.labelFontWeight ?? defaultQuillTheme.labelFontWeight,
-                fontSize: initialTheme.fontSize ?? defaultQuillTheme.fontSize,
-                loadingStateBackgroundColor: initialTheme.loadingStateBackgroundColor ??
-                    defaultQuillTheme.loadingStateBackgroundColor,
-            };
-            // Update the theme state
-            setTheme(populatedTheme);
-        }
-    }, [initialTheme]);
-    function abortLoadingFilters(reportId) {
-        reportFilterOptionsAbortControllers.current[reportId]?.requests.forEach((controller) => controller.abort());
-        // reportFiltersDispatch({
-        //   type: 'CLEAR_REPORT_FILTERS',
-        //   id: reportId,
-        // });
-    }
-    async function loadFiltersForReport(reportId, initiator, filters, updatedFilterLabel, customFilters, dashboardName) {
-        // Abort all previous fetch requests
-        reportFilterOptionsAbortControllers.current[reportId]?.requests.forEach((controller) => controller.abort());
-        reportFilterOptionsAbortControllers.current[reportId] = {
-            initiator: initiator,
-            requests: new Set(),
-        };
-        reportFiltersDispatch({
-            type: 'ADD_REPORT_FILTERS',
-            id: reportId,
-            data: filters.map((filter) => ({
-                filter,
-                loading: filter.label !== updatedFilterLabel &&
-                    filter.filterType !== 'date_range',
-            })),
-        });
-        try {
-            // For each filter, send a fetch request to get the filter options
-            // Once the options are received, update the filter in the state
-            await Promise.allSettled(filters.map(async (filter) => {
-                if (filter.filterType !== 'string') {
-                    reportFiltersDispatch({
-                        type: 'UPDATE_REPORT_FILTER',
-                        id: reportId,
-                        data: {
-                            filter: filter,
-                            loading: false,
-                        },
-                    });
-                    return null;
-                }
-                if (filter.label === updatedFilterLabel) {
-                    reportFiltersDispatch({
-                        type: 'UPDATE_REPORT_FILTER',
-                        id: reportId,
-                        data: {
-                            filter: filter,
-                            loading: false,
-                        },
-                    });
-                    return null;
-                }
-                const filterOptionsAbortController = new AbortController();
-                reportFilterOptionsAbortControllers.current[reportId]?.requests.add(filterOptionsAbortController);
-                try {
-                    const result = await quillFetch({
-                        client: {
-                            clientId: publicKey,
-                            queryEndpoint,
-                            queryHeaders,
-                            withCredentials: !!withCredentials,
-                        },
-                        task: 'filter-options',
-                        metadata: {
-                            clientId: publicKey,
-                            publicKey: publicKey,
-                            reportId: dashboardName ? undefined : reportId,
-                            name: dashboardName,
-                            useNewNodeSql: true,
-                            filter: {
-                                ...filter,
-                                query: undefined,
-                                options: undefined,
-                            },
-                            appliedFilters: filters
-                                .filter((f) => f.label !== filter.label)
-                                .map((f) => ({
-                                ...f,
-                                query: undefined,
-                                options: undefined,
-                            })),
-                            customFilters: customFilters?.filter((f) => f.filterType !== InternalFilterType.DateCustomFilter &&
-                                f.filterType !== InternalFilterType.DateFilter &&
-                                f.filterType !== InternalFilterType.DateComparisonFilter),
-                            tenants,
-                        },
-                        abortSignal: filterOptionsAbortController?.signal,
-                        getToken: getAuthorizationToken,
-                    });
-                    const filterOptions = result.data?.filters[0]?.options ?? [];
-                    if (!filterOptionsAbortController.signal.aborted) {
-                        reportFiltersDispatch({
-                            type: 'UPDATE_REPORT_FILTER',
-                            id: reportId,
-                            data: {
-                                filter: {
-                                    ...filter,
-                                    options: filterOptions,
-                                },
-                                loading: false,
-                            },
-                        });
-                    }
-                }
-                catch (error) {
-                    if (error instanceof Error && error.name === 'AbortError') {
-                        return;
-                    }
-                    console.error('ERROR:', error);
-                    eventTracking?.logError?.({
-                        type: 'bug', // TODO: determine type
-                        severity: 'high',
-                        message: 'Error fetching filter options',
-                        errorMessage: error.message,
-                        errorStack: error.stack,
-                        errorData: {
-                            caller: 'Context',
-                            function: 'loadFiltersForReport',
-                        },
-                    });
-                }
-                finally {
-                    reportFilterOptionsAbortControllers.current[reportId]?.requests.delete(filterOptionsAbortController);
-                }
-            }));
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                return;
-            }
-            console.error('ERROR:', error);
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error fetching filter options',
-                errorMessage: error.message,
-                errorStack: error.stack,
-                errorData: {
-                    caller: 'Context',
-                    function: 'loadFiltersForReport',
-                },
-            });
-        }
-        finally {
-            delete reportFilterOptionsAbortControllers.current[reportId];
-        }
-    }
-    async function fetchIndividualReport({ reportId, initiator, fetchRows = true, dashboardFilters, customFilters, additionalProcessing, dateBucket, reportAbortController, customFields, propagateChanges, }) {
-        if (!populatedClient) {
-            return;
-        }
-        const filters = mergeCustomFilters(dashboardFilters ?? [], customFilters ?? []);
-        const currentRequest = reportsAbortControllers.current[reportId];
-        if (currentRequest) {
-            // Chart requests override useQuill and useExport requests
-            if (initiator === 'Chart' ||
-                (currentRequest.initiator !== 'Chart' && initiator === 'Table')) {
-                currentRequest.request.abort();
-            }
-            else {
-                return;
-            }
-        }
-        const abortController = reportAbortController || new AbortController();
-        reportsAbortControllers.current[reportId] = {
-            initiator: initiator,
-            request: abortController,
-        };
-        try {
-            const resp = await quillFetch({
-                client: {
-                    clientId: publicKey,
-                    queryEndpoint,
-                    queryHeaders,
-                    withCredentials: !!withCredentials,
-                },
-                task: fetchRows ? 'report' : 'report-info',
-                metadata: {
-                    reportId,
-                    clientId: populatedClient.publicKey,
-                    useNewNodeSql: true,
-                    filters: filters?.map((f) => ({ ...f, options: undefined })),
-                    additionalProcessing,
-                    dateBucket,
-                    databaseType: populatedClient.databaseType,
-                    tenants,
-                    flags,
-                    customFields,
-                },
-                abortSignal: abortController.signal,
-                getToken: getAuthorizationToken,
-                urlParameters: `caller=fetchReport&task=report`,
-            });
-            const results = fetchRows
-                ? await parseFetchResponse(populatedClient, 'report', resp, getAuthorizationToken)
-                : resp;
-            if (results.error) {
-                console.error('Error fetching report:', results.error);
-                return;
-            }
-            const report = !fetchRows
-                ? results.data.report
-                : await processReportResponse({
-                    resp: results,
-                    client: populatedClient,
-                    filters,
-                    dateBucket,
-                    additionalProcessing,
-                    customFields,
-                    getToken: getAuthorizationToken,
-                    tenants,
-                    eventTracking,
-                });
-            reportsDispatch({
-                type: 'ADD_REPORT',
-                id: reportId,
-                data: {
-                    ...report,
-                    filtersApplied: customFilters,
-                    loadingRows: !fetchRows,
-                },
-            });
-            // If the report matches the active dashboard, update the dashboard state
-            if (propagateChanges) {
-                if (dashboard[report.dashboardName]) {
-                    dispatch({
-                        type: 'UPDATE_DASHBOARD_ITEM',
-                        id: reportId,
-                        dashboard: report.dashboardName,
-                        data: {
-                            ...report,
-                            filtersApplied: customFilters,
-                            loadingRows: !fetchRows,
-                        },
-                    });
-                }
-            }
-            if (!fetchRows || !filters?.length) {
-                const returnedFilters = !fetchRows
-                    ? results.data.filters
-                    : results.filters;
-                let dateFilterTemplate = returnedFilters.find((f) => f.filterType === 'date_range');
-                if (dateFilterTemplate) {
-                    dateFilterTemplate = {
-                        ...dateFilterTemplate,
-                        presetOptions: dateFilterTemplate?.presetOptions?.map((preset) => ({
-                            ...preset,
-                            loopStart: preset.loopStart
-                                ? new Date(preset.loopStart)
-                                : undefined,
-                            loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : undefined,
-                        })),
-                        defaultPresetRanges: dateFilterTemplate?.defaultPresetRanges?.map((preset) => ({
-                            ...preset,
-                            loopStart: preset.loopStart
-                                ? new Date(preset.loopStart)
-                                : undefined,
-                            loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : undefined,
-                        })),
-                    };
-                }
-                const dateFilter = dateFilterTemplate
-                    ? createDefaultDateFilter(dateFilterTemplate, [report], report.dashboardName)
-                    : undefined;
-                const stringFilters = returnedFilters.filter((f) => f.filterType !== 'date_range');
-                const allFilters = [
-                    ...(dateFilter ? [dateFilter] : []),
-                    ...stringFilters,
-                ];
-                loadFiltersForReport(reportId, initiator, allFilters, undefined, customFilters);
-            }
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                return;
-            }
-            console.error('ERROR:', error);
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error fetching report',
-                errorMessage: error.message,
-                errorStack: error.stack,
-                errorData: {
-                    caller: 'Context',
-                    function: 'fetchIndividualReport',
-                },
-            });
-            throw error;
-        }
-        finally {
-            delete reportsAbortControllers.current[reportId];
-        }
-    }
-    async function loadFiltersForDashboard(dashboardName, filters, updatedFilterLabel, customFilters) {
-        // Abort all previous fetch requests
-        filterOptionsAbortControllers.current.forEach((controller) => controller.abort());
-        dashboardFiltersDispatch({
-            type: 'ADD_DASHBOARD_FILTERS',
-            dashboardName,
-            data: filters.reduce((acc, filter) => {
-                acc[filter.label] = {
-                    filter,
-                    loading: filter.label !== updatedFilterLabel &&
-                        filter.filterType !== 'date_range',
-                };
-                return acc;
-            }, {}),
-        });
-        // For each filter, send a fetch request to get the filter options
-        // Once the options are received, update the filter in the state
-        await Promise.allSettled(filters.map(async (filter) => {
-            if (filter.filterType !== 'string') {
-                dashboardFiltersDispatch({
-                    type: 'UPDATE_DASHBOARD_FILTER',
-                    dashboardName,
-                    filterName: filter.label,
-                    data: {
-                        filter: filter,
-                        loading: false,
-                    },
-                });
-                return null;
-            }
-            if (filter.label === updatedFilterLabel) {
-                dashboardFiltersDispatch({
-                    type: 'UPDATE_DASHBOARD_FILTER',
-                    dashboardName,
-                    filterName: filter.label,
-                    data: {
-                        filter: filter,
-                        loading: false,
-                    },
-                });
-                return null;
-            }
-            const filterOptionsAbortController = new AbortController();
-            filterOptionsAbortControllers.current.add(filterOptionsAbortController);
-            try {
-                const result = await quillFetch({
-                    client: {
-                        clientId: publicKey,
-                        queryEndpoint,
-                        queryHeaders,
-                        withCredentials: !!withCredentials,
-                    },
-                    task: 'filter-options',
-                    metadata: {
-                        clientId: publicKey,
-                        publicKey,
-                        name: dashboardName,
-                        useNewNodeSql: true,
-                        filter: {
-                            ...filter,
-                            query: undefined,
-                            options: undefined,
-                        },
-                        appliedFilters: filters
-                            .filter((f) => f.label !== filter.label)
-                            .map((f) => ({
-                            ...f,
-                            query: undefined,
-                            options: undefined,
-                        })),
-                        customFilters,
-                        tenants,
-                    },
-                    abortSignal: filterOptionsAbortController?.signal,
-                    getToken: getAuthorizationToken,
-                });
-                const filterOptions = result.data?.filters[0]?.options ?? [];
-                dashboardFiltersDispatch({
-                    type: 'UPDATE_DASHBOARD_FILTER',
-                    dashboardName,
-                    filterName: filter.label,
-                    data: {
-                        filter: {
-                            ...filter,
-                            options: filterOptions,
-                        },
-                        loading: false,
-                    },
-                });
-                // Should we be updating the filters for all attached reports when the dashboard filters change?
-                // reportFiltersDispatch({
-                //   type: 'UPDATE_REPORT_FILTER',
-                //   id: filter.label, // should be a reportId
-                //   data: {
-                //     filter: {
-                //       ...filter,
-                //       options: filterOptions,
-                //     },
-                //     loading: false,
-                //   },
-                // });
-                return null;
-            }
-            catch (error) {
-                if (error instanceof Error && error.name === 'AbortError') {
-                    dashboardFiltersDispatch({
-                        type: 'UPDATE_DASHBOARD_FILTER',
-                        dashboardName,
-                        filterName: filter.label,
-                        data: {
-                            filter,
-                            loading: false,
-                        },
-                    });
-                    return;
-                }
-                console.error('ERROR:', error);
-                eventTracking?.logError?.({
-                    type: 'bug', // TODO: determine type
-                    severity: 'high',
-                    message: 'Error fetching filter options',
-                    errorMessage: error.message,
-                    errorStack: error.stack,
-                    errorData: {
-                        caller: 'Context',
-                        function: 'loadFiltersForDashboard',
-                    },
-                });
-            }
-            finally {
-                filterOptionsAbortControllers.current.delete(filterOptionsAbortController);
-            }
-        }));
-    }
-    async function loadDashboard(dashboardName, fetchFromServer = false, reportAction) {
-        if (!client)
-            return;
-        loadDashboardProcessId.current[dashboardName] =
-            (loadDashboardProcessId.current[dashboardName] ?? 0) + 1;
-        const currentProcessId = loadDashboardProcessId.current[dashboardName];
-        let curDashboardConfig = dashboardConfig[dashboardName]?.config;
-        if (!fetchFromServer && curDashboardConfig?.sections) {
-            if (reportAction?.action === 'delete') {
-                curDashboardConfig = {
-                    ...curDashboardConfig,
-                    sections: Object.fromEntries(Object.entries(curDashboardConfig?.sections ?? {}).map(([sectionKey, reports]) => [
-                        sectionKey,
-                        reports.filter((report) => report.id !== reportAction.report.id),
-                    ])),
-                };
-                // Remove the report from the reports context if present
-                reportsDispatch({
-                    type: 'DELETE_REPORT',
-                    id: reportAction.report.id,
-                });
-                dispatch({
-                    type: 'REMOVE_DASHBOARD_ITEM',
-                    id: reportAction.report.id,
-                });
-            }
-            else if (reportAction?.action === 'upsert') {
-                const report = reportAction.report;
-                // Edit in reports context if present
-                if (reports[report.id]) {
-                    reportsDispatch({
-                        type: 'UPDATE_REPORT',
-                        id: report.id,
-                        data: {
-                            ...reports[report.id],
-                            ...report,
-                        },
-                    });
-                }
-                let newSectionOrder = curDashboardConfig.sectionOrder;
-                const reportSectionExists = newSectionOrder?.some((section) => section.section === report.section);
-                if (newSectionOrder && !reportSectionExists) {
-                    newSectionOrder = [
-                        ...newSectionOrder,
-                        { section: report.section, reportOrder: [report.id] },
-                    ];
-                }
-                if (newSectionOrder) {
-                    newSectionOrder = newSectionOrder.map((section) => {
-                        if (section.section === report.section &&
-                            !section.reportOrder.includes(report.id)) {
-                            section.reportOrder.push(report.id);
-                        }
-                        else if (section.section !== report.section &&
-                            section.reportOrder.includes(report.id)) {
-                            section.reportOrder = section.reportOrder.filter((id) => id !== report.id);
-                        }
-                        return section;
-                    });
-                    const newSections = newSectionOrder.reduce((acc, section) => {
-                        acc[section.section] = section.reportOrder
-                            .map((id, index) => {
-                            if (id === report.id) {
-                                return { ...report, id: id, order: index };
-                            }
-                            return dashboard?.[dashboardName]?.[id]
-                                ? { ...dashboard[dashboardName][id], id: id, order: index }
-                                : null;
-                        })
-                            .filter((r) => r);
-                        return acc;
-                    }, {});
-                    dashboardConfigDispatch({
-                        type: 'UPDATE_DASHBOARD',
-                        id: dashboardName,
-                        data: {
-                            config: {
-                                ...curDashboardConfig,
-                                sections: newSections,
-                                sectionOrder: newSectionOrder?.map((section) => ({
-                                    ...section,
-                                    _id: section._id ?? 'temp_section_id_' + Date.now().toString(),
-                                })) ?? [],
-                            },
-                            loading: false,
-                        },
-                    });
-                    if ((curDashboardConfig.sectionOrder?.find((section) => section.reportOrder?.includes(report?.id ?? ''))?.section ?? '') !== report.section) {
-                        const body = {
-                            task: 'set-section-order',
-                            clientId: client?.clientId,
-                            dashboardName,
-                            sectionOrder: newSectionOrder,
-                        };
-                        try {
-                            await quillFetch({
-                                client,
-                                task: 'set-section-order',
-                                metadata: body,
-                                getToken: getAuthorizationToken,
-                            });
-                        }
-                        catch (e) {
-                            console.error(e);
-                            eventTracking?.logError?.({
-                                type: 'bug', // TODO: determine type
-                                severity: 'high',
-                                message: 'Error setting section order',
-                                errorMessage: e.message,
-                                errorStack: e.stack,
-                                errorData: {
-                                    caller: 'Context',
-                                    function: 'loadDashboard',
-                                },
-                            });
-                        }
-                    }
-                }
-            }
-            if (reportAction?.action !== 'upsert') {
-                dashboardConfigDispatch({
-                    type: 'UPDATE_DASHBOARD',
-                    id: dashboardName,
-                    data: { config: curDashboardConfig, loading: false },
-                });
-            }
-            return curDashboardConfig;
-        }
-        if (!fetchFromServer &&
-            curDashboardConfig &&
-            curDashboardConfig.newQueries) {
-            dashboardConfigDispatch({
-                type: 'SET_DASHBOARD_LOADING',
-                id: dashboardName,
-                data: false,
-            });
-            return curDashboardConfig;
-        }
-        if (!populatedClient || !populatedClient.publicKey) {
-            return curDashboardConfig;
-        }
-        if (dashboardName === null || dashboardName === undefined)
-            return curDashboardConfig;
-        try {
-            dashboardConfigDispatch({
-                type: 'SET_DASHBOARD_LOADING',
-                id: dashboardName,
-                data: true,
-            });
-            const resp = await requestGetDashboard(dashboardName, populatedClient, getAuthorizationToken, tenants, flags);
-            if (currentProcessId === loadDashboardProcessId.current[dashboardName]) {
-                // if dashboard has changed
-                if (!equal(resp, curDashboardConfig)) {
-                    dashboardConfigDispatch({
-                        type: 'UPDATE_DASHBOARD',
-                        id: dashboardName,
-                        data: { config: { ...resp, name: dashboardName }, loading: false },
-                    });
-                    dispatch({ type: 'CLEAR_DASHBOARD', dashboard: dashboardName });
-                    // For each report, set it to the new version
-                    Object.values(resp.sections ?? {})
-                        .flat()
-                        .forEach((report) => {
-                        dispatch({
-                            type: 'ADD_DASHBOARD_ITEM',
-                            id: report.id,
-                            dashboard: dashboardName,
-                            data: report,
-                        });
-                    });
-                }
-            }
-            return resp;
-        }
-        catch (error) {
-            console.error('Error fetching data:', error);
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error fetching data',
-                errorMessage: error.message,
-                errorStack: error.stack,
-                errorData: {
-                    caller: 'Context',
-                    function: 'loadDashboard',
-                },
-            });
-        }
-        finally {
-            dashboardConfigDispatch({
-                type: 'SET_DASHBOARD_LOADING',
-                id: dashboardName,
-                data: false,
-            });
-        }
-    }
-    async function reloadAllDashboards() {
-        const dashboards = Object.keys(dashboard);
-        for (const dashboard of dashboards) {
-            loadDashboard(dashboard, true);
-        }
-    }
-    async function fetchSchema({ client, tenants, caller, }) {
-        fetchSchemaProcessId.current = (fetchSchemaProcessId.current ?? 0) + 1;
-        const currentProcessId = fetchSchemaProcessId.current;
-        if (fetchSchemaAbortController.current) {
-            fetchSchemaAbortController.current.abort();
-        }
-        fetchSchemaAbortController.current = new AbortController();
-        // add custom fields here and also store in schema context
-        setSchemaData((prevSchema) => ({ ...prevSchema, isSchemaLoading: true }));
-        try {
-            const { schemaData: schema, customFieldsByTable, schemaWithCustomFields, } = await getSchemaInfo({
-                client,
-                tenants,
-                caller,
-                abortSignal: fetchSchemaAbortController.current.signal,
-                getToken: getAuthorizationToken,
-                eventTracking,
-            });
-            if (currentProcessId === fetchSchemaProcessId.current) {
-                setSchemaData({
-                    schema,
-                    customFields: customFieldsByTable,
-                    isSchemaLoading: false,
-                    schemaWithCustomFields,
-                });
-            }
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                return;
-            }
-            else {
-                console.error('ERROR:', error);
-                eventTracking?.logError?.({
-                    type: 'bug', // TODO: determine type
-                    severity: 'high',
-                    message: 'Error fetching schema',
-                    errorMessage: error.message,
-                    errorStack: error.stack,
-                    errorData: {
-                        caller: 'Context',
-                        function: 'fetchSchema',
-                    },
-                });
-            }
-        }
-    }
-    async function fetchDashboards(publicKey) {
-        if (!publicKey) {
-            return;
-        }
-        setIsDashboardsLoading(true);
-        fetchDashboardsProcessId.current =
-            (fetchDashboardsProcessId.current ?? 0) + 1;
-        const currentProcessId = fetchDashboardsProcessId.current;
-        if (fetchDashboardsAbortController.current) {
-            fetchDashboardsAbortController.current.abort();
-        }
-        fetchDashboardsAbortController.current = new AbortController();
-        dashboardConfigDispatch({ type: 'CLEAR_DASHBOARDS' });
-        try {
-            const result = await quillFetch({
-                client: {
-                    clientId: publicKey,
-                    queryEndpoint,
-                    queryHeaders,
-                    withCredentials: !!withCredentials,
-                },
-                task: 'dashboards',
-                metadata: {
-                    clientId: publicKey,
-                    // getSections: true, // skip fetching reports since 'dashboard' always does anyway
-                },
-                abortSignal: fetchDashboardsAbortController.current.signal,
-                getToken: getAuthorizationToken,
-            });
-            dashboardConfigDispatch({
-                type: 'SET_DASHBOARD_DATA',
-                data: result.data.dashboards.map((dashboard) => ({
-                    ...dashboard,
-                    dateFilter: dashboard.dateFilter
-                        ? {
-                            ...dashboard.dateFilter,
-                            presetOptions: dashboard.dateFilter.presetOptions?.map((preset) => ({
-                                ...preset,
-                                loopStart: preset.loopStart
-                                    ? new Date(preset.loopStart)
-                                    : undefined,
-                                loopEnd: preset.loopEnd
-                                    ? new Date(preset.loopEnd)
-                                    : undefined,
-                            })),
-                            defaultPresetRanges: dashboard.dateFilter.defaultPresetRanges?.map((preset) => ({
-                                ...preset,
-                                loopStart: preset.loopStart
-                                    ? new Date(preset.loopStart)
-                                    : undefined,
-                                loopEnd: preset.loopEnd
-                                    ? new Date(preset.loopEnd)
-                                    : undefined,
-                            })),
-                        }
-                        : undefined,
-                    createdAt: new Date(dashboard.createdAt),
-                })),
-            });
-            dashboardFiltersDispatch({
-                type: 'SET_INITIAL_DASHBOARD_FILTERS',
-                data: result.data.dashboards.reduce((acc, dashboard) => {
-                    let presetOptions = defaultOptionsV2;
-                    if (dashboard.dateFilter?.presetOptions ||
-                        dashboard.dateFilter?.defaultPresetRanges) {
-                        presetOptions = convertPresetOptionsToSelectableList((dashboard.dateFilter.presetOptions ?? []).map((preset) => ({
-                            ...preset,
-                            loopStart: preset.loopStart
-                                ? new Date(preset.loopStart)
-                                : undefined,
-                            loopEnd: preset.loopEnd
-                                ? new Date(preset.loopEnd)
-                                : undefined,
-                        })), (dashboard.dateFilter.defaultPresetRanges ?? []).map((preset) => ({
-                            ...preset,
-                            loopStart: preset.loopStart
-                                ? new Date(preset.loopStart)
-                                : undefined,
-                            loopEnd: preset.loopEnd
-                                ? new Date(preset.loopEnd)
-                                : undefined,
-                        })));
-                    }
-                    acc[dashboard.name] = {};
-                    if (dashboard.dateFilter) {
-                        dashboard.dateFilter = {
-                            ...dashboard.dateFilter,
-                            startDate: presetOptions.find((elem) => elem.value === dashboard.dateFilter.primaryRange?.value)?.startDate,
-                            endDate: presetOptions.find((elem) => elem.value === dashboard.dateFilter.primaryRange?.value)?.endDate,
-                            filterType: 'date_range',
-                            presetOptions: dashboard.dateFilter.presetOptions?.map((preset) => ({
-                                ...preset,
-                                loopStart: preset.loopStart
-                                    ? new Date(preset.loopStart)
-                                    : undefined,
-                                loopEnd: preset.loopEnd
-                                    ? new Date(preset.loopEnd)
-                                    : undefined,
-                            })),
-                            defaultPresetRanges: dashboard.dateFilter.defaultPresetRanges?.map((preset) => ({
-                                ...preset,
-                                loopStart: preset.loopStart
-                                    ? new Date(preset.loopStart)
-                                    : undefined,
-                                loopEnd: preset.loopEnd
-                                    ? new Date(preset.loopEnd)
-                                    : undefined,
-                            })),
-                        };
-                        acc[dashboard.name][dashboard.dateFilter.label] = {
-                            filter: dashboard.dateFilter,
-                            loading: true,
-                        };
-                    }
-                    dashboard.filters.forEach((filter) => {
-                        acc[dashboard.name][filter.label] = {
-                            filter: { ...filter, options: undefined },
-                            loading: true,
-                        };
-                    });
-                    return acc;
-                }, {}),
-            });
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                return;
-            }
-            else {
-                console.error('ERROR:', error);
-                eventTracking?.logError?.({
-                    type: 'bug', // TODO: determine type
-                    severity: 'high',
-                    message: 'Error fetching dashboards',
-                    errorMessage: error.message,
-                    errorStack: error.stack,
-                    errorData: {
-                        caller: 'Context',
-                        function: 'fetchDashboards',
-                    },
-                });
-            }
-        }
-        finally {
-            if (currentProcessId === fetchDashboardsProcessId.current) {
-                setIsDashboardsLoading(false);
-            }
-        }
-    }
-    async function quillFetchWithToken({ client, task, method = 'POST', metadata, abortSignal, credentials = 'omit', urlParameters, includeFlags = false, includeTenants = false, adminMode, }) {
-        try {
-            const result = await quillFetch({
-                client,
-                task,
-                method,
-                metadata: {
-                    flags: includeFlags ? flags : undefined,
-                    tenants: includeTenants ? tenants : undefined,
-                    adminMode,
-                    ...metadata,
-                },
-                abortSignal,
-                credentials,
-                urlParameters,
-                getToken: getAuthorizationToken,
-            });
-            return result;
-        }
-        catch (e) {
-            if (e instanceof Error && e.name === 'AbortError') {
-                throw e;
-            }
-            console.error('Failed to fetch:', e);
-            eventTracking?.logError?.({
-                type: 'network',
-                severity: 'medium',
-                message: 'Error fetching data',
-                errorMessage: e.message,
-                errorStack: e.stack,
-                errorData: {
-                    caller: 'Context',
-                    function: 'quillFetchWithToken',
-                },
-            });
-            return { error: 'Failed to fetch data' };
-        }
-    }
-    useEffect(() => {
-        async function updateClientAndSchema(publicKey) {
-            if (!publicKey ||
-                (populatedClient?.clientId === publicKey &&
-                    populatedClient?.allTenantTypes?.length))
-                return;
-            setIsClientLoading(true);
-            setSchemaData({ ...schemaData, isSchemaLoading: true });
-            try {
-                const newClient = await fetchClient(publicKey, queryEndpoint, withCredentials, getAuthorizationToken, eventTracking, queryHeaders, isAdmin);
-                if (!newClient.allTenantTypes?.every((t) => t.defaultId || t.scope === 'database')) {
-                    console.error('Default organization not found. Please select a default organization for ', newClient.allTenantTypes?.find((t) => !t.defaultId));
-                }
-                setClient({
-                    ...populatedClient,
-                    queryHeaders: queryHeaders,
-                    queryEndpoint: queryEndpoint,
-                    withCredentials: withCredentials ?? false,
-                    databaseType: newClient.databaseType,
-                    name: newClient.name,
-                    clientId: publicKey,
-                    publicKey: publicKey,
-                    featureFlags: newClient.featureFlags,
-                    clerkOrgId: newClient.clerkOrgId,
-                    allTenantTypes: newClient.allTenantTypes,
-                });
-            }
-            catch (error) {
-                console.error('Error fetching client:', error);
-            }
-            finally {
-                setIsClientLoading(false);
-            }
-        }
-        updateClientAndSchema(publicKey);
-    }, [publicKey]);
-    useEffect(() => {
-        let publicKeyChanged = false;
-        if (populatedClient?.publicKey &&
-            currentPublicKey.current !== populatedClient?.publicKey) {
-            publicKeyChanged = true;
-            // CLEAR ALL DASHBOARD DATA AND REPORTS AND THEIR FILTERS
-            dispatch({ type: 'CLEAR_DASHBOARDS' });
-            dashboardFiltersDispatch({ type: 'CLEAR_DASHBOARD_FILTERS' });
-            reportFiltersDispatch({ type: 'CLEAR_REPORT_FILTERS' });
-            reportsDispatch({ type: 'CLEAR_REPORTS' });
-            // TODO: this is yet another unfortunate hack where the answer is to unify the admin and react state
-            // currently, we fetch the dashboards twice if both the client and default org change
-            // because if we didn't, we would fetch 0 times if the client changed but the org didn't
-            if (isAdmin) {
-                setIsDashboardsLoading(true);
-                fetchDashboards(populatedClient?.publicKey);
-            }
-            else {
-                setIsDashboardsLoading(false);
-            }
-            currentPublicKey.current = publicKey;
-        }
-        if ((populatedClient?.currentTenants &&
-            !equal(currentTenant.current, populatedClient?.currentTenants)) ||
-            publicKeyChanged) {
-            if (!publicKeyChanged) {
-                // dispatch({ type: 'CLEAR_DASHBOARDS' });
-                reloadAllDashboards();
-                dashboardFiltersDispatch({ type: 'CLEAR_DASHBOARD_FILTERS' });
-                reportFiltersDispatch({ type: 'CLEAR_REPORT_FILTERS' });
-                reportsDispatch({ type: 'CLEAR_REPORTS' });
-            }
-            if (populatedClient) {
-                fetchSchema({
-                    client: populatedClient,
-                    tenants: populatedClient.currentTenants,
-                    caller: 'context',
-                });
-            }
-            currentTenant.current = populatedClient?.currentTenants ?? null;
-        }
-        if (typeof window !== 'undefined' && sessionStorage) {
-            sessionStorage.setItem('quill-client', JSON.stringify({
-                ...populatedClient,
-                allTenantTypes: undefined,
-            }));
-        }
-        if (populatedClient?.currentTenants && populatedClient?.publicKey) {
-            const tenant = typeof populatedClient?.currentTenants[0] === 'object'
-                ? populatedClient?.currentTenants[0]?.tenantField
-                : undefined;
-            const tenantIds = tenant && typeof populatedClient?.currentTenants[0] === 'object'
-                ? populatedClient?.currentTenants[0]?.tenantIds
-                : populatedClient?.currentTenants;
-            eventTracking?.setUser?.({
-                clientId: populatedClient.publicKey,
-                clerkOrgId: populatedClient.clerkOrgId,
-                tenant,
-                tenantIds,
-            });
-        }
-    }, [populatedClient?.currentTenants, populatedClient?.publicKey]);
-    if (!theme) {
-        return null;
-    }
-    return (_jsx(ClientContext.Provider, { value: [
-            isClientLoading || !populatedClient ? null : populatedClient,
-            isClientLoading,
-            setClient,
-        ], children: _jsx(ThemeContext.Provider, { value: [theme, setTheme], children: _jsx(FetchContext.Provider, { value: { getToken: getAuthorizationToken, quillFetchWithToken }, children: _jsx(EventTrackingContext.Provider, { value: { eventTracking }, children: _jsx(SchemaDataContext.Provider, { value: [schemaData, setSchemaData], children: _jsx(DashboardContext.Provider, { value: [dashboard, dispatch], children: _jsx(DashboardConfigContext.Provider, { value: {
-                                    dashboardConfig: isDashboardsLoading ? {} : dashboardConfig,
-                                    isLoading: isDashboardsLoading,
-                                    dashboardConfigDispatch,
-                                    loadDashboard,
-                                }, children: _jsx(DashboardFiltersContext.Provider, { value: {
-                                        dashboardFilters,
-                                        dashboardCustomFilters,
-                                        customFilterDispatch,
-                                        dispatch: dashboardFiltersDispatch,
-                                        loadFiltersForDashboard,
-                                    }, children: _jsx(ReportFiltersContext.Provider, { value: {
-                                            reportFilters,
-                                            customReportFilters,
-                                            reportFiltersDispatch,
-                                            customReportFiltersDispatch,
-                                            loadFiltersForReport,
-                                            abortLoadingFilters,
-                                        }, children: _jsx(ReportsContext.Provider, { value: {
-                                                reports,
-                                                reportsDispatch,
-                                                fetchIndividualReport,
-                                                reportsLoadingState,
-                                                reportsLoadingStateDispatch,
-                                            }, children: _jsx(TenantContext.Provider, { value: {
-                                                    tenants: populatedClient?.currentTenants ?? tenants,
-                                                    flags: populatedClient?.currentFlags ?? flags,
-                                                }, children: children }) }) }) }) }) }) }) }) }) }) }));
-};