@gen3/core 0.10.54 → 0.10.55

package/dist/cjs/index.js

@@ -7,14 +7,15 @@ var query = require('@reduxjs/toolkit/query');
 var React = require('react');
 var reactRedux = require('react-redux');
 var lodash = require('lodash');
-var Queue = require('queue');
+var idb = require('idb');
+var useSWR = require('swr');
 var jsonpathPlus = require('jsonpath-plus');
+var flat = require('flat');
+var Papa = require('papaparse');
+var Queue = require('queue');
 var uuid = require('uuid');
 var reduxPersist = require('redux-persist');
 var reactCookie = require('react-cookie');
-var useSWR = require('swr');
-var flat = require('flat');
-var Papa = require('papaparse');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -50,6 +51,7 @@ const GEN3_REDIRECT_URL = process.env.NEXT_PUBLIC_GEN3_REDIRECT_URL || GEN3_API;
 const GEN3_WORKSPACE_API = process.env.NEXT_PUBLIC_GEN3_WORKSPACE_STATUS_API || `${GEN3_API}/lw-workspace`;
 const GEN3_SUBMISSION_API = process.env.NEXT_PUBLIC_GEN3_SUBMISSION_API || `${GEN3_API}/api/v0/submission`;
 const GEN3_WTS_API = process.env.NEXT_PUBLIC_GEN3_WTS_API || `${GEN3_API}/wts`;
+const GEN3_DATA_LIBRARY_API = process.env.NEXT_PUBLIC_GEN3_DATA_LIBRARY_API || `${GEN3_API}/library/lists`;
 const GEN3_CROSSWALK_API = process.env.NEXT_PUBLIC_GEN3_CROSSWALK_API || `${GEN3_API}/mds`;
 const GEN3_SOWER_API = process.env.NEXT_PUBLIC_GEN3_SOWER_API || `${GEN3_API}/jobs`;
 exports.Accessibility = void 0;
@@ -63,6 +65,10 @@ const FILE_DELIMITERS = {
     csv: ','
 };
 
+// import { selectCSRFToken } from '../user/userSliceRTK';
+// import { coreStore } from '../../store';
+// import { prepareUrl } from '../../utils';
+// import { getCookie } from 'cookies-next';
 /**
  * Template for fence error response dict
  * @returns: An error dict response from a RESTFUL API request
@@ -94,7 +100,59 @@ const FILE_DELIMITERS = {
         headers,
         body
     });
+}; /*
+interface DownloadFromFenceParameters {
+  guid: string;
+  method?: 'GET' | 'POST';
+  onStart?: () => void; // function to call when the download starts
+  onDone?: (blob: Blob) => void; // function to call when the download is done
+  onError?: (error: Error) => void; // function to call when the download fails
+  onAbort?: () => void; // function to call when the download is aborted
+  signal?: AbortSignal; // AbortSignal to use for the request
+}
+
+
+export const fetchFencePresignedURL = async ({
+  guid,
+  method = 'GET',
+  onAbort = () => null,
+  signal = undefined,
+}: DownloadFromFenceParameters) => {
+  const csrfToken = selectCSRFToken(coreStore.getState());
+
+  const headers = new Headers();
+  headers.set('Content-Type', 'application/json');
+  if (csrfToken) headers.set('X-CSRF-Token', csrfToken);
+  let accessToken = undefined;
+  if (process.env.NODE_ENV === 'development') {
+    // NOTE: This cookie can only be accessed from the client side
+    // in development mode. Otherwise, the cookie is set as httpOnly
+    accessToken = getCookie('credentials_token');
+  }
+  if (csrfToken) headers.set('X-CSRF-Token', csrfToken);
+  if (accessToken) headers.set('Authorization', `Bearer ${accessToken}`);
+  const url = prepareUrl(`${GEN3_FENCE_API}/user/download/${guid}`);
+
+  try {
+    const response = await fetch(url.toString(), {
+      method: method,
+      headers: headers,
+      ...(signal ? { signal: signal } : {}),
+    } as RequestInit);
+
+    const jsonData = await response.json();
+    // convert the data to the specified format and return a Blob
+    return jsonData;
+  } catch (error: any) {
+    // Abort is handle as an exception
+    if (error.name == 'AbortError') {
+      // handle abort()
+      onAbort?.();
+    }
+    throw new Error(error);
+  }
 };
+*/
 
 const userAuthApi = react.createApi({
     reducerPath: 'userAuthApi',
@@ -224,10 +282,13 @@ const gen3ServicesReducerMiddleware = gen3Api.middleware;
     endpoints: (builder)=>({
             getLoginProviders: builder.query({
                 query: ()=>`${GEN3_FENCE_API}/user/login`
+            }),
+            getDownload: builder.query({
+                query: (guid)=>`${GEN3_FENCE_API}/user/data/download/${guid}`
             })
         })
 });
-const { useGetLoginProvidersQuery } = loginProvidersApi;
+const { useGetLoginProvidersQuery, useGetDownloadQuery, useLazyGetDownloadQuery } = loginProvidersApi;
 /**
  * Logout from fence
  */ const logoutFence = async (redirect = '/')=>await fetchFence({
@@ -411,7 +472,7 @@ const createUseCoreDataHook = (fetchDataActionCreator, dataSelector)=>{
 });
 const isAuthenticated = (loginStatus)=>loginStatus === 'authenticated';
 const isPending = (loginStatus)=>loginStatus === 'pending';
-const initialState$4 = {
+const initialState$5 = {
     status: 'uninitialized',
     loginStatus: 'unauthenticated',
     error: undefined
@@ -422,9 +483,9 @@ const initialState$4 = {
  * @returns: status messages wrapped around fetchUserState response dict
  */ const slice$4 = toolkit.createSlice({
     name: 'fence/user',
-    initialState: initialState$4,
+    initialState: initialState$5,
     reducers: {
-        resetUserState: ()=>initialState$4
+        resetUserState: ()=>initialState$5
     },
     extraReducers: (builder)=>{
         builder.addCase(fetchUserState.fulfilled, (_, action)=>{
@@ -594,12 +655,12 @@ const lookupGen3App = (id)=>{
     return REGISTRY[id];
 };
 
-const initialState$3 = {
+const initialState$4 = {
     gen3Apps: {}
 };
 const slice$3 = toolkit.createSlice({
     name: 'gen3Apps',
-    initialState: initialState$3,
+    initialState: initialState$4,
     reducers: {
         addGen3AppMetadata: (state, action)=>{
             const { name, requiredEntityTypes } = action.payload;
@@ -618,11 +679,11 @@ const { addGen3AppMetadata } = slice$3.actions;
 const selectGen3AppMetadataByName = (state, appName)=>state.gen3Apps.gen3Apps[appName];
 const selectGen3AppByName = (appName)=>lookupGen3App(appName); // TODO: memoize this selector
 
-const initialState$2 = {};
+const initialState$3 = {};
 // TODO: document what this does
 const slice$2 = toolkit.createSlice({
     name: 'drsResolver',
-    initialState: initialState$2,
+    initialState: initialState$3,
     reducers: {
         setDRSHostnames: (_state, action)=>{
             return action.payload;
@@ -640,13 +701,13 @@ exports.Modals = void 0;
     Modals["CreateCredentialsAPIKeyModal"] = "CreateCredentialsAPIKeyModal";
     Modals["GeneralErrorModal"] = "GeneralErrorModal";
 })(exports.Modals || (exports.Modals = {}));
-const initialState$1 = {
+const initialState$2 = {
     currentModal: null
 };
 //Creates a modal slice for tracking showModal and hideModal state.
 const slice$1 = toolkit.createSlice({
     name: 'modals',
-    initialState: initialState$1,
+    initialState: initialState$2,
     reducers: {
         showModal: (state, action)=>{
             state.currentModal = action.payload.modal;
@@ -786,6 +847,587 @@ const EmptyFilterSet = {
 };
 const cohortReducer = cohortSlice.reducer;
 
+const isFileItem = (item)=>{
+    return item && 'guid' in item;
+};
+const isAdditionalDataItem = (item)=>{
+    return item.itemType === 'AdditionalData'; // TODO resolve this with type from the api
+};
+// Type guard for CohortItem
+const isCohortItem = (item)=>{
+    return item && 'data' in item && 'schemaVersion' in item && item.itemType === 'Gen3GraphQL';
+};
+
+const processItem = (id, data)=>{
+    if (data?.type === 'AdditionalData') {
+        return {
+            name: data.name,
+            itemType: 'AdditionalData',
+            description: data?.description,
+            documentationUrl: data?.documentationUrl,
+            url: data?.url
+        };
+    }
+    return {
+        ...data,
+        itemType: 'Data',
+        guid: data.id,
+        id: id
+    };
+};
+const BuildList = (listId, listData)=>{
+    if (!Object.keys(listData).includes('items')) return undefined;
+    const items = Object.entries(listData?.items).reduce((acc, [id, data])=>{
+        if (data?.type === 'Gen3GraphQL') {
+            acc.items[id] = {
+                itemType: 'Gen3GraphQL',
+                id: data.guid,
+                schemaVersion: data.schema_version,
+                data: data.data,
+                name: data.name,
+                index: data.index
+            };
+        } else {
+            if (!(data.dataset_guid in acc.items)) {
+                acc.items[data.dataset_guid] = {
+                    id: data.dataset_guid,
+                    name: '',
+                    items: {
+                        [id]: processItem(id, data)
+                    }
+                };
+            } else {
+                acc.items[data.dataset_guid].items[id] = processItem(id, data);
+            }
+        }
+        return acc;
+    }, {
+        items: {},
+        version: listData?.version ?? 0,
+        createdTime: listData?.created_time,
+        updatedTime: listData?.updated_time,
+        name: listData?.name ?? listId,
+        id: listId,
+        authz: {
+            version: listData.authz.version,
+            authz: listData.authz
+        }
+    });
+    return items;
+};
+const BuildLists = (data)=>{
+    return Object.entries(data?.lists).reduce((acc, [listId, listData])=>{
+        const list = BuildList(listId, listData);
+        if (list) acc[listId] = list;
+        return acc;
+    }, {});
+};
+/**
+ * Calculates the total number of items within a DataList object.
+ *
+ * @param {DataList} dataList - The DataList object to count items from.
+ * @return {number} The total number of items in the DataList.
+ */ const getNumberOfItemsInDatalist = (dataList)=>{
+    if (!dataList?.items) return 0;
+    return Object.values(dataList.items).reduce((count, item)=>{
+        if (isCohortItem(item)) {
+            return count + 1;
+        } else {
+            return count + Object.values(item?.items ?? {}).reduce((fileCount, x)=>{
+                if (isFileItem(x)) {
+                    return fileCount + 1;
+                }
+                return fileCount;
+            }, 0);
+        }
+    }, 0);
+};
+const getTimestamp = ()=>{
+    return new Date(Date.now()).toLocaleString();
+};
+const flattenDataList = (dataList)=>{
+    // convert datalist into user-data-library for for updating.
+    const items = Object.entries(dataList.items).reduce((acc, [id, value])=>{
+        if (isCohortItem(value)) {
+            acc[id] = value;
+        } else {
+            return {
+                ...acc,
+                ...value.items
+            };
+        }
+        return acc;
+    }, {});
+    return {
+        name: dataList.name,
+        items: items
+    };
+};
+
+const TAGS = 'dataLibrary';
+const dataLibraryTags = gen3Api.enhanceEndpoints({
+    addTagTypes: [
+        TAGS
+    ]
+});
+/**
+ * RTKQuery hooks for data-library list CRUD operations.
+ * @param getLists returns all the list in the user's data library
+ * @param getList args: id returns the list for the given id
+ * @param addLists args: Record<string, ListItemDefinition> populates the whole datalibrary
+ * @param addList args: id ListItemDefinition creates a new list
+ * @param updateList args: id ListItemDefinition updates a list
+ * @param deleteList args: id deletes the list by id
+ */ const dataLibraryApi = dataLibraryTags.injectEndpoints({
+    endpoints: (builder)=>({
+            getDataLibraryLists: builder.query({
+                query: ()=>`${GEN3_DATA_LIBRARY_API}`,
+                transformResponse: (res)=>{
+                    return {
+                        lists: BuildLists(res)
+                    };
+                },
+                transformErrorResponse (response) {
+                    if ('originalStatus' in response) return {
+                        status: response.originalStatus,
+                        data: response.data
+                    };
+                    return response;
+                }
+            }),
+            getDataLibraryList: builder.query({
+                query: (id)=>`${GEN3_DATA_LIBRARY_API}/${id}`,
+                transformResponse: (res)=>BuildLists(res)?.lists
+            }),
+            addAllDataLibraryLists: builder.mutation({
+                query: (lists)=>({
+                        url: `${GEN3_DATA_LIBRARY_API}`,
+                        method: 'POST',
+                        body: lists
+                    }),
+                invalidatesTags: [
+                    TAGS
+                ],
+                transformErrorResponse (response) {
+                    if ('originalStatus' in response) return {
+                        status: response.originalStatus,
+                        data: response.data
+                    };
+                    return response;
+                }
+            }),
+            addDataLibraryList: builder.mutation({
+                query: (list)=>({
+                        url: `${GEN3_DATA_LIBRARY_API}/${toolkit.nanoid()}`,
+                        method: 'POST',
+                        body: list ?? {}
+                    }),
+                transformErrorResponse (response) {
+                    if ('originalStatus' in response) return {
+                        status: response.originalStatus,
+                        data: response.data
+                    };
+                    return response;
+                },
+                invalidatesTags: [
+                    TAGS
+                ]
+            }),
+            updateDataLibraryList: builder.mutation({
+                query: ({ id, list })=>({
+                        url: `${GEN3_DATA_LIBRARY_API}/${id}`,
+                        method: 'PUT',
+                        body: list
+                    }),
+                transformErrorResponse (response) {
+                    if ('originalStatus' in response) return {
+                        status: response.originalStatus,
+                        data: response.data
+                    };
+                    return response;
+                },
+                invalidatesTags: [
+                    TAGS
+                ]
+            }),
+            deleteDataLibraryList: builder.mutation({
+                query: (id)=>({
+                        url: `${GEN3_DATA_LIBRARY_API}/${id}`,
+                        method: 'DELETE'
+                    }),
+                transformErrorResponse (response) {
+                    if ('originalStatus' in response) return {
+                        status: response.originalStatus,
+                        data: response.data
+                    };
+                    return response;
+                },
+                invalidatesTags: [
+                    TAGS
+                ]
+            }),
+            deleteAllDataLibrary: builder.mutation({
+                query: ()=>({
+                        url: `${GEN3_DATA_LIBRARY_API}`,
+                        method: 'DELETE'
+                    }),
+                transformErrorResponse (response) {
+                    if ('originalStatus' in response) return {
+                        status: response.originalStatus,
+                        data: response.data
+                    };
+                    return response;
+                },
+                invalidatesTags: [
+                    TAGS
+                ]
+            })
+        })
+});
+const { useGetDataLibraryListQuery, useGetDataLibraryListsQuery, useAddDataLibraryListMutation, useAddAllDataLibraryListsMutation, useDeleteDataLibraryListMutation, useDeleteAllDataLibraryMutation, useUpdateDataLibraryListMutation } = dataLibraryApi;
+
+const DATABASE_NAME = 'Gen3DataLibrary';
+const STORE_NAME = 'DataLibraryLists';
+const getDb = async ()=>{
+    return idb.openDB(DATABASE_NAME, 1, {
+        upgrade (db) {
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+                db.createObjectStore(STORE_NAME, {
+                    keyPath: 'id'
+                });
+            }
+        }
+    });
+};
+/**
+ * Deletes a list from the database.
+ *
+ * @async
+ * @param {string} id - The unique identifier of the list to delete.
+ * @returns {Promise<ReturnStatus>} The status of the deletion operation.
+ * @throws {Error} If the list with the provided id does not exist.
+ */ const deleteListIndexDB = async (id)=>{
+    try {
+        const db = await getDb();
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        const store = tx.objectStore(STORE_NAME);
+        const item = await store.get(id);
+        if (!item) {
+            throw new Error(`List ${id} does not exist`);
+        }
+        store.delete(id);
+        await tx.done;
+        return {
+            status: `${id} deleted`
+        };
+    } catch (error) {
+        return {
+            isError: true
+        };
+    }
+};
+const deleteAll = async ()=>{
+    try {
+        const db = await getDb();
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        tx.objectStore(STORE_NAME).clear();
+        await tx.done;
+        return {
+            status: 'list added'
+        };
+    } catch (error) {
+        return {
+            isError: true,
+            status: `unable to clear library`
+        };
+    }
+};
+const addListToDataLibraryIndexDB = async (body)=>{
+    const timestamp = getTimestamp();
+    try {
+        const db = await getDb();
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        const id = toolkit.nanoid(); // Create an id for the list
+        tx.objectStore(STORE_NAME).put({
+            id,
+            version: 0,
+            items: body?.items ?? {},
+            creator: '{{subject_id}}',
+            authz: {
+                version: 0,
+                authz: [
+                    `/users/{{subject_id}}/user-library/lists/${id}`
+                ]
+            },
+            name: body?.name ?? 'New List',
+            created_time: timestamp,
+            updated_time: timestamp
+        });
+        await tx.done;
+        return {
+            status: 'list added'
+        };
+    } catch (error) {
+        return {
+            isError: true,
+            status: `unable to add list`
+        };
+    }
+};
+const updateListIndexDB = async (id, list)=>{
+    try {
+        const db = await getDb();
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        const store = tx.objectStore(STORE_NAME);
+        const listData = await store.get(id);
+        if (!listData) {
+            throw new Error(`List ${id} does not exist`);
+        }
+        const timestamp = getTimestamp();
+        const version = listData.version ? listData.version + 1 : 0;
+        const updated = {
+            ...listData,
+            ...list,
+            version: version,
+            updated_time: timestamp,
+            created_time: listData.created_time
+        };
+        store.put(updated);
+        await tx.done;
+        return {
+            status: 'success'
+        };
+    } catch (error) {
+        let errorMessage = 'An unknown error occurred';
+        if (error instanceof Error) {
+            errorMessage = error.message;
+        }
+        return {
+            isError: true,
+            status: `Unable to update list: ${id}. Error: ${errorMessage}`
+        };
+    }
+};
+const addAllListIndexDB = async (data)=>{
+    if (!Object.keys(data).includes('lists') || !lodash.isArray(data['lists'])) {
+        return {
+            isError: true,
+            status: 'lists not found in request'
+        };
+    }
+    const timestamp = getTimestamp();
+    const allLists = data['lists'].reduce((acc, x)=>{
+        if (!isJSONObject(x)) return acc;
+        const id = toolkit.nanoid(10);
+        acc[id] = {
+            ...x,
+            version: 0,
+            created_time: timestamp,
+            updated_time: timestamp,
+            creator: '{{subject_id}}',
+            authz: {
+                version: 0,
+                authz: [
+                    `/users/{{subject_id}}/user-library/lists/${id}`
+                ]
+            }
+        };
+        return acc;
+    }, {});
+    try {
+        const db = await getDb();
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        for (const [id, list] of Object.entries(allLists)){
+            tx.objectStore(STORE_NAME).put({
+                id,
+                ...list
+            });
+        }
+        await tx.done;
+        return {
+            status: 'success'
+        };
+    } catch (error) {
+        return {
+            isError: true,
+            status: 'unable to add lists'
+        };
+    }
+};
+const getDataLibraryListIndexDB = async (id)=>{
+    try {
+        const db = await getDb();
+        const tx = db.transaction(STORE_NAME, 'readonly');
+        const store = tx.objectStore(STORE_NAME);
+        if (id !== undefined) ; else {
+            const lists = await store.getAll();
+            const listMap = lists.reduce((acc, x)=>{
+                acc[x.id] = {
+                    ...x,
+                    items: x.items
+                };
+                return acc;
+            }, {});
+            const datalists = BuildLists({
+                lists: listMap
+            });
+            return {
+                status: 'success',
+                lists: datalists
+            };
+        }
+    } catch (error) {
+        return {
+            isError: true
+        };
+    }
+};
+
+const useDataLibrary = (useApi)=>{
+    const [localLibrary, setLocalLibrary] = React.useState({});
+    const { data: apiLibrary, refetch: refetchLibraryFromApi, error: apiError, isError: isAPIListError, isLoading: isAPIListLoading } = useGetDataLibraryListsQuery(undefined, {
+        skip: !useApi
+    });
+    const [addItemToLibraryApi] = useAddDataLibraryListMutation();
+    const [addAllItemsToLibraryApi] = useAddAllDataLibraryListsMutation();
+    const [deleteItemInLibraryApi] = useDeleteDataLibraryListMutation();
+    const [updateItemInLibraryApi, { isLoading: isUpdatingLoading }] = useUpdateDataLibraryListMutation();
+    const [deleteAllApi] = useDeleteAllDataLibraryMutation();
+    let hasError = false;
+    let errorData = null;
+    let isLoading = false;
+    // TODO: Add error message from indexedDB
+    if (useApi && isAPIListError) {
+        hasError = true;
+        errorData = apiError;
+    }
+    if (useApi && (isUpdatingLoading || isAPIListLoading)) {
+        isLoading = true;
+    }
+    const generateUniqueName = (baseName = 'List')=>{
+        let uniqueName = baseName;
+        let counter = 1;
+        const existingNames = dataLibrary ? Object.values(dataLibrary).map((x)=>x.name) : [];
+        while(existingNames.includes(uniqueName)){
+            uniqueName = `${baseName} ${counter}`;
+            counter++;
+        }
+        return uniqueName;
+    };
+    const refetchLocalLists = async ()=>{
+        const { isError, lists } = await getDataLibraryListIndexDB();
+        setLocalLibrary(lists ?? {});
+        hasError = isError === true;
+    };
+    React.useEffect(()=>{
+        const fetchLibrary = async ()=>{
+            if (!useApi) {
+                const { isError, lists } = await getDataLibraryListIndexDB();
+                if (!isError) {
+                    setLocalLibrary(lists ?? {});
+                }
+            }
+        };
+        fetchLibrary();
+    }, [
+        useApi
+    ]);
+    const addListToDataLibrary = async (item)=>{
+        const adjustedData = {
+            ...item ?? {},
+            name: generateUniqueName(item?.name ?? 'List')
+        };
+        if (useApi) {
+            await addItemToLibraryApi(adjustedData);
+            refetchLibraryFromApi();
+        } else {
+            const { isError } = await addListToDataLibraryIndexDB(adjustedData);
+            await refetchLocalLists();
+            hasError = isError === true;
+        }
+    };
+    const deleteListFromDataLibrary = async (id)=>{
+        if (useApi) {
+            await deleteItemInLibraryApi(id);
+            refetchLibraryFromApi();
+        } else {
+            const { isError } = await deleteListIndexDB(id);
+            refetchLocalLists();
+            hasError = isError === true;
+        }
+    };
+    const setAllListsInDataLibrary = async (data)=>{
+        if (useApi) {
+            await addAllItemsToLibraryApi(data);
+            refetchLibraryFromApi();
+        } else {
+            const { isError } = await addAllListIndexDB(data);
+            refetchLocalLists();
+            hasError = isError === true;
+        }
+    };
+    const updateListInDataLibrary = async (id, data)=>{
+        const flattend = flattenDataList(data);
+        if (useApi) {
+            await updateItemInLibraryApi({
+                id,
+                list: flattend
+            });
+            refetchLibraryFromApi();
+        } else {
+            const { isError } = await updateListIndexDB(id, data);
+            refetchLocalLists();
+            hasError = isError === true;
+        }
+    };
+    const clearLibrary = async ()=>{
+        if (useApi) {
+            await deleteAllApi();
+            refetchLibraryFromApi();
+        } else {
+            const { isError } = await deleteAll();
+            refetchLocalLists();
+            hasError = isError === true;
+        }
+    };
+    const dataLibrary = useApi ? apiLibrary ? apiLibrary.lists : {} : localLibrary;
+    return {
+        dataLibrary,
+        isError: hasError,
+        isLoading,
+        error: errorData,
+        addListToDataLibrary,
+        deleteListFromDataLibrary,
+        clearLibrary,
+        setAllListsInDataLibrary,
+        updateListInDataLibrary
+    };
+};
+
+const initialState$1 = {};
+const dataLibrarySlice = toolkit.createSlice({
+    name: 'dataLibrary',
+    initialState: initialState$1,
+    reducers: {
+        setDataLibraryListSelection: (state, action)=>{
+            const { listId, itemIds } = action.payload;
+            state[listId] = itemIds;
+        },
+        clearDataLibrarySelection: ()=>{
+            return initialState$1;
+        }
+    }
+});
+const { setDataLibraryListSelection, clearDataLibrarySelection } = dataLibrarySlice.actions;
+const dataLibrarySelectionReducer = dataLibrarySlice.reducer;
+// Selector
+const selectDataLibrary = (state)=>state.dataLibrarySelection;
+// Memoized selector for getting data library items for a specific root object
+toolkit.createSelector([
+    selectDataLibrary,
+    (_, rootObjectId)=>rootObjectId
+], (dataLibrary, rootObjectId)=>dataLibrary[rootObjectId] || []);
+
 exports.WorkspaceStatus = void 0;
 (function(WorkspaceStatus) {
     WorkspaceStatus["Launching"] = "Launching";
@@ -909,1127 +1551,1268 @@ const guppyAPISliceMiddleware = guppyApi.middleware;
 const guppyApiSliceReducerPath = guppyApi.reducerPath;
 const guppyApiReducer = guppyApi.reducer;
 
-const rootReducer = toolkit.combineReducers({
-    gen3Services: gen3ServicesReducer,
-    user: userReducer,
-    gen3Apps: gen3AppReducer,
-    drsHostnames: drsHostnamesReducer,
-    modals: modalReducer,
-    cohorts: cohortReducer,
-    activeWorkspace: activeWorkspaceReducer,
-    [guppyApiSliceReducerPath]: guppyApiReducer,
-    [userAuthApiReducerPath]: userAuthApiReducer
-});
-
-const coreStore = toolkit.configureStore({
-    reducer: rootReducer,
-    middleware: (getDefaultMiddleware)=>getDefaultMiddleware().concat(gen3ServicesReducerMiddleware, guppyAPISliceMiddleware, userAuthApiMiddleware)
-});
-query.setupListeners(coreStore.dispatch);
-
-const CoreProvider = ({ children })=>{
-    return /*#__PURE__*/ React.createElement(reactRedux.Provider, {
-        store: coreStore
-    }, children);
+const isOperationWithField = (operation)=>{
+    return operation?.field !== undefined;
 };
-
-/**
- * Creates the authzApi for checking arborist permissions for a selected user
- * @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/arborist/master/docs/openapi.yaml#/auth/get_auth_mapping
- * @see https://github.com/uc-cdis/arborist/blob/master/docs/relationships.simplified.png
- * @returns: An arborist response dict of user permissions {method, service} for each resource path.
- */ const authzApi = gen3Api.injectEndpoints({
-    endpoints: (builder)=>({
-            getAuthzMappings: builder.query({
-                query: ()=>`${GEN3_AUTHZ_API}/mapping`
-            })
-        })
-});
-const { useGetAuthzMappingsQuery } = authzApi;
-const selectAuthzMapping = authzApi.endpoints.getAuthzMappings.select();
-const selectAuthzMappingData = toolkit.createSelector(selectAuthzMapping, (authzMapping)=>authzMapping?.data ?? {
-        mappings: []
-    });
-
-const HasEnoughData = (data, keys, limit)=>{
-    const numEmptyKeys = keys.filter((k)=>Object.hasOwn(data, k) && typeof data[k] === 'string' && data[k].trim() === '').length;
-    return numEmptyKeys < limit;
+const extractFilterValue = (op)=>{
+    const valueExtractorHandler = new ValueExtractorHandler();
+    return handleOperation(valueExtractorHandler, op);
+};
+const extractEnumFilterValue = (op)=>{
+    const enumValueExtractorHandler = new EnumValueExtractorHandler();
+    const results = handleOperation(enumValueExtractorHandler, op);
+    return results ?? [];
+};
+const assertNever = (x)=>{
+    throw Error(`Exhaustive comparison did not handle: ${x}`);
+};
+const handleOperation = (handler, op)=>{
+    switch(op.operator){
+        case '=':
+            return handler.handleEquals(op);
+        case '!=':
+            return handler.handleNotEquals(op);
+        case '<':
+            return handler.handleLessThan(op);
+        case '<=':
+            return handler.handleLessThanOrEquals(op);
+        case '>':
+            return handler.handleGreaterThan(op);
+        case '>=':
+            return handler.handleGreaterThanOrEquals(op);
+        case 'and':
+            return handler.handleIntersection(op);
+        case 'or':
+            return handler.handleUnion(op);
+        case 'nested':
+            return handler.handleNestedFilter(op);
+        case 'in':
+            return handler.handleIncludes(op);
+        case 'excludeifany':
+            return handler.handleExcludeIfAny(op);
+        case 'excludes':
+            return handler.handleExcludes(op);
+        default:
+            return assertNever(op);
+    }
 };
 /**
- * Defines metadataApi service using a base URL and expected endpoints. Derived from gen3Api core API.
- *
- * @param endpoints - Defines endpoints used in discovery page
- *  @param getAggMDS - Queries aggregate metadata service
- *    @see https://github.com/uc-cdis/metadata-service/blob/master/docs/agg_mds.md
- *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Aggregate/get_aggregate_metadata_aggregate_metadata_get
- *  @param getMDS - Queries normal metadata service
- *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Query/search_metadata_metadata_get
- *  @param getIndexAggMDS - queries the Aggregate Metadata service and returns all common passed in indexKeys
- *  @param getTags - Probably refering to Aggregate metadata service summary statistics query
- *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Aggregate/get_aggregate_tags_aggregate_tags_get
- *  @param getData - Looks like a duplicate of getMDS handler. unused in ./frontend package
- *  @param getCrosswalkData - Maps ids from one source to another
- * @returns: A guppy download API for fetching bulk metadata
- */ const metadataApi = gen3Api.injectEndpoints({
-    endpoints: (builder)=>({
-            getAggMDS: builder.query({
-                query: ({ offset, pageSize })=>{
-                    return `${GEN3_MDS_API}/aggregate/metadata?flatten=true&pagination=true&offset=${offset}&limit=${pageSize}`;
-                },
-                transformResponse: (response, _meta, params)=>{
-                    return {
-                        data: response.results.map((x)=>{
-                            const objValues = Object.values(x);
-                            const firstValue = objValues ? objValues.at(0) : undefined;
-                            return firstValue ? firstValue[params.studyField] : undefined;
-                        }),
-                        hits: response.pagination.hits
-                    };
+ * Return true if a FilterSet's root value is an empty object
+ * @param fs - FilterSet to test
+ */ const isFilterEmpty = (fs)=>lodash.isEqual({}, fs);
+class ToGqlHandler {
+    constructor(){
+        this.handleEquals = (op)=>({
+                '=': {
+                    [op.field]: op.operand
                 }
-            }),
-            getIndexAggMDS: builder.query({
-                query: ({ pageSize })=>{
-                    return `${GEN3_MDS_API}/aggregate/metadata?limit=${pageSize}`;
-                },
-                transformResponse: (response, _meta, params)=>{
-                    const dataFromIndexes = params.indexKeys.reduce((acc, key)=>{
-                        if (response[key]) {
-                            acc.push(...response[key]);
-                        }
-                        return acc;
-                    }, []);
-                    return {
-                        data: dataFromIndexes.map((x)=>{
-                            const objValues = Object.values(x);
-                            const objIds = Object.keys(x);
-                            let firstValue = objValues ? objValues.at(0) : undefined;
-                            if (params?.filterEmpty) {
-                                // remove any data that has < limit if defined
-                                if (firstValue && !HasEnoughData(firstValue[params.studyField], params.filterEmpty.keys, params.filterEmpty.limit)) firstValue = undefined;
-                            }
-                            return firstValue ? {
-                                gen3MDSGUID: objIds.at(0),
-                                ...firstValue[params.studyField]
-                            } : undefined;
-                        }).filter((x)=>x !== undefined),
-                        hits: dataFromIndexes.length
-                    };
+            });
+        this.handleNotEquals = (op)=>({
+                '!=': {
+                    [op.field]: op.operand
                 }
-            }),
-            getMDS: builder.query({
-                query: ({ guidType, offset, pageSize })=>{
-                    return `${GEN3_MDS_API}/metadata?data=True&_guid_type=${guidType}&limit=${pageSize}&offset=${offset}`;
-                },
-                transformResponse: (response, _meta)=>{
-                    return {
-                        data: Object.keys(response).map((guid)=>response[guid]),
-                        hits: Object.keys(response).length
-                    };
+            });
+        this.handleLessThan = (op)=>({
+                '<': {
+                    [op.field]: op.operand
                 }
-            }),
-            getTags: builder.query({
-                query: ()=>'tags'
-            }),
-            getData: builder.query({
-                query: (params)=>({
-                        url: `metadata?${params}`
-                    })
-            }),
-            // TODO: Move this to own slice
-            getCrosswalkData: builder.query({
-                queryFn: async (arg, _queryApi, _extraOptions, fetchWithBQ)=>{
-                    const queryMultiple = async ()=>{
-                        let result = [];
-                        const queue = Queue({
-                            concurrency: 15
-                        });
-                        for (const id of arg.ids){
-                            queue.push(async (callback)=>{
-                                const response = await fetchWithBQ({
-                                    url: `${GEN3_CROSSWALK_API}/metadata/${id}`
-                                });
-                                if (response.error) {
-                                    return {
-                                        error: response.error
-                                    };
-                                }
-                                const toData = arg.toPaths.reduce((acc, path)=>{
-                                    acc[path.id] = jsonpathPlus.JSONPath({
-                                        json: response.data,
-                                        path: `$.[${path.dataPath}]`,
-                                        resultType: 'value'
-                                    })?.[0] ?? 'n/a';
-                                    return acc;
-                                }, {});
-                                result = [
-                                    ...result,
-                                    {
-                                        from: id,
-                                        to: toData
-                                    }
-                                ];
-                                if (callback) callback();
-                                return result;
-                            });
-                        }
-                        return new Promise((resolve, reject)=>{
-                            queue.start((err)=>{
-                                if (err) {
-                                    reject(err);
-                                } else {
-                                    resolve(result);
-                                }
-                            });
-                        });
-                    };
-                    const result = await queryMultiple();
-                    return {
-                        data: result
-                    };
+            });
+        this.handleLessThanOrEquals = (op)=>({
+                '<=': {
+                    [op.field]: op.operand
                 }
-            })
-        })
-});
-const { useGetAggMDSQuery, useGetMDSQuery, useGetTagsQuery, useGetDataQuery, useGetCrosswalkDataQuery, useLazyGetCrosswalkDataQuery, useGetIndexAggMDSQuery } = metadataApi;
-
-// using a random uuid v4 as the namespace
-const GEN3_APP_NAMESPACE = '7bfaa818-c69c-457e-8d87-413cf60c25f0';
-
-const getGen3AppId = (name, version)=>{
-    const nameVersion = `${name}::${version}`;
-    return uuid.v5(nameVersion, GEN3_APP_NAMESPACE);
-};
-/**
- *  Creates a Gen3App that is dynamically loaded
- */ const createGen3App = ({ App, name, version, requiredEntityTypes })=>{
-    // create a stable id for this app
-    const nameVersion = `${name}::${version}`;
-    const id = uuid.v5(nameVersion, GEN3_APP_NAMESPACE);
-    // need to create store and provider.
-    // return a component representing this app
-    // if component gets added to a list, then the list can be iterated in index.js and each provider component can be added
-    // a route can be setup for the app
-    // need to register its name, category, path, data requirements
-    // this will be used to build page3
-    // click app link
-    // const store = configureStore({
-    //   // TODO allow user to pass in a reducer in CreateGen3AppOptions?
-    //   reducer: (state) => state,
-    //   devTools: {
-    //     name: `${nameVersion}::${id}`,
-    //   },
-    // });
-    const Gen3AppWrapper = (props)=>{
-        React.useEffect(()=>{
-            document.title = `GEN3 - ${name}`;
-        });
-        return /*#__PURE__*/ React.createElement(App, props);
-    };
-    // add the app to the store
-    coreStore.dispatch(addGen3AppMetadata({
-        id,
-        name,
-        version,
-        requiredEntityTypes
-    }));
-    registerGen3App(name, Gen3AppWrapper);
-    return Gen3AppWrapper;
-};
-// ----------------------------------------------------------------------------------------
-// Apps with Local Storage
-//
-const createAppStore = (options)=>{
-    const { name, version, reducers, middleware } = options;
-    const nameVersion = `${name}::${version}`;
-    const id = uuid.v5(nameVersion, GEN3_APP_NAMESPACE);
-    const store = toolkit.configureStore({
-        reducer: reducers,
-        devTools: {
-            name: `${nameVersion}::${id}`
-        },
-        middleware: (getDefaultMiddleware)=>middleware ? getDefaultMiddleware({
-                serializableCheck: {
-                    ignoredActions: [
-                        reduxPersist.FLUSH,
-                        reduxPersist.REHYDRATE,
-                        reduxPersist.PAUSE,
-                        reduxPersist.PERSIST,
-                        reduxPersist.PURGE,
-                        reduxPersist.REGISTER
-                    ]
+            });
+        this.handleGreaterThan = (op)=>({
+                '>': {
+                    [op.field]: op.operand
                 }
-            }).concat(middleware) : getDefaultMiddleware({
-                serializableCheck: {
-                    ignoredActions: [
-                        reduxPersist.FLUSH,
-                        reduxPersist.REHYDRATE,
-                        reduxPersist.PAUSE,
-                        reduxPersist.PERSIST,
-                        reduxPersist.PURGE,
-                        reduxPersist.REGISTER
-                    ]
+            });
+        this.handleGreaterThanOrEquals = (op)=>({
+                '>=': {
+                    [op.field]: op.operand
                 }
-            })
-    });
-    const context = /*#__PURE__*/ React.createContext(null);
-    const useAppSelector = reactRedux.createSelectorHook(context);
-    const useAppDispatch = reactRedux.createDispatchHook(context);
-    const useAppStore = reactRedux.createStoreHook(context);
-    return {
-        id: id,
-        AppStore: store,
-        AppContext: context,
-        useAppSelector: useAppSelector,
-        useAppDispatch: useAppDispatch,
-        useAppStore: useAppStore
-    };
-};
-const createGen3AppWithOwnStore = (options)=>{
-    const { App, id, name, version, requiredEntityTypes, store, context } = options;
-    // need to create store and provider.
-    // return a component representing this app
-    // if component gets added to a list, then the list can be iterated in index.js and each provider component can be added
-    // a route can be setup for the app
-    // need to register its name, category, path, data requirements
-    // this will be used to build page3
-    // click app link
-    const Gen3AppWrapper = (props)=>{
-        React.useEffect(()=>{
-            document.title = `GEN3 - ${name}`;
-        });
-        return /*#__PURE__*/ React.createElement(reactRedux.Provider, {
-            store: store,
-            context: context
-        }, /*#__PURE__*/ React.createElement(reactCookie.CookiesProvider, null, /*#__PURE__*/ React.createElement(App, props)));
-    };
-    // add the app to the store
-    coreStore.dispatch(addGen3AppMetadata({
-        id,
-        name,
-        version,
-        requiredEntityTypes
-    }));
-    registerGen3App(name, Gen3AppWrapper);
-    return Gen3AppWrapper;
-};
-
-const createAppApiForRTKQ = (reducerPath, baseQuery)=>{
-    const appContext = React__namespace.createContext(null);
-    const useAppSelector = reactRedux.useSelector.withTypes();
-    const useAppDispatch = reactRedux.createDispatchHook(appContext);
-    const useAppStore = reactRedux.createStoreHook(appContext);
-    const appCreateApi = react.buildCreateApi(react.coreModule(), react.reactHooksModule({
-        hooks: {
-            useDispatch: useAppDispatch,
-            useSelector: useAppSelector,
-            useStore: useAppStore
-        }
-    }));
-    const appRTKQApi = appCreateApi({
-        reducerPath: reducerPath,
-        baseQuery: baseQuery ?? react.fetchBaseQuery({
-            baseUrl: `${GEN3_API}`,
-            prepareHeaders: (headers)=>{
-                headers.set('Content-Type', 'application/json');
-                let accessToken = undefined;
-                if (process.env.NODE_ENV === 'development') {
-                    // NOTE: This cookie can only be accessed from the client side
-                    // in development mode. Otherwise, the cookie is set as httpOnly
-                    accessToken = cookiesNext.getCookie('credentials_token');
+            });
+        this.handleIncludes = (op)=>({
+                in: {
+                    [op.field]: op.operands
                 }
-                if (accessToken) headers.set('Authorization', `Bearer ${accessToken}`);
-                return headers;
-            }
-        }),
-        endpoints: ()=>({})
-    });
-    const appMiddleware = appRTKQApi.middleware;
-    const appStore = toolkit.configureStore({
-        reducer: {
-            [appRTKQApi.reducerPath]: appRTKQApi.reducer
-        },
-        middleware: (getDefaultMiddleware)=>getDefaultMiddleware({
-                serializableCheck: {
-                    ignoredActions: [
-                        reduxPersist.FLUSH,
-                        reduxPersist.REHYDRATE,
-                        reduxPersist.PAUSE,
-                        reduxPersist.PERSIST,
-                        reduxPersist.PURGE,
-                        reduxPersist.REGISTER
-                    ]
+            });
+        this.handleExcludes = (op)=>({
+                exclude: {
+                    [op.field]: op.operands
                 }
-            }).concat(appMiddleware)
-    });
-    return {
-        useAppSelector: useAppSelector,
-        useAppDispatch: useAppDispatch,
-        useAppStore: useAppStore,
-        AppContext: appContext,
-        appApi: appRTKQApi,
-        appContext: appContext,
-        appStore: appStore
+            });
+        this.handleExcludeIfAny = (op)=>({
+                excludeifany: {
+                    [op.field]: op.operands
+                }
+            });
+        this.handleIntersection = (op)=>({
+                and: op.operands.map((x)=>convertFilterToGqlFilter(x))
+            });
+        this.handleUnion = (op)=>({
+                or: op.operands.map((x)=>convertFilterToGqlFilter(x))
+            });
+        this.handleNestedFilter = (op)=>{
+            const child = convertFilterToGqlFilter(op.operand);
+            return {
+                nested: {
+                    path: op.path,
+                    ...child
+                }
+            };
+        };
+    }
+}
+const convertFilterToGqlFilter = (filter)=>{
+    const handler = new ToGqlHandler();
+    return handleOperation(handler, filter);
+};
+const convertFilterSetToGqlFilter = (fs, toplevelOp = 'and')=>{
+    const fsKeys = Object.keys(fs.root);
+    // if no keys return undefined
+    if (fsKeys.length === 0) return {
+        and: []
+    };
+    return toplevelOp === 'and' ? {
+        and: fsKeys.map((key)=>convertFilterToGqlFilter(fs.root[key]))
+    } : {
+        or: fsKeys.map((key)=>convertFilterToGqlFilter(fs.root[key]))
     };
 };
-
-const graphQLWithTags = gen3Api.enhanceEndpoints({
-    addTagTypes: [
-        'graphQL'
-    ]
-});
 /**
- * Creates a graphQLAPI for graphql queries to elasticsearch indices via guppy
- * @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md
- * @param query - Resolver function which configures the graphql query with graphQLParams argument
- * @returns: A guppy search API for fetching metadata
- */ const graphQLAPI = graphQLWithTags.injectEndpoints({
-    endpoints: (builder)=>({
-            graphQL: builder.query({
-                query: (graphQLParams)=>({
-                        url: `${GEN3_GUPPY_API}/graphql`,
-                        method: 'POST',
-                        credentials: 'include',
-                        body: JSON.stringify(graphQLParams)
-                    })
-            })
-        })
-});
-const { useGraphQLQuery } = graphQLAPI;
+ * Extract the operand values, if operands themselves have values,  otherwise undefined.
+ */ class ValueExtractorHandler {
+    constructor(){
+        this.handleEquals = (op)=>op.operand;
+        this.handleNotEquals = (op)=>op.operand;
+        this.handleIncludes = (op)=>op.operands;
+        this.handleExcludes = (op)=>op.operands;
+        this.handleExcludeIfAny = (op)=>op.operands;
+        this.handleGreaterThanOrEquals = (op)=>op.operand;
+        this.handleGreaterThan = (op)=>op.operand;
+        this.handleLessThan = (op)=>op.operand;
+        this.handleLessThanOrEquals = (op)=>op.operand;
+        this.handleIntersection = (_arg)=>undefined;
+        this.handleUnion = (_)=>undefined;
+        this.handleNestedFilter = (_)=>undefined;
+    }
+}
+/**
+ * Extract the operand values, if operands themselves have values,  otherwise undefined.
+ */ class EnumValueExtractorHandler {
+    constructor(){
+        this.handleEquals = (_)=>undefined;
+        this.handleNotEquals = (_)=>undefined;
+        this.handleIncludes = (op)=>op.operands;
+        this.handleExcludes = (op)=>op.operands;
+        this.handleExcludeIfAny = (op)=>op.operands;
+        this.handleGreaterThanOrEquals = (_)=>undefined;
+        this.handleGreaterThan = (_)=>undefined;
+        this.handleLessThan = (_)=>undefined;
+        this.handleLessThanOrEquals = (_)=>undefined;
+        this.handleIntersection = (_)=>undefined;
+        this.handleUnion = (_)=>undefined;
+        this.handleNestedFilter = (op)=>{
+            return extractEnumFilterValue(op.operand);
+        };
+    }
+}
 
-const isOperationWithField = (operation)=>{
-    return operation?.field !== undefined;
+const isFilterSet = (input)=>{
+    if (typeof input !== 'object' || input === null) {
+        return false;
+    }
+    const { root, mode } = input;
+    if (typeof root !== 'object' || root === null) {
+        return false;
+    }
+    if (![
+        'and',
+        'or'
+    ].includes(mode)) {
+        return false;
+    }
+    return true;
 };
-const extractFilterValue = (op)=>{
-    const valueExtractorHandler = new ValueExtractorHandler();
-    return handleOperation(valueExtractorHandler, op);
+
+const FieldNameOverrides = {};
+const COMMON_PREPOSITIONS = [
+    'a',
+    'an',
+    'and',
+    'at',
+    'but',
+    'by',
+    'for',
+    'in',
+    'is',
+    'nor',
+    'of',
+    'on',
+    'or',
+    'out',
+    'so',
+    'the',
+    'to',
+    'up',
+    'yet'
+];
+const capitalize = (s)=>s.length > 0 ? s[0].toUpperCase() + s.slice(1) : '';
+const trimFirstFieldNameToTitle = (fieldName, trim = false)=>{
+    if (trim) {
+        const source = fieldName.slice(fieldName.indexOf('.') + 1);
+        return fieldNameToTitle(source ? source : fieldName, 0);
+    }
+    return fieldNameToTitle(fieldName);
+};
+/**
+ * Converts a filter name to a title,
+ * For example files.input.experimental_strategy will get converted to Experimental Strategy
+ * if sections == 2 then the output would be Input Experimental Strategy
+ * @param fieldName input filter expected to be: string.firstpart_secondpart
+ * @param sections number of "sections" string.string.string to got back from the end of the field
+ */ const fieldNameToTitle = (fieldName, sections = 1)=>{
+    if (fieldName in FieldNameOverrides) {
+        return FieldNameOverrides[fieldName];
+    }
+    if (fieldName === undefined) return 'No Title';
+    return fieldName.split('.').slice(-sections).map((s)=>s.split('_')).flat().map((word)=>COMMON_PREPOSITIONS.includes(word) ? word : capitalize(word)).join(' ');
+};
+/**
+ * Extracts the index name from the field name
+ * @param fieldName
+ */ const extractIndexFromFullFieldName = (fieldName)=>fieldName.split('.')[0];
+/**
+ * prepend the index name to the field name
+ */ const prependIndexToFieldName = (fieldName, index)=>`${index}.${fieldName}`;
+/**
+ * extract the field name from the index.field name
+ */ const extractFieldNameFromFullFieldName = (fieldName)=>fieldName.split('.').slice(1).join('.');
+/**
+ * extract the field name and the index from the index.field name returning as a tuple
+ */ const extractIndexAndFieldNameFromFullFieldName = (fieldName)=>{
+    const [index, ...rest] = fieldName.split('.');
+    return [
+        index,
+        rest.join('.')
+    ];
+};
+
+const statusEndpoint = '/_status';
+const processHistogramResponse = (data)=>{
+    const valueData = jsonpathPlus.JSONPath({
+        json: data,
+        path: '$..histogram',
+        resultType: 'value'
+    });
+    const pointerData = jsonpathPlus.JSONPath({
+        json: data,
+        path: '$..histogram',
+        resultType: 'pointer'
+    });
+    const results = pointerData.reduce((acc, element, idx)=>{
+        const key = element.slice(1).replace(/\/histogram/g, '').replace(/\//g, '.');
+        return {
+            ...acc,
+            [key]: valueData[idx]
+        };
+    }, {});
+    return results;
+};
+const fetchJson = async (url)=>{
+    const res = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Content-type': 'application/json'
+        }
+    });
+    if (!res.ok) throw new Error('An error occurred while fetching the data.');
+    return await res.json();
+};
+const useGetStatus = ()=>{
+    const fetcher = ()=>fetchJson(`${GEN3_GUPPY_API}${statusEndpoint}`);
+    return useSWR('explorerStatus', fetcher);
+};
+/**
+ * The main endpoint used in templating Exploration page queries.
+ * Includes table, filter and aggregation query types and leverages guppyApi defined in ./gupplApi.ts
+ * Query templates support filters where applicable
+ *
+ * @param endpoints - Defines endpoints used in Exploration page:
+ * @param getAllFieldsForType - A mapping query that returns all property key names vertex types specified.
+ *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#mapping-query
+ * @param getAccessibleData - An aggregation histogram counts query that filters based on access type
+ *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#accessibility-argument-for-regular-tier-access-level
+ * @param getRawDataAndTotalCounts - Queries both _totalCount for selected vertex types and
+ * tabular results containing the raw data in the rows of selected vertex types
+ *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#1-total-count-aggregation
+ * @param getAggs - An aggregated histogram counts query which outputs vertex property frequencies
+ * @param getSubAggs - TODO: not sure what this one does. Looks like nested aggregation
+ * @param getCounts - Returns total counts of a vertex type
+ * @returns: A guppy API endpoint for templating queriable data displayed on the exploration page
+ */ const explorerApi = guppyApi.injectEndpoints({
+    endpoints: (builder)=>({
+            getAllFieldsForType: builder.query({
+                query: (type)=>({
+                        query: `{ _mapping ${type} } }`
+                    }),
+                transformResponse: (response, _meta, params)=>{
+                    return response[params.type];
+                }
+            }),
+            getAccessibleData: builder.query({
+                query: ({ type, fields, accessType })=>{
+                    const fieldParts = fields.map((field)=>`${field} { histogram { key count } }`);
+                    return {
+                        query: `_aggregation {
+              ${type} (accessibility: ${accessType}) {
+                ${fieldParts.join(',')}
+              }
+            }`
+                    };
+                }
+            }),
+            getRawDataAndTotalCounts: builder.query({
+                query: ({ type, fields, filters, sort, offset = 0, size = 20, accessibility = exports.Accessibility.ALL, format = undefined })=>{
+                    const gqlFilter = convertFilterSetToGqlFilter(filters);
+                    const params = [
+                        ...sort ? [
+                            '$sort: JSON'
+                        ] : [],
+                        ...gqlFilter ? [
+                            '$filter: JSON'
+                        ] : [],
+                        ...format ? [
+                            '$format: Format'
+                        ] : []
+                    ].join(',');
+                    const queryLine = `query getRawDataAndTotalCounts (${params}) {`;
+                    const dataParams = [
+                        ...format ? [
+                            'format: $format'
+                        ] : [],
+                        ...sort ? [
+                            'sort: $sort'
+                        ] : [],
+                        ...gqlFilter ? [
+                            'filter: $filter'
+                        ] : []
+                    ].join(',');
+                    const dataTypeLine = `${type} (accessibility: ${accessibility}, offset: ${offset}, first: ${size},
+        ${dataParams}) {`;
+                    const typeAggsLine = `${type} (${gqlFilter && 'filter: $filter,'} accessibility: ${accessibility}) {`;
+                    const processedFields = fields.map((field)=>rawDataQueryStrForEachField(field));
+                    const query = `${queryLine}
+    ${dataTypeLine}
+      ${processedFields.join(' ')}
+            }
+            _aggregation {
+              ${typeAggsLine}
+                _totalCount
+              }
+            }
+        }`;
+                    const variables = {
+                        ...sort && {
+                            sort
+                        },
+                        ...gqlFilter && {
+                            filter: gqlFilter
+                        },
+                        ...format && {
+                            format
+                        }
+                    };
+                    return {
+                        query,
+                        variables
+                    };
+                }
+            }),
+            getAggs: builder.query({
+                query: ({ type, fields, filters, accessibility = exports.Accessibility.ALL })=>{
+                    const queryStart = isFilterEmpty(filters) ? `
+              query getAggs {
+              _aggregation {
+              ${type} (accessibility: ${accessibility}) {` : `query getAggs ($filter: JSON) {
+               _aggregation {
+                      ${type} (filter: $filter, filterSelf: false, accessibility: ${accessibility}) {`;
+                    const query = `${queryStart}
+                  ${fields.map((field)=>histogramQueryStrForEachField(field))}
+                }
+              }
+            }`;
+                    const queryBody = {
+                        query: query,
+                        variables: {
+                            filter: convertFilterSetToGqlFilter(filters)
+                        }
+                    };
+                    return queryBody;
+                },
+                transformResponse: (response, _meta, args)=>{
+                    return processHistogramResponse(response.data._aggregation[args.type]);
+                }
+            }),
+            getSubAggs: builder.query({
+                query: ({ type, mainField, termsFields = undefined, missingFields = undefined, numericAggAsText = false, gqlFilter = undefined, accessibility = exports.Accessibility.ALL })=>{
+                    const nestedAggFields = {
+                        termsFields: termsFields,
+                        missingFields: missingFields
+                    };
+                    const query = `query getSubAggs ( ${gqlFilter ?? '$filter: JSON,'} $nestedAggFields: JSON) {
+    _aggregation {
+      ${type} ( ${gqlFilter ?? 'filter: $filter, filterSelf: false,'} nestedAggFields: $nestedAggFields, accessibility: ${accessibility}) {
+        ${nestedHistogramQueryStrForEachField(mainField, numericAggAsText)}
+      }`;
+                    return {
+                        query: query,
+                        variables: {
+                            ...gqlFilter && {
+                                filter: convertFilterSetToGqlFilter(gqlFilter)
+                            },
+                            nestedAggFields: nestedAggFields
+                        }
+                    };
+                },
+                transformResponse: (response, _meta, args)=>{
+                    return processHistogramResponse(response.data._aggregation[args.type]);
+                }
+            }),
+            getCounts: builder.query({
+                query: ({ type, filters, accessibility = exports.Accessibility.ALL })=>{
+                    const gqlFilters = convertFilterSetToGqlFilter(filters);
+                    const queryLine = `query totalCounts ${gqlFilters ? '($filter: JSON)' : ''}{`;
+                    const typeAggsLine = `${type} ${gqlFilters ? '(filter: $filter, ' : '('} accessibility: ${accessibility}) {`;
+                    const query = `${queryLine} _aggregation {
+          ${typeAggsLine}
+            _totalCount
+            }
+           }
+        }`;
+                    return {
+                        query: query,
+                        variables: {
+                            ...gqlFilters && {
+                                filter: gqlFilters
+                            }
+                        }
+                    };
+                },
+                transformResponse: (response, _meta, args)=>{
+                    return response.data._aggregation[args.type]._totalCount;
+                }
+            }),
+            getFieldCountSummary: builder.query({
+                query: ({ type, field, filters, accessibility = exports.Accessibility.ALL })=>{
+                    const gqlFilters = convertFilterSetToGqlFilter(filters);
+                    const query = `query summary ($filter: JSON) {
+        _aggregation {
+          ${type} (filter: $filter, accessibility: ${accessibility}) {
+            ${field} {
+              histogram {
+                sum,
+              }
+            }
+          }
+        }
+      }`;
+                    return {
+                        query: query,
+                        variables: {
+                            ...gqlFilters && {
+                                filter: gqlFilters
+                            }
+                        }
+                    };
+                }
+            }),
+            getFieldsForIndex: builder.query({
+                query: (index)=>{
+                    return {
+                        query: `{
+            _mapping ${index}
+          }`
+                    };
+                },
+                transformResponse: (response)=>{
+                    return response['_mapping'];
+                }
+            }),
+            generalGQL: builder.query({
+                query: ({ query, variables })=>{
+                    return {
+                        query: query,
+                        variables: variables
+                    };
+                }
+            })
+        })
+});
+// query for aggregate data
+// convert the function below to typescript
+const histogramQueryStrForEachField = (field)=>{
+    const splittedFieldArray = field.split('.');
+    const splittedField = splittedFieldArray.shift();
+    if (splittedFieldArray.length === 0) {
+        return `
+    ${splittedField} {
+      histogram {
+        key
+        count
+      }
+    }`;
+    }
+    return `
+  ${splittedField} {
+    ${histogramQueryStrForEachField(splittedFieldArray.join('.'))}
+  }`;
 };
-const extractEnumFilterValue = (op)=>{
-    const enumValueExtractorHandler = new EnumValueExtractorHandler();
-    const results = handleOperation(enumValueExtractorHandler, op);
-    return results ?? [];
+const nestedHistogramQueryStrForEachField = (mainField, numericAggAsText)=>`
+  ${mainField} {
+    ${numericAggAsText ? 'asTextHistogram' : 'histogram'} {
+      key
+      count
+      missingFields {
+        field
+        count
+      }
+      termsFields {
+        field
+        count
+        terms {
+          key
+          count
+        }
+      }
+    }
+  }`;
+const rawDataQueryStrForEachField = (field)=>{
+    const splitFieldArray = field.split('.');
+    const splitField = splitFieldArray.shift();
+    if (splitFieldArray.length === 0) {
+        return `
+    ${splitField}
+    `;
+    }
+    return `
+  ${splitField} {
+    ${rawDataQueryStrForEachField(splitFieldArray.join('.'))}
+  }`;
 };
-const assertNever = (x)=>{
-    throw Error(`Exhaustive comparison did not handle: ${x}`);
+const useGetArrayTypes = ()=>{
+    {
+        const { data, error } = useGetStatus();
+        if (error) {
+            return {};
+        }
+        return data ? data['indices'] : {};
+    }
 };
-const handleOperation = (handler, op)=>{
-    switch(op.operator){
-        case '=':
-            return handler.handleEquals(op);
-        case '!=':
-            return handler.handleNotEquals(op);
-        case '<':
-            return handler.handleLessThan(op);
-        case '<=':
-            return handler.handleLessThanOrEquals(op);
-        case '>':
-            return handler.handleGreaterThan(op);
-        case '>=':
-            return handler.handleGreaterThanOrEquals(op);
-        case 'and':
-            return handler.handleIntersection(op);
-        case 'or':
-            return handler.handleUnion(op);
-        case 'nested':
-            return handler.handleNestedFilter(op);
-        case 'in':
-            return handler.handleIncludes(op);
-        case 'excludeifany':
-            return handler.handleExcludeIfAny(op);
-        case 'excludes':
-            return handler.handleExcludes(op);
-        default:
-            return assertNever(op);
+const { useGetRawDataAndTotalCountsQuery, useGetAccessibleDataQuery, useGetAllFieldsForTypeQuery, useGetAggsQuery, useLazyGetAggsQuery, useGetSubAggsQuery, useGetCountsQuery, useGetFieldCountSummaryQuery, useGetFieldsForIndexQuery, useGeneralGQLQuery, useLazyGeneralGQLQuery } = explorerApi;
+
+/**
+ * Flattens a deep nested JSON object skipping
+ * the first level to avoid potentially flattening
+ * non-nested data.
+ * @param {JSON} json
+ */ function flattenJson(json) {
+    const flattenedJson = [];
+    Object.keys(json).forEach((key)=>{
+        flattenedJson.push(flat.flatten(json[key], {
+            delimiter: '_'
+        }));
+    });
+    return flattenedJson;
+}
+/**
+ * Converts JSON based on a config.
+ * @param {JSON} json
+ * @param {Object} config
+ */ async function conversion(json, config) {
+    return Papa.unparse(json, config);
+}
+/**
+ * Converts JSON to a specified file format.
+ * Defaults to JSON if file format is not supported.
+ * @param {JSON} json
+ * @param {string} format
+ */ async function jsonToFormat(json, format) {
+    if (Object.keys(FILE_DELIMITERS).includes(format)) {
+        const flatJson = await flattenJson(json);
+        const data = await conversion(flatJson, {
+            delimiter: FILE_DELIMITERS[format]
+        });
+        return data;
     }
+    return json;
+}
+
+/**
+ * Prepares a URL for downloading by appending '/download' to the provided apiUrl.
+ *
+ * @param {string} apiUrl - The base URL to be used for preparing the download URL.
+ * @returns {URL} - The prepared download URL as a URL object.
+ */ const prepareUrl$1 = (apiUrl)=>new URL(apiUrl + '/download');
+/**
+ * Prepares a fetch configuration object for downloading files from Guppy.
+ *
+ * @param {GuppyFileDownloadRequestParams} parameters - The parameters to include in the request body.
+ * @param {string} csrfToken - The CSRF token to include in the request headers.
+ * @returns {FetchConfig} - The prepared fetch configuration object.
+ */ const prepareFetchConfig = (parameters, csrfToken)=>{
+    return {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...csrfToken !== undefined && {
+                'X-CSRF-Token': csrfToken
+            }
+        },
+        body: JSON.stringify({
+            type: parameters.type,
+            filter: convertFilterSetToGqlFilter(parameters.filter),
+            accessibility: parameters.accessibility,
+            fields: parameters?.fields,
+            sort: parameters?.sort
+        })
+    };
 };
 /**
- * Return true if a FilterSet's root value is an empty object
- * @param fs - FilterSet to test
- */ const isFilterEmpty = (fs)=>lodash.isEqual({}, fs);
-class ToGqlHandler {
-    constructor(){
-        this.handleEquals = (op)=>({
-                '=': {
-                    [op.field]: op.operand
-                }
-            });
-        this.handleNotEquals = (op)=>({
-                '!=': {
-                    [op.field]: op.operand
-                }
-            });
-        this.handleLessThan = (op)=>({
-                '<': {
-                    [op.field]: op.operand
-                }
-            });
-        this.handleLessThanOrEquals = (op)=>({
-                '<=': {
-                    [op.field]: op.operand
-                }
-            });
-        this.handleGreaterThan = (op)=>({
-                '>': {
-                    [op.field]: op.operand
-                }
-            });
-        this.handleGreaterThanOrEquals = (op)=>({
-                '>=': {
-                    [op.field]: op.operand
-                }
-            });
-        this.handleIncludes = (op)=>({
-                in: {
-                    [op.field]: op.operands
-                }
-            });
-        this.handleExcludes = (op)=>({
-                exclude: {
-                    [op.field]: op.operands
-                }
-            });
-        this.handleExcludeIfAny = (op)=>({
-                excludeifany: {
-                    [op.field]: op.operands
-                }
-            });
-        this.handleIntersection = (op)=>({
-                and: op.operands.map((x)=>convertFilterToGqlFilter(x))
+ * Downloads a file from Guppy using the provided parameters.
+ * It will optionally convert the data to the specified format.
+ *
+ * @param {DownloadFromGuppyParams} parameters - The parameters to use for the download request.
+ * @param onStart - The function to call when the download starts.
+ * @param onDone - The function to call when the download is done.
+ * @param onError - The function to call when the download fails.
+ * @param onAbort - The function to call when the download is aborted.
+ * @param signal - AbortSignal to use for the request.
+ */ const downloadFromGuppyToBlob = async ({ parameters, onStart = ()=>null, onDone = (_)=>null, onError = (_)=>null, onAbort = ()=>null, signal = undefined })=>{
+    const csrfToken = selectCSRFToken(coreStore.getState());
+    onStart?.();
+    const url = prepareUrl$1(GEN3_GUPPY_API);
+    const fetchConfig = prepareFetchConfig(parameters, csrfToken);
+    fetch(url.toString(), {
+        ...fetchConfig,
+        ...signal ? {
+            signal: signal
+        } : {}
+    }).then(async (response)=>{
+        if (!response.ok) {
+            throw new Error(response.statusText);
+        }
+        let jsonData = await response.json();
+        if (parameters?.rootPath && parameters.rootPath) {
+            // if rootPath is provided, extract the data from the rootPath
+            jsonData = jsonpathPlus.JSONPath({
+                json: jsonData,
+                path: `$.[${parameters.rootPath}]`,
+                resultType: 'value'
             });
-        this.handleUnion = (op)=>({
-                or: op.operands.map((x)=>convertFilterToGqlFilter(x))
+        }
+        // convert the data to the specified format and return a Blob
+        let str = '';
+        if (parameters.format === 'json') {
+            str = JSON.stringify(jsonData);
+        } else {
+            const convertedData = await jsonToFormat(jsonData, parameters.format);
+            if (isJSONObject(convertedData)) {
+                str = JSON.stringify(convertedData, null, 2);
+            } else {
+                str = convertedData;
+            }
+        }
+        return new Blob([
+            str
+        ], {
+            type: 'application/json'
+        });
+    }).then((blob)=>onDone?.(blob)).catch((error)=>{
+        // Abort is handle as an exception
+        if (error.name == 'AbortError') {
+            // handle abort()
+            onAbort?.();
+        }
+        onError?.(error);
+    });
+};
+const downloadJSONDataFromGuppy = async ({ parameters, onAbort = ()=>null, signal = undefined })=>{
+    const csrfToken = selectCSRFToken(coreStore.getState());
+    const url = prepareUrl$1(GEN3_GUPPY_API);
+    const fetchConfig = prepareFetchConfig(parameters, csrfToken);
+    try {
+        const response = await fetch(url.toString(), {
+            ...fetchConfig,
+            ...signal ? {
+                signal: signal
+            } : {}
+        });
+        let jsonData = await response.json();
+        if (parameters?.rootPath && parameters.rootPath) {
+            // if rootPath is provided, extract the data from the rootPath
+            jsonData = jsonpathPlus.JSONPath({
+                json: jsonData,
+                path: `$.[${parameters.rootPath}]`,
+                resultType: 'value'
             });
-        this.handleNestedFilter = (op)=>{
-            const child = convertFilterToGqlFilter(op.operand);
-            return {
-                nested: {
-                    path: op.path,
-                    ...child
-                }
-            };
-        };
+        }
+        // convert the data to the specified format and return a Blob
+        return jsonData;
+    } catch (error) {
+        // Abort is handle as an exception
+        if (error.name == 'AbortError') {
+            // handle abort()
+            onAbort?.();
+        }
+        throw new Error(error);
     }
-}
-const convertFilterToGqlFilter = (filter)=>{
-    const handler = new ToGqlHandler();
-    return handleOperation(handler, filter);
 };
-const convertFilterSetToGqlFilter = (fs, toplevelOp = 'and')=>{
-    const fsKeys = Object.keys(fs.root);
-    // if no keys return undefined
-    if (fsKeys.length === 0) return {
-        and: []
-    };
-    return toplevelOp === 'and' ? {
-        and: fsKeys.map((key)=>convertFilterToGqlFilter(fs.root[key]))
-    } : {
-        or: fsKeys.map((key)=>convertFilterToGqlFilter(fs.root[key]))
-    };
+const useGetIndexFields = (index)=>{
+    const { data } = useGetFieldsForIndexQuery(index);
+    return data ?? [];
 };
+
 /**
- * Extract the operand values, if operands themselves have values,  otherwise undefined.
- */ class ValueExtractorHandler {
-    constructor(){
-        this.handleEquals = (op)=>op.operand;
-        this.handleNotEquals = (op)=>op.operand;
-        this.handleIncludes = (op)=>op.operands;
-        this.handleExcludes = (op)=>op.operands;
-        this.handleExcludeIfAny = (op)=>op.operands;
-        this.handleGreaterThanOrEquals = (op)=>op.operand;
-        this.handleGreaterThan = (op)=>op.operand;
-        this.handleLessThan = (op)=>op.operand;
-        this.handleLessThanOrEquals = (op)=>op.operand;
-        this.handleIntersection = (_arg)=>undefined;
-        this.handleUnion = (_)=>undefined;
-        this.handleNestedFilter = (_)=>undefined;
-    }
-}
-/**
- * Extract the operand values, if operands themselves have values,  otherwise undefined.
- */ class EnumValueExtractorHandler {
-    constructor(){
-        this.handleEquals = (_)=>undefined;
-        this.handleNotEquals = (_)=>undefined;
-        this.handleIncludes = (op)=>op.operands;
-        this.handleExcludes = (op)=>op.operands;
-        this.handleExcludeIfAny = (op)=>op.operands;
-        this.handleGreaterThanOrEquals = (_)=>undefined;
-        this.handleGreaterThan = (_)=>undefined;
-        this.handleLessThan = (_)=>undefined;
-        this.handleLessThanOrEquals = (_)=>undefined;
-        this.handleIntersection = (_)=>undefined;
-        this.handleUnion = (_)=>undefined;
-        this.handleNestedFilter = (op)=>{
-            return extractEnumFilterValue(op.operand);
-        };
-    }
-}
+ * Creates a Guppy API for fetching bulk (> 10K rows) elasticsearch data
+ * @see https://github.com/uc-cdis/guppy/blob/master/doc/download.md
+ * @param endpoints - Resolver function which configures the query with
+ * type, filter, accessibility, fields, and sort arguments
+ * @returns: A guppy download API for fetching bulk metadata
+ */ const downloadRequestApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            downloadFromGuppy: builder.mutation({
+                query: ({ type, filter, accessibility, fields, sort })=>{
+                    const queryBody = {
+                        filter: convertFilterSetToGqlFilter(filter),
+                        ...{
+                            type,
+                            accessibility,
+                            fields,
+                            sort
+                        }
+                    };
+                    return {
+                        url: `${GEN3_GUPPY_API}/download`,
+                        method: 'POST',
+                        queryBody,
+                        cache: 'no-cache'
+                    };
+                },
+                transformResponse: (response)=>{
+                    return response;
+                }
+            })
+        })
+});
+const { useDownloadFromGuppyMutation } = downloadRequestApi;
 
-const FieldNameOverrides = {};
-const COMMON_PREPOSITIONS = [
-    'a',
-    'an',
-    'and',
-    'at',
-    'but',
-    'by',
-    'for',
-    'in',
-    'is',
-    'nor',
-    'of',
-    'on',
-    'or',
-    'out',
-    'so',
-    'the',
-    'to',
-    'up',
-    'yet'
-];
-const capitalize = (s)=>s.length > 0 ? s[0].toUpperCase() + s.slice(1) : '';
-const trimFirstFieldNameToTitle = (fieldName, trim = false)=>{
-    if (trim) {
-        const source = fieldName.slice(fieldName.indexOf('.') + 1);
-        return fieldNameToTitle(source ? source : fieldName, 0);
-    }
-    return fieldNameToTitle(fieldName);
+const rootReducer = toolkit.combineReducers({
+    gen3Services: gen3ServicesReducer,
+    user: userReducer,
+    gen3Apps: gen3AppReducer,
+    drsHostnames: drsHostnamesReducer,
+    modals: modalReducer,
+    cohorts: cohortReducer,
+    activeWorkspace: activeWorkspaceReducer,
+    dataLibrarySelection: dataLibrarySelectionReducer,
+    [guppyApiSliceReducerPath]: guppyApiReducer,
+    [userAuthApiReducerPath]: userAuthApiReducer
+});
+
+const coreStore = toolkit.configureStore({
+    reducer: rootReducer,
+    middleware: (getDefaultMiddleware)=>getDefaultMiddleware().concat(gen3ServicesReducerMiddleware, guppyAPISliceMiddleware, userAuthApiMiddleware)
+});
+query.setupListeners(coreStore.dispatch);
+
+const isNotDefined = (x)=>{
+    return x === undefined || x === null || x === void 0;
 };
-/**
- * Converts a filter name to a title,
- * For example files.input.experimental_strategy will get converted to Experimental Strategy
- * if sections == 2 then the output would be Input Experimental Strategy
- * @param fieldName input filter expected to be: string.firstpart_secondpart
- * @param sections number of "sections" string.string.string to got back from the end of the field
- */ const fieldNameToTitle = (fieldName, sections = 1)=>{
-    if (fieldName in FieldNameOverrides) {
-        return FieldNameOverrides[fieldName];
-    }
-    if (fieldName === undefined) return 'No Title';
-    return fieldName.split('.').slice(-sections).map((s)=>s.split('_')).flat().map((word)=>COMMON_PREPOSITIONS.includes(word) ? word : capitalize(word)).join(' ');
+const isObject = (x)=>{
+    return typeof x === 'object';
 };
-/**
- * Extracts the index name from the field name
- * @param fieldName
- */ const extractIndexFromFullFieldName = (fieldName)=>fieldName.split('.')[0];
-/**
- * prepend the index name to the field name
- */ const prependIndexToFieldName = (fieldName, index)=>`${index}.${fieldName}`;
-/**
- * extract the field name from the index.field name
- */ const extractFieldNameFromFullFieldName = (fieldName)=>fieldName.split('.').slice(1).join('.');
-/**
- * extract the field name and the index from the index.field name returning as a tuple
- */ const extractIndexAndFieldNameFromFullFieldName = (fieldName)=>{
-    const [index, ...rest] = fieldName.split('.');
-    return [
-        index,
-        rest.join('.')
-    ];
+const isArray = (x)=>{
+    return Array.isArray(x);
 };
-
-const statusEndpoint = '/_status';
-const processHistogramResponse = (data)=>{
-    const pathData = jsonpathPlus.JSONPath({
-        json: data,
-        path: '$..histogram',
-        resultType: 'all'
-    });
-    const results = pathData.reduce((acc, element)=>{
-        const key = element.pointer.slice(1).replace(/\/histogram/g, '').replace(/\//g, '.');
-        return {
-            ...acc,
-            [key]: element.value
-        };
-    }, {});
-    return results;
+const isString = (x)=>{
+    return typeof x === 'string';
 };
-const fetchJson = async (url)=>{
-    const res = await fetch(url, {
-        method: 'GET',
-        headers: {
-            'Content-type': 'application/json'
+
+/**
+ * Prepares a URL for downloading by appending '/download' to the provided apiUrl.
+ *
+ * @param {string} apiUrl - The base URL to be used for preparing the download URL.
+ * @returns {URL} - The prepared download URL as a URL object.
+ */ const prepareUrl = (apiUrl)=>new URL(apiUrl + '/download');
+
+const HTTPErrorMessages = {
+    // 4xx Client Errors
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Payload Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: "I'm a teapot",
+    421: 'Misdirected Request',
+    422: 'Unprocessable Entity',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    // 5xx Server Errors
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required'
+};
+const prepareDownloadUrl = (apiUrl, guid)=>new URL(`${apiUrl}/data/download/${guid}`);
+class HTTPError extends Error {
+    constructor(status, message, responseData){
+        super(message), this.status = status, this.responseData = responseData;
+        this.name = 'HTTPError';
+    }
+}
+const fetchFencePresignedURL = async ({ guid, method = 'GET', onAbort = ()=>null, signal = undefined })=>{
+    const csrfToken = selectCSRFToken(coreStore.getState());
+    const headers = new Headers();
+    headers.set('Content-Type', 'application/json');
+    let accessToken = undefined;
+    if (process.env.NODE_ENV === 'development') {
+        // NOTE: This cookie can only be accessed from the client side
+        // in development mode. Otherwise, the cookie is set as httpOnly
+        accessToken = cookiesNext.getCookie('credentials_token');
+    }
+    if (csrfToken) headers.set('X-CSRF-Token', csrfToken);
+    if (accessToken) headers.set('Authorization', `Bearer ${accessToken}`);
+    const url = prepareDownloadUrl(`${GEN3_FENCE_API}/user`, guid);
+    try {
+        const response = await fetch(url.toString(), {
+            method: method,
+            headers: headers,
+            ...signal ? {
+                signal: signal
+            } : {}
+        });
+        // Check if the response is ok before proceeding
+        if (!response.ok) {
+            let errorMessage;
+            let errorData;
+            try {
+                // Attempt to parse error response as JSON
+                errorData = await response.json();
+                errorMessage = errorData.message || response.statusText;
+            } catch  {
+                // If JSON parsing fails, use status text
+                errorMessage = response.statusText;
+            }
+            throw new HTTPError(response.status, errorMessage, errorData);
         }
-    });
-    if (!res.ok) throw new Error('An error occurred while fetching the data.');
-    return await res.json();
+        const jsonData = await response.json();
+        return jsonData;
+    } catch (error) {
+        if (error instanceof Error) {
+            if (error.name === 'AbortError') {
+                onAbort?.();
+            }
+        }
+        throw error;
+    }
 };
-const useGetStatus = ()=>{
-    const fetcher = ()=>fetchJson(`${GEN3_GUPPY_API}${statusEndpoint}`);
-    return useSWR('explorerStatus', fetcher);
+
+const CoreProvider = ({ children })=>{
+    return /*#__PURE__*/ React.createElement(reactRedux.Provider, {
+        store: coreStore
+    }, children);
 };
+
 /**
- * The main endpoint used in templating Exploration page queries.
- * Includes table, filter and aggregation query types and leverages guppyApi defined in ./gupplApi.ts
- * Query templates support filters where applicable
+ * Creates the authzApi for checking arborist permissions for a selected user
+ * @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/arborist/master/docs/openapi.yaml#/auth/get_auth_mapping
+ * @see https://github.com/uc-cdis/arborist/blob/master/docs/relationships.simplified.png
+ * @returns: An arborist response dict of user permissions {method, service} for each resource path.
+ */ const authzApi = gen3Api.injectEndpoints({
+    endpoints: (builder)=>({
+            getAuthzMappings: builder.query({
+                query: ()=>`${GEN3_AUTHZ_API}/mapping`
+            })
+        })
+});
+const { useGetAuthzMappingsQuery } = authzApi;
+const selectAuthzMapping = authzApi.endpoints.getAuthzMappings.select();
+const selectAuthzMappingData = toolkit.createSelector(selectAuthzMapping, (authzMapping)=>authzMapping?.data ?? {
+        mappings: []
+    });
+
+const HasEnoughData = (data, keys, limit)=>{
+    const numEmptyKeys = keys.filter((k)=>Object.hasOwn(data, k) && typeof data[k] === 'string' && data[k].trim() === '').length;
+    return numEmptyKeys < limit;
+};
+/**
+ * Defines metadataApi service using a base URL and expected endpoints. Derived from gen3Api core API.
  *
- * @param endpoints - Defines endpoints used in Exploration page:
- * @param getAllFieldsForType - A mapping query that returns all property key names vertex types specified.
- *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#mapping-query
- * @param getAccessibleData - An aggregation histogram counts query that filters based on access type
- *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#accessibility-argument-for-regular-tier-access-level
- * @param getRawDataAndTotalCounts - Queries both _totalCount for selected vertex types and
- * tabular results containing the raw data in the rows of selected vertex types
- *   @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md#1-total-count-aggregation
- * @param getAggs - An aggregated histogram counts query which outputs vertex property frequencies
- * @param getSubAggs - TODO: not sure what this one does. Looks like nested aggregation
- * @param getCounts - Returns total counts of a vertex type
- * @returns: A guppy API endpoint for templating queriable data displayed on the exploration page
- */ const explorerApi = guppyApi.injectEndpoints({
+ * @param endpoints - Defines endpoints used in discovery page
+ *  @param getAggMDS - Queries aggregate metadata service
+ *    @see https://github.com/uc-cdis/metadata-service/blob/master/docs/agg_mds.md
+ *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Aggregate/get_aggregate_metadata_aggregate_metadata_get
+ *  @param getMDS - Queries normal metadata service
+ *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Query/search_metadata_metadata_get
+ *  @param getIndexAggMDS - queries the Aggregate Metadata service and returns all common passed in indexKeys
+ *  @param getTags - Probably refering to Aggregate metadata service summary statistics query
+ *    @see https://petstore.swagger.io/?url=https://raw.githubusercontent.com/uc-cdis/metadata-service/master/docs/openapi.yaml#/Aggregate/get_aggregate_tags_aggregate_tags_get
+ *  @param getData - Looks like a duplicate of getMDS handler. unused in ./frontend package
+ *  @param getCrosswalkData - Maps ids from one source to another
+ * @returns: A guppy download API for fetching bulk metadata
+ */ const metadataApi = gen3Api.injectEndpoints({
     endpoints: (builder)=>({
-            getAllFieldsForType: builder.query({
-                query: (type)=>({
-                        query: `{ _mapping ${type} } }`
-                    }),
+            getAggMDS: builder.query({
+                query: ({ offset, pageSize })=>{
+                    return `${GEN3_MDS_API}/aggregate/metadata?flatten=true&pagination=true&offset=${offset}&limit=${pageSize}`;
+                },
                 transformResponse: (response, _meta, params)=>{
-                    return response[params.type];
-                }
-            }),
-            getAccessibleData: builder.query({
-                query: ({ type, fields, accessType })=>{
-                    const fieldParts = fields.map((field)=>`${field} { histogram { key count } }`);
-                    return {
-                        query: `_aggregation {
-              ${type} (accessibility: ${accessType}) {
-                ${fieldParts.join(',')}
-              }
-            }`
-                    };
-                }
-            }),
-            getRawDataAndTotalCounts: builder.query({
-                query: ({ type, fields, filters, sort, offset = 0, size = 20, accessibility = exports.Accessibility.ALL, format = undefined })=>{
-                    const gqlFilter = convertFilterSetToGqlFilter(filters);
-                    const params = [
-                        ...sort ? [
-                            '$sort: JSON'
-                        ] : [],
-                        ...gqlFilter ? [
-                            '$filter: JSON'
-                        ] : [],
-                        ...format ? [
-                            '$format: Format'
-                        ] : []
-                    ].join(',');
-                    const queryLine = `query getRawDataAndTotalCounts (${params}) {`;
-                    const dataParams = [
-                        ...format ? [
-                            'format: $format'
-                        ] : [],
-                        ...sort ? [
-                            'sort: $sort'
-                        ] : [],
-                        ...gqlFilter ? [
-                            'filter: $filter'
-                        ] : []
-                    ].join(',');
-                    const dataTypeLine = `${type} (accessibility: ${accessibility}, offset: ${offset}, first: ${size},
-        ${dataParams}) {`;
-                    const typeAggsLine = `${type} (${gqlFilter && 'filter: $filter,'} accessibility: ${accessibility}) {`;
-                    const processedFields = fields.map((field)=>rawDataQueryStrForEachField(field));
-                    const query = `${queryLine}
-    ${dataTypeLine}
-      ${processedFields.join(' ')}
-            }
-            _aggregation {
-              ${typeAggsLine}
-                _totalCount
-              }
-            }
-        }`;
-                    const variables = {
-                        ...sort && {
-                            sort
-                        },
-                        ...gqlFilter && {
-                            filter: gqlFilter
-                        },
-                        ...format && {
-                            format
-                        }
-                    };
                     return {
-                        query,
-                        variables
-                    };
-                }
-            }),
-            getAggs: builder.query({
-                query: ({ type, fields, filters, accessibility = exports.Accessibility.ALL })=>{
-                    const queryStart = isFilterEmpty(filters) ? `
-              query getAggs {
-              _aggregation {
-              ${type} (accessibility: ${accessibility}) {` : `query getAggs ($filter: JSON) {
-               _aggregation {
-                      ${type} (filter: $filter, filterSelf: false, accessibility: ${accessibility}) {`;
-                    const query = `${queryStart}
-                  ${fields.map((field)=>histogramQueryStrForEachField(field))}
-                }
-              }
-            }`;
-                    const queryBody = {
-                        query: query,
-                        variables: {
-                            filter: convertFilterSetToGqlFilter(filters)
-                        }
+                        data: response.results.map((x)=>{
+                            const objValues = Object.values(x);
+                            const firstValue = objValues ? objValues.at(0) : undefined;
+                            return firstValue ? firstValue[params.studyField] : undefined;
+                        }),
+                        hits: response.pagination.hits
                     };
-                    return queryBody;
-                },
-                transformResponse: (response, _meta, args)=>{
-                    return processHistogramResponse(response.data._aggregation[args.type]);
                 }
             }),
-            getSubAggs: builder.query({
-                query: ({ type, mainField, termsFields = undefined, missingFields = undefined, numericAggAsText = false, gqlFilter = undefined, accessibility = exports.Accessibility.ALL })=>{
-                    const nestedAggFields = {
-                        termsFields: termsFields,
-                        missingFields: missingFields
-                    };
-                    const query = `query getSubAggs ( ${gqlFilter ?? '$filter: JSON,'} $nestedAggFields: JSON) {
-    _aggregation {
-      ${type} ( ${gqlFilter ?? 'filter: $filter, filterSelf: false,'} nestedAggFields: $nestedAggFields, accessibility: ${accessibility}) {
-        ${nestedHistogramQueryStrForEachField(mainField, numericAggAsText)}
-      }`;
-                    return {
-                        query: query,
-                        variables: {
-                            ...gqlFilter && {
-                                filter: convertFilterSetToGqlFilter(gqlFilter)
-                            },
-                            nestedAggFields: nestedAggFields
-                        }
-                    };
+            getIndexAggMDS: builder.query({
+                query: ({ pageSize })=>{
+                    return `${GEN3_MDS_API}/aggregate/metadata?limit=${pageSize}`;
                 },
-                transformResponse: (response, _meta, args)=>{
-                    return processHistogramResponse(response.data._aggregation[args.type]);
-                }
-            }),
-            getCounts: builder.query({
-                query: ({ type, filters, accessibility = exports.Accessibility.ALL })=>{
-                    const gqlFilters = convertFilterSetToGqlFilter(filters);
-                    const queryLine = `query totalCounts ${gqlFilters ? '($filter: JSON)' : ''}{`;
-                    const typeAggsLine = `${type} ${gqlFilters ? '(filter: $filter, ' : '('} accessibility: ${accessibility}) {`;
-                    const query = `${queryLine} _aggregation {
-          ${typeAggsLine}
-            _totalCount
-            }
-           }
-        }`;
-                    return {
-                        query: query,
-                        variables: {
-                            ...gqlFilters && {
-                                filter: gqlFilters
-                            }
+                transformResponse: (response, _meta, params)=>{
+                    const dataFromIndexes = params.indexKeys.reduce((acc, key)=>{
+                        if (response[key]) {
+                            acc.push(...response[key]);
                         }
-                    };
-                },
-                transformResponse: (response, _meta, args)=>{
-                    return response.data._aggregation[args.type]._totalCount;
-                }
-            }),
-            getFieldCountSummary: builder.query({
-                query: ({ type, field, filters, accessibility = exports.Accessibility.ALL })=>{
-                    const gqlFilters = convertFilterSetToGqlFilter(filters);
-                    const query = `query summary ($filter: JSON) {
-        _aggregation {
-          ${type} (filter: $filter, accessibility: ${accessibility}) {
-            ${field} {
-              histogram {
-                sum,
-              }
-            }
-          }
-        }
-      }`;
+                        return acc;
+                    }, []);
                     return {
-                        query: query,
-                        variables: {
-                            ...gqlFilters && {
-                                filter: gqlFilters
+                        data: dataFromIndexes.map((x)=>{
+                            const objValues = Object.values(x);
+                            const objIds = Object.keys(x);
+                            let firstValue = objValues ? objValues.at(0) : undefined;
+                            if (params?.filterEmpty) {
+                                // remove any data that has < limit if defined
+                                if (firstValue && !HasEnoughData(firstValue[params.studyField], params.filterEmpty.keys, params.filterEmpty.limit)) firstValue = undefined;
                             }
-                        }
+                            return firstValue ? {
+                                gen3MDSGUID: objIds.at(0),
+                                ...firstValue[params.studyField]
+                            } : undefined;
+                        }).filter((x)=>x !== undefined),
+                        hits: dataFromIndexes.length
                     };
                 }
             }),
-            getFieldsForIndex: builder.query({
-                query: (index)=>{
+            getMDS: builder.query({
+                query: ({ guidType, offset, pageSize })=>{
+                    return `${GEN3_MDS_API}/metadata?data=True&_guid_type=${guidType}&limit=${pageSize}&offset=${offset}`;
+                },
+                transformResponse: (response, _meta)=>{
                     return {
-                        query: `{
-            _mapping ${index}
-          }`
+                        data: Object.keys(response).map((guid)=>response[guid]),
+                        hits: Object.keys(response).length
                     };
-                },
-                transformResponse: (response)=>{
-                    return response['_mapping'];
                 }
             }),
-            generalGQL: builder.query({
-                query: ({ query, variables })=>{
+            getTags: builder.query({
+                query: ()=>'tags'
+            }),
+            getData: builder.query({
+                query: (params)=>({
+                        url: `metadata?${params}`
+                    })
+            }),
+            // TODO: Move this to own slice
+            getCrosswalkData: builder.query({
+                queryFn: async (arg, _queryApi, _extraOptions, fetchWithBQ)=>{
+                    const queryMultiple = async ()=>{
+                        let result = [];
+                        const queue = Queue({
+                            concurrency: 15
+                        });
+                        for (const id of arg.ids){
+                            queue.push(async (callback)=>{
+                                const response = await fetchWithBQ({
+                                    url: `${GEN3_CROSSWALK_API}/metadata/${id}`
+                                });
+                                if (response.error) {
+                                    return {
+                                        error: response.error
+                                    };
+                                }
+                                const toData = arg.toPaths.reduce((acc, path)=>{
+                                    acc[path.id] = jsonpathPlus.JSONPath({
+                                        json: response.data,
+                                        path: `$.[${path.dataPath}]`,
+                                        resultType: 'value'
+                                    })?.[0] ?? 'n/a';
+                                    return acc;
+                                }, {});
+                                result = [
+                                    ...result,
+                                    {
+                                        from: id,
+                                        to: toData
+                                    }
+                                ];
+                                if (callback) callback();
+                                return result;
+                            });
+                        }
+                        return new Promise((resolve, reject)=>{
+                            queue.start((err)=>{
+                                if (err) {
+                                    reject(err);
+                                } else {
+                                    resolve(result);
+                                }
+                            });
+                        });
+                    };
+                    const result = await queryMultiple();
                     return {
-                        query: query,
-                        variables: variables
+                        data: result
                     };
                 }
             })
         })
 });
-// query for aggregate data
-// convert the function below to typescript
-const histogramQueryStrForEachField = (field)=>{
-    const splittedFieldArray = field.split('.');
-    const splittedField = splittedFieldArray.shift();
-    if (splittedFieldArray.length === 0) {
-        return `
-    ${splittedField} {
-      histogram {
-        key
-        count
-      }
-    }`;
-    }
-    return `
-  ${splittedField} {
-    ${histogramQueryStrForEachField(splittedFieldArray.join('.'))}
-  }`;
-};
-const nestedHistogramQueryStrForEachField = (mainField, numericAggAsText)=>`
-  ${mainField} {
-    ${numericAggAsText ? 'asTextHistogram' : 'histogram'} {
-      key
-      count
-      missingFields {
-        field
-        count
-      }
-      termsFields {
-        field
-        count
-        terms {
-          key
-          count
-        }
-      }
-    }
-  }`;
-const rawDataQueryStrForEachField = (field)=>{
-    const splitFieldArray = field.split('.');
-    const splitField = splitFieldArray.shift();
-    if (splitFieldArray.length === 0) {
-        return `
-    ${splitField}
-    `;
-    }
-    return `
-  ${splitField} {
-    ${rawDataQueryStrForEachField(splitFieldArray.join('.'))}
-  }`;
-};
-const useGetArrayTypes = ()=>{
-    {
-        const { data, error } = useGetStatus();
-        if (error) {
-            return {};
-        }
-        return data ? data['indices'] : {};
-    }
-};
-const { useGetRawDataAndTotalCountsQuery, useGetAccessibleDataQuery, useGetAllFieldsForTypeQuery, useGetAggsQuery, useLazyGetAggsQuery, useGetSubAggsQuery, useGetCountsQuery, useGetFieldCountSummaryQuery, useGetFieldsForIndexQuery, useGeneralGQLQuery, useLazyGeneralGQLQuery } = explorerApi;
+const { useGetAggMDSQuery, useGetMDSQuery, useGetTagsQuery, useGetDataQuery, useGetCrosswalkDataQuery, useLazyGetCrosswalkDataQuery, useGetIndexAggMDSQuery } = metadataApi;
 
-/**
- * Flattens a deep nested JSON object skipping
- * the first level to avoid potentially flattening
- * non-nested data.
- * @param {JSON} json
- */ function flattenJson(json) {
-    const flattenedJson = [];
-    Object.keys(json).forEach((key)=>{
-        flattenedJson.push(flat.flatten(json[key], {
-            delimiter: '_'
-        }));
-    });
-    return flattenedJson;
-}
-/**
- * Converts JSON based on a config.
- * @param {JSON} json
- * @param {Object} config
- */ async function conversion(json, config) {
-    return Papa.unparse(json, config);
-}
-/**
- * Converts JSON to a specified file format.
- * Defaults to JSON if file format is not supported.
- * @param {JSON} json
- * @param {string} format
- */ async function jsonToFormat(json, format) {
-    if (Object.keys(FILE_DELIMITERS).includes(format)) {
-        const flatJson = await flattenJson(json);
-        const data = await conversion(flatJson, {
-            delimiter: FILE_DELIMITERS[format]
-        });
-        return data;
-    }
-    return json;
-}
+// using a random uuid v4 as the namespace
+const GEN3_APP_NAMESPACE = '7bfaa818-c69c-457e-8d87-413cf60c25f0';
 
+const getGen3AppId = (name, version)=>{
+    const nameVersion = `${name}::${version}`;
+    return uuid.v5(nameVersion, GEN3_APP_NAMESPACE);
+};
 /**
- * Prepares a URL for downloading by appending '/download' to the provided apiUrl.
- *
- * @param {string} apiUrl - The base URL to be used for preparing the download URL.
- * @returns {URL} - The prepared download URL as a URL object.
- */ const prepareUrl = (apiUrl)=>new URL(apiUrl + '/download');
-/**
- * Prepares a fetch configuration object for downloading files from Guppy.
- *
- * @param {GuppyFileDownloadRequestParams} parameters - The parameters to include in the request body.
- * @param {string} csrfToken - The CSRF token to include in the request headers.
- * @returns {FetchConfig} - The prepared fetch configuration object.
- */ const prepareFetchConfig = (parameters, csrfToken)=>{
+ *  Creates a Gen3App that is dynamically loaded
+ */ const createGen3App = ({ App, name, version, requiredEntityTypes })=>{
+    // create a stable id for this app
+    const nameVersion = `${name}::${version}`;
+    const id = uuid.v5(nameVersion, GEN3_APP_NAMESPACE);
+    // need to create store and provider.
+    // return a component representing this app
+    // if component gets added to a list, then the list can be iterated in index.js and each provider component can be added
+    // a route can be setup for the app
+    // need to register its name, category, path, data requirements
+    // this will be used to build page3
+    // click app link
+    // const store = configureStore({
+    //   // TODO allow user to pass in a reducer in CreateGen3AppOptions?
+    //   reducer: (state) => state,
+    //   devTools: {
+    //     name: `${nameVersion}::${id}`,
+    //   },
+    // });
+    const Gen3AppWrapper = (props)=>{
+        React.useEffect(()=>{
+            document.title = `GEN3 - ${name}`;
+        });
+        return /*#__PURE__*/ React.createElement(App, props);
+    };
+    // add the app to the store
+    coreStore.dispatch(addGen3AppMetadata({
+        id,
+        name,
+        version,
+        requiredEntityTypes
+    }));
+    registerGen3App(name, Gen3AppWrapper);
+    return Gen3AppWrapper;
+};
+// ----------------------------------------------------------------------------------------
+// Apps with Local Storage
+//
+const createAppStore = (options)=>{
+    const { name, version, reducers, middleware } = options;
+    const nameVersion = `${name}::${version}`;
+    const id = uuid.v5(nameVersion, GEN3_APP_NAMESPACE);
+    const store = toolkit.configureStore({
+        reducer: reducers,
+        devTools: {
+            name: `${nameVersion}::${id}`
+        },
+        middleware: (getDefaultMiddleware)=>middleware ? getDefaultMiddleware({
+                serializableCheck: {
+                    ignoredActions: [
+                        reduxPersist.FLUSH,
+                        reduxPersist.REHYDRATE,
+                        reduxPersist.PAUSE,
+                        reduxPersist.PERSIST,
+                        reduxPersist.PURGE,
+                        reduxPersist.REGISTER
+                    ]
+                }
+            }).concat(middleware) : getDefaultMiddleware({
+                serializableCheck: {
+                    ignoredActions: [
+                        reduxPersist.FLUSH,
+                        reduxPersist.REHYDRATE,
+                        reduxPersist.PAUSE,
+                        reduxPersist.PERSIST,
+                        reduxPersist.PURGE,
+                        reduxPersist.REGISTER
+                    ]
+                }
+            })
+    });
+    const context = /*#__PURE__*/ React.createContext(null);
+    const useAppSelector = reactRedux.createSelectorHook(context);
+    const useAppDispatch = reactRedux.createDispatchHook(context);
+    const useAppStore = reactRedux.createStoreHook(context);
     return {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            ...csrfToken !== undefined && {
-                'X-CSRF-Token': csrfToken
-            }
-        },
-        body: JSON.stringify({
-            type: parameters.type,
-            filter: convertFilterSetToGqlFilter(parameters.filter),
-            accessibility: parameters.accessibility,
-            fields: parameters?.fields,
-            sort: parameters?.sort
-        })
+        id: id,
+        AppStore: store,
+        AppContext: context,
+        useAppSelector: useAppSelector,
+        useAppDispatch: useAppDispatch,
+        useAppStore: useAppStore
     };
 };
-/**
- * Downloads a file from Guppy using the provided parameters.
- * It will optionally convert the data to the specified format.
- *
- * @param {DownloadFromGuppyParams} parameters - The parameters to use for the download request.
- * @param onStart - The function to call when the download starts.
- * @param onDone - The function to call when the download is done.
- * @param onError - The function to call when the download fails.
- * @param onAbort - The function to call when the download is aborted.
- * @param signal - AbortSignal to use for the request.
- */ const downloadFromGuppyToBlob = async ({ parameters, onStart = ()=>null, onDone = (_)=>null, onError = (_)=>null, onAbort = ()=>null, signal = undefined })=>{
-    const csrfToken = selectCSRFToken(coreStore.getState());
-    onStart?.();
-    const url = prepareUrl(GEN3_GUPPY_API);
-    const fetchConfig = prepareFetchConfig(parameters, csrfToken);
-    fetch(url.toString(), {
-        ...fetchConfig,
-        ...signal ? {
-            signal: signal
-        } : {}
-    }).then(async (response)=>{
-        if (!response.ok) {
-            throw new Error(response.statusText);
-        }
-        let jsonData = await response.json();
-        if (parameters?.rootPath && parameters.rootPath) {
-            // if rootPath is provided, extract the data from the rootPath
-            jsonData = jsonpathPlus.JSONPath({
-                json: jsonData,
-                path: `$.[${parameters.rootPath}]`,
-                resultType: 'value'
-            });
-        }
-        // convert the data to the specified format and return a Blob
-        let str = '';
-        if (parameters.format === 'json') {
-            str = JSON.stringify(jsonData);
-        } else {
-            const convertedData = await jsonToFormat(jsonData, parameters.format);
-            if (isJSONObject(convertedData)) {
-                str = JSON.stringify(convertedData, null, 2);
-            } else {
-                str = convertedData;
-            }
-        }
-        return new Blob([
-            str
-        ], {
-            type: 'application/json'
+const createGen3AppWithOwnStore = (options)=>{
+    const { App, id, name, version, requiredEntityTypes, store, context } = options;
+    // need to create store and provider.
+    // return a component representing this app
+    // if component gets added to a list, then the list can be iterated in index.js and each provider component can be added
+    // a route can be setup for the app
+    // need to register its name, category, path, data requirements
+    // this will be used to build page3
+    // click app link
+    const Gen3AppWrapper = (props)=>{
+        React.useEffect(()=>{
+            document.title = `GEN3 - ${name}`;
         });
-    }).then((blob)=>onDone?.(blob)).catch((error)=>{
-        // Abort is handle as an exception
-        if (error.name == 'AbortError') {
-            // handle abort()
-            onAbort?.();
-        }
-        onError?.(error);
-    });
+        return /*#__PURE__*/ React.createElement(reactRedux.Provider, {
+            store: store,
+            context: context
+        }, /*#__PURE__*/ React.createElement(reactCookie.CookiesProvider, null, /*#__PURE__*/ React.createElement(App, props)));
+    };
+    // add the app to the store
+    coreStore.dispatch(addGen3AppMetadata({
+        id,
+        name,
+        version,
+        requiredEntityTypes
+    }));
+    registerGen3App(name, Gen3AppWrapper);
+    return Gen3AppWrapper;
 };
-const downloadJSONDataFromGuppy = async ({ parameters, onAbort = ()=>null, signal = undefined })=>{
-    const csrfToken = selectCSRFToken(coreStore.getState());
-    const url = prepareUrl(GEN3_GUPPY_API);
-    const fetchConfig = prepareFetchConfig(parameters, csrfToken);
-    try {
-        const response = await fetch(url.toString(), {
-            ...fetchConfig,
-            ...signal ? {
-                signal: signal
-            } : {}
-        });
-        let jsonData = await response.json();
-        if (parameters?.rootPath && parameters.rootPath) {
-            // if rootPath is provided, extract the data from the rootPath
-            jsonData = jsonpathPlus.JSONPath({
-                json: jsonData,
-                path: `$.[${parameters.rootPath}]`,
-                resultType: 'value'
-            });
-        }
-        // convert the data to the specified format and return a Blob
-        return jsonData;
-    } catch (error) {
-        // Abort is handle as an exception
-        if (error.name == 'AbortError') {
-            // handle abort()
-            onAbort?.();
+
+const createAppApiForRTKQ = (reducerPath, baseQuery)=>{
+    const appContext = React__namespace.createContext(null);
+    const useAppSelector = reactRedux.useSelector.withTypes();
+    const useAppDispatch = reactRedux.createDispatchHook(appContext);
+    const useAppStore = reactRedux.createStoreHook(appContext);
+    const appCreateApi = react.buildCreateApi(react.coreModule(), react.reactHooksModule({
+        hooks: {
+            useDispatch: useAppDispatch,
+            useSelector: useAppSelector,
+            useStore: useAppStore
         }
-        throw new Error(error);
-    }
-};
-const useGetIndexFields = (index)=>{
-    const { data } = useGetFieldsForIndexQuery(index);
-    return data ?? [];
+    }));
+    const appRTKQApi = appCreateApi({
+        reducerPath: reducerPath,
+        baseQuery: baseQuery ?? react.fetchBaseQuery({
+            baseUrl: `${GEN3_API}`,
+            prepareHeaders: (headers)=>{
+                headers.set('Content-Type', 'application/json');
+                let accessToken = undefined;
+                if (process.env.NODE_ENV === 'development') {
+                    // NOTE: This cookie can only be accessed from the client side
+                    // in development mode. Otherwise, the cookie is set as httpOnly
+                    accessToken = cookiesNext.getCookie('credentials_token');
+                }
+                if (accessToken) headers.set('Authorization', `Bearer ${accessToken}`);
+                return headers;
+            }
+        }),
+        endpoints: ()=>({})
+    });
+    const appMiddleware = appRTKQApi.middleware;
+    const appStore = toolkit.configureStore({
+        reducer: {
+            [appRTKQApi.reducerPath]: appRTKQApi.reducer
+        },
+        middleware: (getDefaultMiddleware)=>getDefaultMiddleware({
+                serializableCheck: {
+                    ignoredActions: [
+                        reduxPersist.FLUSH,
+                        reduxPersist.REHYDRATE,
+                        reduxPersist.PAUSE,
+                        reduxPersist.PERSIST,
+                        reduxPersist.PURGE,
+                        reduxPersist.REGISTER
+                    ]
+                }
+            }).concat(appMiddleware)
+    });
+    return {
+        useAppSelector: useAppSelector,
+        useAppDispatch: useAppDispatch,
+        useAppStore: useAppStore,
+        AppContext: appContext,
+        appApi: appRTKQApi,
+        appContext: appContext,
+        appStore: appStore
+    };
 };
 
+const graphQLWithTags = gen3Api.enhanceEndpoints({
+    addTagTypes: [
+        'graphQL'
+    ]
+});
 /**
- * Creates a Guppy API for fetching bulk (> 10K rows) elasticsearch data
- * @see https://github.com/uc-cdis/guppy/blob/master/doc/download.md
- * @param endpoints - Resolver function which configures the query with
- * type, filter, accessibility, fields, and sort arguments
- * @returns: A guppy download API for fetching bulk metadata
- */ const downloadRequestApi = gen3Api.injectEndpoints({
+ * Creates a graphQLAPI for graphql queries to elasticsearch indices via guppy
+ * @see https://github.com/uc-cdis/guppy/blob/master/doc/queries.md
+ * @param query - Resolver function which configures the graphql query with graphQLParams argument
+ * @returns: A guppy search API for fetching metadata
+ */ const graphQLAPI = graphQLWithTags.injectEndpoints({
     endpoints: (builder)=>({
-            downloadFromGuppy: builder.mutation({
-                query: ({ type, filter, accessibility, fields, sort })=>{
-                    const queryBody = {
-                        filter: convertFilterSetToGqlFilter(filter),
-                        ...{
-                            type,
-                            accessibility,
-                            fields,
-                            sort
-                        }
-                    };
-                    return {
-                        url: `${GEN3_GUPPY_API}/download`,
+            graphQL: builder.query({
+                query: (graphQLParams)=>({
+                        url: `${GEN3_GUPPY_API}/graphql`,
                         method: 'POST',
-                        queryBody,
-                        cache: 'no-cache'
-                    };
-                },
-                transformResponse: (response)=>{
-                    return response;
-                }
+                        credentials: 'include',
+                        body: JSON.stringify(graphQLParams)
+                    })
             })
         })
 });
-const { useDownloadFromGuppyMutation } = downloadRequestApi;
+const { useGraphQLQuery } = graphQLAPI;
 
 /**
  * returns a response from the AI search service
@@ -2474,8 +3257,11 @@ exports.GEN3_REDIRECT_URL = GEN3_REDIRECT_URL;
 exports.GEN3_SOWER_API = GEN3_SOWER_API;
 exports.GEN3_SUBMISSION_API = GEN3_SUBMISSION_API;
 exports.GEN3_WORKSPACE_API = GEN3_WORKSPACE_API;
+exports.HTTPError = HTTPError;
+exports.HTTPErrorMessages = HTTPErrorMessages;
 exports.clearActiveWorkspaceId = clearActiveWorkspaceId;
 exports.clearCohortFilters = clearCohortFilters;
+exports.clearDataLibrarySelection = clearDataLibrarySelection;
 exports.cohortReducer = cohortReducer;
 exports.convertFilterSetToGqlFilter = convertFilterSetToGqlFilter;
 exports.coreStore = coreStore;
@@ -2484,6 +3270,7 @@ exports.createAppStore = createAppStore;
 exports.createGen3App = createGen3App;
 exports.createGen3AppWithOwnStore = createGen3AppWithOwnStore;
 exports.createUseCoreDataHook = createUseCoreDataHook;
+exports.dataLibrarySelectionReducer = dataLibrarySelectionReducer;
 exports.downloadFromGuppyToBlob = downloadFromGuppyToBlob;
 exports.downloadJSONDataFromGuppy = downloadJSONDataFromGuppy;
 exports.drsHostnamesReducer = drsHostnamesReducer;
@@ -2493,11 +3280,14 @@ exports.extractFilterValue = extractFilterValue;
 exports.extractIndexAndFieldNameFromFullFieldName = extractIndexAndFieldNameFromFullFieldName;
 exports.extractIndexFromFullFieldName = extractIndexFromFullFieldName;
 exports.fetchFence = fetchFence;
+exports.fetchFencePresignedURL = fetchFencePresignedURL;
 exports.fetchJson = fetchJson;
 exports.fetchUserState = fetchUserState;
 exports.fieldNameToTitle = fieldNameToTitle;
 exports.gen3Api = gen3Api;
 exports.getGen3AppId = getGen3AppId;
+exports.getNumberOfItemsInDatalist = getNumberOfItemsInDatalist;
+exports.getTimestamp = getTimestamp;
 exports.graphQLAPI = graphQLAPI;
 exports.graphQLWithTags = graphQLWithTags;
 exports.guppyAPISliceMiddleware = guppyAPISliceMiddleware;
@@ -2506,11 +3296,16 @@ exports.guppyApiReducer = guppyApiReducer;
 exports.guppyApiSliceReducerPath = guppyApiSliceReducerPath;
 exports.handleOperation = handleOperation;
 exports.hideModal = hideModal;
+exports.isAdditionalDataItem = isAdditionalDataItem;
+exports.isArray = isArray;
 exports.isAuthenticated = isAuthenticated;
+exports.isCohortItem = isCohortItem;
 exports.isErrorWithMessage = isErrorWithMessage;
 exports.isFetchBaseQueryError = isFetchBaseQueryError;
 exports.isFetchParseError = isFetchParseError;
+exports.isFileItem = isFileItem;
 exports.isFilterEmpty = isFilterEmpty;
+exports.isFilterSet = isFilterSet;
 exports.isGuppyAggregationData = isGuppyAggregationData;
 exports.isHistogramData = isHistogramData;
 exports.isHistogramDataAArray = isHistogramDataAArray;
@@ -2524,15 +3319,20 @@ exports.isHttpStatusError = isHttpStatusError;
 exports.isJSONObject = isJSONObject;
 exports.isJSONValue = isJSONValue;
 exports.isJSONValueArray = isJSONValueArray;
+exports.isNotDefined = isNotDefined;
+exports.isObject = isObject;
 exports.isOperationWithField = isOperationWithField;
 exports.isPending = isPending;
 exports.isProgramUrl = isProgramUrl;
 exports.isRootUrl = isRootUrl;
+exports.isString = isString;
 exports.isWorkspaceActive = isWorkspaceActive;
 exports.isWorkspaceRunningOrStopping = isWorkspaceRunningOrStopping;
 exports.listifyMethodsFromMapping = listifyMethodsFromMapping;
 exports.logoutFence = logoutFence;
+exports.prepareUrl = prepareUrl;
 exports.prependIndexToFieldName = prependIndexToFieldName;
+exports.processHistogramResponse = processHistogramResponse;
 exports.projectCodeFromResourcePath = projectCodeFromResourcePath;
 exports.rawDataQueryStrForEachField = rawDataQueryStrForEachField;
 exports.removeCohortFilter = removeCohortFilter;
@@ -2567,16 +3367,20 @@ exports.setActiveWorkspaceId = setActiveWorkspaceId;
 exports.setActiveWorkspaceStatus = setActiveWorkspaceStatus;
 exports.setCohortFilter = setCohortFilter;
 exports.setDRSHostnames = setDRSHostnames;
+exports.setDataLibraryListSelection = setDataLibraryListSelection;
 exports.setRequestedWorkspaceStatus = setRequestedWorkspaceStatus;
 exports.showModal = showModal;
 exports.submissionApi = submissionApi;
 exports.trimFirstFieldNameToTitle = trimFirstFieldNameToTitle;
 exports.updateCohortFilter = updateCohortFilter;
+exports.useAddDataLibraryListMutation = useAddDataLibraryListMutation;
 exports.useAddNewCredentialMutation = useAddNewCredentialMutation;
 exports.useAskQuestionMutation = useAskQuestionMutation;
 exports.useAuthorizeFromCredentialsMutation = useAuthorizeFromCredentialsMutation;
 exports.useCoreDispatch = useCoreDispatch;
 exports.useCoreSelector = useCoreSelector;
+exports.useDataLibrary = useDataLibrary;
+exports.useDeleteDataLibraryListMutation = useDeleteDataLibraryListMutation;
 exports.useDownloadFromGuppyMutation = useDownloadFromGuppyMutation;
 exports.useFetchUserDetailsQuery = useFetchUserDetailsQuery;
 exports.useGeneralGQLQuery = useGeneralGQLQuery;
@@ -2593,8 +3397,11 @@ exports.useGetCSRFQuery = useGetCSRFQuery;
 exports.useGetCountsQuery = useGetCountsQuery;
 exports.useGetCredentialsQuery = useGetCredentialsQuery;
 exports.useGetCrosswalkDataQuery = useGetCrosswalkDataQuery;
+exports.useGetDataLibraryListQuery = useGetDataLibraryListQuery;
+exports.useGetDataLibraryListsQuery = useGetDataLibraryListsQuery;
 exports.useGetDataQuery = useGetDataQuery;
 exports.useGetDictionaryQuery = useGetDictionaryQuery;
+exports.useGetDownloadQuery = useGetDownloadQuery;
 exports.useGetExternalLoginsQuery = useGetExternalLoginsQuery;
 exports.useGetFieldCountSummaryQuery = useGetFieldCountSummaryQuery;
 exports.useGetFieldsForIndexQuery = useGetFieldsForIndexQuery;
@@ -2626,6 +3433,7 @@ exports.useLazyFetchUserDetailsQuery = useLazyFetchUserDetailsQuery;
 exports.useLazyGeneralGQLQuery = useLazyGeneralGQLQuery;
 exports.useLazyGetAggsQuery = useLazyGetAggsQuery;
 exports.useLazyGetCrosswalkDataQuery = useLazyGetCrosswalkDataQuery;
+exports.useLazyGetDownloadQuery = useLazyGetDownloadQuery;
 exports.useLazyGetExternalLoginsQuery = useLazyGetExternalLoginsQuery;
 exports.useLazyGetProjectsQuery = useLazyGetProjectsQuery;
 exports.useLazyGetSowerJobListQuery = useLazyGetSowerJobListQuery;
@@ -2636,6 +3444,7 @@ exports.useRemoveCredentialMutation = useRemoveCredentialMutation;
 exports.useSetCurrentPayModelMutation = useSetCurrentPayModelMutation;
 exports.useSubmitSowerJobMutation = useSubmitSowerJobMutation;
 exports.useTerminateWorkspaceMutation = useTerminateWorkspaceMutation;
+exports.useUpdateDataLibraryListMutation = useUpdateDataLibraryListMutation;
 exports.useUser = useUser;
 exports.useUserAuth = useUserAuth;
 exports.userHasCreateOrUpdateOnAnyProject = userHasCreateOrUpdateOnAnyProject;