@databiosphere/findable-ui 0.0.0

package/lib/providers/config.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigProvider = exports.ConfigContext = void 0;
+const react_1 = __importStar(require("react"));
+const utils_1 = require("../config/utils");
+exports.ConfigContext = (0, react_1.createContext)({
+    config: (0, utils_1.getDefaultConfig)(),
+    defaultEntityListType: "",
+    entityConfig: (0, utils_1.getDefaultEntityConfig)(),
+    entityListType: "",
+});
+function ConfigProvider({ children, config, entityListType, }) {
+    const { entities } = config;
+    const defaultEntityListType = config.redirectRootToPath.slice(1);
+    const entityName = entityListType || defaultEntityListType;
+    const entityConfig = (0, utils_1.getEntityConfig)(entities, entityName);
+    return (react_1.default.createElement(exports.ConfigContext.Provider, { value: {
+            config,
+            defaultEntityListType,
+            entityConfig,
+            entityListType,
+        } }, children));
+}
+exports.ConfigProvider = ConfigProvider;

package/lib/providers/exploreState/constants.d.ts

@@ -0,0 +1,3 @@
+import { ExploreState, PaginationState } from "../exploreState";
+export declare const DEFAULT_PAGINATION_STATE: PaginationState;
+export declare const INITIAL_STATE: ExploreState;

package/lib/providers/exploreState/constants.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INITIAL_STATE = exports.DEFAULT_PAGINATION_STATE = void 0;
+// Template constants
+exports.DEFAULT_PAGINATION_STATE = {
+    currentPage: 1,
+    index: null,
+    nextIndex: null,
+    pageSize: 25,
+    pages: 1,
+    previousIndex: null,
+    rows: 0,
+};
+// Initial state
+exports.INITIAL_STATE = {
+    catalogState: undefined,
+    categoryViews: [],
+    entityPageState: {},
+    filterCount: 0,
+    filterState: [],
+    isRelatedView: false,
+    listItems: [],
+    listView: undefined,
+    loading: true,
+    paginationState: exports.DEFAULT_PAGINATION_STATE,
+    relatedListItems: undefined,
+    tabValue: "",
+};

package/lib/providers/exploreState/payloads/entities.d.ts

@@ -0,0 +1,46 @@
+import { ColumnSort } from "@tanstack/react-table";
+import { CategoryKey, CategoryValueKey, PaginationDirectionType, SelectCategory } from "../../../common/entities";
+import { ENTITY_VIEW, ListItems, PaginationResponse, RelatedListItems } from "../../exploreState";
+/**
+ * Process explore response payload.
+ */
+export interface ProcessExploreResponsePayload {
+    listItems: ListItems;
+    loading: boolean;
+    paginationResponse: PaginationResponse;
+    selectCategories?: SelectCategory[];
+}
+/**
+ * Process related response payload
+ */
+export interface ProcessRelatedResponsePayload {
+    relatedListItems: RelatedListItems;
+}
+/**
+ * Paginate table payload.
+ */
+export declare type PaginateTablePayload = PaginationDirectionType;
+/**
+ * Reset explore response payload.
+ */
+export declare type ResetExploreResponsePayload = undefined;
+/**
+ * Toggle entity view payload.
+ */
+export declare type ToggleEntityViewPayload = ENTITY_VIEW;
+/**
+ * Update column visibility payload.
+ */
+export declare type UpdateColumnVisibilityPayload = Record<string, boolean>;
+/**
+ * Update filter payload.
+ */
+export interface UpdateFilterPayload {
+    categoryKey: CategoryKey;
+    selected: boolean;
+    selectedValue: CategoryValueKey;
+}
+/**
+ * Update sorting payload.
+ */
+export declare type UpdateSortingPayload = ColumnSort[];

package/lib/providers/exploreState/payloads/entities.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/providers/exploreState/utils.d.ts

@@ -0,0 +1,36 @@
+import { SelectedFilter } from "../../common/entities";
+import { SiteConfig } from "../../config/entities";
+import { EntityPageStateMapper, ExploreState, PaginationState } from "../exploreState";
+/**
+ * Returns the filter count.
+ * @param filterState - Filter state.
+ * @returns filter count.
+ */
+export declare function getFilterCount(filterState: SelectedFilter[]): number;
+/**
+ * Returns the initial explore state.
+ * @param config - Site config.
+ * @param entityListType - Entity list type.
+ * @param decodedFilterParam - Decoded filter parameter.
+ * @param decodedCatalogParam - Decoded catalog parameter.
+ * @returns explore state.
+ */
+export declare function initExploreState(config: SiteConfig, entityListType: string, decodedFilterParam: string, decodedCatalogParam?: string): ExploreState;
+/**
+ * Initializes filter state from URL "filter" parameter.
+ * @param decodedFilterParam - Decoded filter parameter.
+ * @returns filter state.
+ */
+export declare function initFilterState(decodedFilterParam: string): SelectedFilter[];
+/**
+ * Initializes entity page state.
+ * @param config - Site config.
+ * @returns entity page state.
+ */
+export declare function initEntityPageState(config: SiteConfig): EntityPageStateMapper;
+/**
+ * Resets pagination.
+ * @param paginationState - Pagination state.
+ * @returns a reset pagination state.
+ */
+export declare function resetPage(paginationState: PaginationState): PaginationState;

package/lib/providers/exploreState/utils.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetPage = exports.initEntityPageState = exports.initFilterState = exports.initExploreState = exports.getFilterCount = void 0;
+const utils_1 = require("../../components/Table/common/utils");
+const utils_2 = require("../../config/utils");
+const exploreState_1 = require("../exploreState");
+const constants_1 = require("./constants");
+/**
+ * Returns the filter count.
+ * @param filterState - Filter state.
+ * @returns filter count.
+ */
+function getFilterCount(filterState) {
+    return filterState.reduce((acc, filter) => acc + filter.value.length, 0);
+}
+exports.getFilterCount = getFilterCount;
+/**
+ * Returns the initial explore state.
+ * @param config - Site config.
+ * @param entityListType - Entity list type.
+ * @param decodedFilterParam - Decoded filter parameter.
+ * @param decodedCatalogParam - Decoded catalog parameter.
+ * @returns explore state.
+ */
+function initExploreState(config, entityListType, decodedFilterParam, decodedCatalogParam) {
+    const filterState = initFilterState(decodedFilterParam);
+    const filterCount = getFilterCount(filterState);
+    return Object.assign(Object.assign({}, constants_1.INITIAL_STATE), { catalogState: decodedCatalogParam, entityPageState: initEntityPageState(config), filterCount,
+        filterState, listView: exploreState_1.ENTITY_VIEW.EXACT, tabValue: entityListType });
+}
+exports.initExploreState = initExploreState;
+/**
+ * Initializes filter state from URL "filter" parameter.
+ * @param decodedFilterParam - Decoded filter parameter.
+ * @returns filter state.
+ */
+function initFilterState(decodedFilterParam) {
+    // Define filter state, from URL "filter" parameter, if present and valid.
+    let filterState = [];
+    try {
+        filterState = JSON.parse(decodedFilterParam);
+    }
+    catch (_a) {
+        // do nothing
+    }
+    return filterState;
+}
+exports.initFilterState = initFilterState;
+/**
+ * Initializes entity page state.
+ * @param config - Site config.
+ * @returns entity page state.
+ */
+function initEntityPageState(config) {
+    return config.entities.reduce((acc, entity) => (Object.assign(Object.assign({}, acc), { [entity.route]: {
+            columnsVisibility: (0, utils_1.getInitialTableColumnVisibility)(entity.list.columns),
+            sorting: (0, utils_2.getDefaultSorting)(entity),
+        } })), {});
+}
+exports.initEntityPageState = initEntityPageState;
+/**
+ * Resets pagination.
+ * @param paginationState - Pagination state.
+ * @returns a reset pagination state.
+ */
+function resetPage(paginationState) {
+    const nextPaginationState = Object.assign({}, paginationState);
+    nextPaginationState.index = null;
+    nextPaginationState.currentPage = 1;
+    return nextPaginationState;
+}
+exports.resetPage = resetPage;

package/lib/providers/exploreState.d.ts

@@ -0,0 +1,209 @@
+import { ColumnSort } from "@tanstack/react-table";
+import React, { Dispatch, ReactNode } from "react";
+import { AzulSearchIndex } from "../apis/azul/common/entities";
+import { SelectCategory, SelectedFilter } from "../common/entities";
+import { CategoryConfig, EntityPath, SiteConfig } from "../config/entities";
+import { PaginateTablePayload, ProcessExploreResponsePayload, ProcessRelatedResponsePayload, ResetExploreResponsePayload, ToggleEntityViewPayload, UpdateColumnVisibilityPayload, UpdateFilterPayload, UpdateSortingPayload } from "./exploreState/payloads/entities";
+export declare type CatalogState = string | undefined;
+/**
+ * Entity view.
+ */
+export declare enum ENTITY_VIEW {
+    EXACT = "EXACT",
+    RELATED = "RELATED"
+}
+/**
+ * Explore context.
+ */
+export interface ExploreContext {
+    categoryConfigs?: CategoryConfig[];
+    config: SiteConfig;
+    entityList: string;
+}
+/**
+ * State for each entity.
+ */
+export interface EntityPageState {
+    columnsVisibility: Record<string, boolean>;
+    sorting: ColumnSort[];
+}
+/**
+ * State for all entities.
+ */
+export interface EntityPageStateMapper {
+    [key: EntityPath]: EntityPageState;
+}
+/**
+ * Explore state.
+ */
+export declare type ExploreState = {
+    catalogState: CatalogState;
+    categoryViews: SelectCategory[];
+    entityPageState: EntityPageStateMapper;
+    filterCount: number;
+    filterState: SelectedFilter[];
+    isRelatedView: boolean;
+    listItems: ListItems;
+    listView: ENTITY_VIEW | undefined;
+    loading: boolean;
+    paginationState: PaginationState;
+    relatedListItems: RelatedListItems;
+    tabValue: string;
+};
+/**
+ * Model of explore state context.
+ */
+export interface ExploreStateContextProps {
+    exploreDispatch: Dispatch<ExploreAction>;
+    exploreState: ExploreState;
+}
+/**
+ * List items.
+ */
+export declare type ListItems = any[] | undefined;
+/**
+ * Pagination index.
+ */
+export interface PaginationIndex {
+    type: AzulSearchIndex;
+    value: string | null;
+}
+/**
+ * Pagination response.
+ */
+export interface PaginationResponse {
+    nextIndex: PaginationIndex | null;
+    pages: number;
+    pageSize: number;
+    previousIndex: PaginationIndex | null;
+    rows: number;
+}
+/**
+ * Pagination state.
+ */
+export interface PaginationState {
+    currentPage: number;
+    index: PaginationIndex | null;
+    nextIndex: PaginationIndex | null;
+    pages: number;
+    pageSize: number;
+    previousIndex: PaginationIndex | null;
+    rows: number;
+}
+/**
+ * Related list items.
+ */
+export declare type RelatedListItems = any[] | undefined;
+/**
+ * Explore state context for storing and using filter-related and explore state.
+ */
+export declare const ExploreStateContext: React.Context<ExploreStateContextProps>;
+/**
+ * Explore state provider for consuming components to subscribe to changes in filter-related and explore-related state.
+ * @param props - Component inputs.
+ * @param props.children - Set of children components that can possibly consume the query provider.
+ * @param props.entityListType - type of list to display
+ * @returns Provider element to be used by consumers to both update explore state and subscribe to changes in explore state.
+ */
+export declare function ExploreStateProvider({ children, entityListType, }: {
+    children: ReactNode | ReactNode[];
+    entityListType: string;
+}): JSX.Element;
+/**
+ * Explore action kind.
+ */
+export declare enum ExploreActionKind {
+    ClearFilters = "CLEAR_FILTERS",
+    PaginateTable = "PAGINATE_TABLE",
+    ProcessExploreResponse = "PROCESS_EXPLORE_RESPONSE",
+    ProcessRelatedResponse = "PROCESS_RELATED_RESPONSE",
+    ResetExploreResponse = "RESET_EXPLORE_RESPONSE",
+    ResetState = "RESET_STATE",
+    SelectEntityType = "SELECT_ENTITY_TYPE",
+    ToggleEntityView = "TOGGLE_ENTITY_VIEW",
+    UpdateColumnVisibility = "UPDATE_COLUMN_VISIBILITY",
+    UpdateFilter = "UPDATE_FILTER",
+    UpdateSorting = "UPDATE_SORTING"
+}
+/**
+ * Explore action.
+ */
+export declare type ExploreAction = ClearFiltersAction | PaginateTableAction | ProcessExploreResponseAction | ProcessRelatedResponseAction | ResetExploreResponseAction | ResetStateAction | SelectEntityTypeAction | ToggleEntityViewAction | UpdateColumnVisibilityAction | UpdateFilterAction | UpdateSortingAction;
+/**
+ * Clear filters action.
+ */
+declare type ClearFiltersAction = {
+    payload: undefined;
+    type: ExploreActionKind.ClearFilters;
+};
+/**
+ * Paginate table action.
+ */
+declare type PaginateTableAction = {
+    payload: PaginateTablePayload;
+    type: ExploreActionKind.PaginateTable;
+};
+/**
+ * Process explore response action.
+ */
+declare type ProcessExploreResponseAction = {
+    payload: ProcessExploreResponsePayload;
+    type: ExploreActionKind.ProcessExploreResponse;
+};
+/**
+ * Process related response action.
+ */
+declare type ProcessRelatedResponseAction = {
+    payload: ProcessRelatedResponsePayload;
+    type: ExploreActionKind.ProcessRelatedResponse;
+};
+/**
+ * Reset explore response action.
+ */
+declare type ResetExploreResponseAction = {
+    payload: ResetExploreResponsePayload;
+    type: ExploreActionKind.ResetExploreResponse;
+};
+/**
+ * Reset state type action.
+ */
+declare type ResetStateAction = {
+    payload: string;
+    type: ExploreActionKind.ResetState;
+};
+/**
+ * Select entity type action.
+ */
+declare type SelectEntityTypeAction = {
+    payload: string;
+    type: ExploreActionKind.SelectEntityType;
+};
+/**
+ * Toggle entity view.
+ */
+declare type ToggleEntityViewAction = {
+    payload: ToggleEntityViewPayload;
+    type: ExploreActionKind.ToggleEntityView;
+};
+/**
+ * Update column visibility action.
+ */
+declare type UpdateColumnVisibilityAction = {
+    payload: UpdateColumnVisibilityPayload;
+    type: ExploreActionKind.UpdateColumnVisibility;
+};
+/**
+ * Update filter action.
+ */
+declare type UpdateFilterAction = {
+    payload: UpdateFilterPayload;
+    type: ExploreActionKind.UpdateFilter;
+};
+/**
+ * Update sorting action.
+ */
+export declare type UpdateSortingAction = {
+    payload: UpdateSortingPayload;
+    type: ExploreActionKind.UpdateSorting;
+};
+export {};

package/lib/providers/exploreState.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExploreActionKind = exports.ExploreStateProvider = exports.ExploreStateContext = exports.ENTITY_VIEW = void 0;
+const react_1 = __importStar(require("react"));
+const useAuthentication_1 = require("../hooks/useAuthentication/useAuthentication");
+const useCategoryConfigs_1 = require("../hooks/useCategoryConfigs");
+const useCategoryFilter_1 = require("../hooks/useCategoryFilter");
+const useConfig_1 = require("../hooks/useConfig");
+const useURLFilterParams_1 = require("../hooks/useURLFilterParams");
+const constants_1 = require("./exploreState/constants");
+const utils_1 = require("./exploreState/utils");
+/**
+ * Entity view.
+ */
+var ENTITY_VIEW;
+(function (ENTITY_VIEW) {
+    ENTITY_VIEW["EXACT"] = "EXACT";
+    ENTITY_VIEW["RELATED"] = "RELATED";
+})(ENTITY_VIEW = exports.ENTITY_VIEW || (exports.ENTITY_VIEW = {}));
+/**
+ * Explore state context for storing and using filter-related and explore state.
+ */
+exports.ExploreStateContext = (0, react_1.createContext)({
+    /**
+     * The defaultValue argument is only used when a component does not have a matching Provider
+     * above it in the tree. This default value can be helpful for testing components
+     * in isolation without wrapping them. Note: passing undefined as a Provider value
+     * does not cause consuming components to use defaultValue.
+     * So basically the default value is not used...
+     */
+    // eslint-disable-next-line @typescript-eslint/no-empty-function -- default note used
+    exploreDispatch: () => { },
+    exploreState: constants_1.INITIAL_STATE,
+});
+/**
+ * Explore state provider for consuming components to subscribe to changes in filter-related and explore-related state.
+ * @param props - Component inputs.
+ * @param props.children - Set of children components that can possibly consume the query provider.
+ * @param props.entityListType - type of list to display
+ * @returns Provider element to be used by consumers to both update explore state and subscribe to changes in explore state.
+ */
+function ExploreStateProvider({ children, entityListType, }) {
+    const { config, defaultEntityListType } = (0, useConfig_1.useConfig)();
+    const categoryConfigs = (0, useCategoryConfigs_1.useCategoryConfigs)();
+    const { decodedCatalogParam, decodedFilterParam } = (0, useURLFilterParams_1.useURLFilterParams)();
+    const { isEnabled: isAuthEnabled, token } = (0, useAuthentication_1.useAuthentication)();
+    const entityList = entityListType || defaultEntityListType;
+    const [initReducerState] = (0, react_1.useState)(() => (0, utils_1.initExploreState)(config, entityList, decodedFilterParam, decodedCatalogParam));
+    const [exploreState, exploreDispatch] = (0, react_1.useReducer)((s, a) => exploreReducer(s, a, {
+        categoryConfigs,
+        config,
+        entityList,
+    }), initReducerState);
+    // does this help? https://hswolff.com/blog/how-to-usecontext-with-usereducer/
+    const exploreContextValue = (0, react_1.useMemo)(() => {
+        return { exploreDispatch, exploreState };
+    }, [exploreDispatch, exploreState]);
+    // Reset explore response when token changes.
+    (0, react_1.useEffect)(() => {
+        if (!isAuthEnabled)
+            return;
+        exploreDispatch({
+            payload: undefined,
+            type: ExploreActionKind.ResetExploreResponse,
+        });
+    }, [exploreDispatch, isAuthEnabled, token]);
+    return (react_1.default.createElement(exports.ExploreStateContext.Provider, { value: exploreContextValue }, children));
+}
+exports.ExploreStateProvider = ExploreStateProvider;
+/**
+ * Explore action kind.
+ */
+var ExploreActionKind;
+(function (ExploreActionKind) {
+    ExploreActionKind["ClearFilters"] = "CLEAR_FILTERS";
+    ExploreActionKind["PaginateTable"] = "PAGINATE_TABLE";
+    ExploreActionKind["ProcessExploreResponse"] = "PROCESS_EXPLORE_RESPONSE";
+    ExploreActionKind["ProcessRelatedResponse"] = "PROCESS_RELATED_RESPONSE";
+    ExploreActionKind["ResetExploreResponse"] = "RESET_EXPLORE_RESPONSE";
+    ExploreActionKind["ResetState"] = "RESET_STATE";
+    ExploreActionKind["SelectEntityType"] = "SELECT_ENTITY_TYPE";
+    ExploreActionKind["ToggleEntityView"] = "TOGGLE_ENTITY_VIEW";
+    ExploreActionKind["UpdateColumnVisibility"] = "UPDATE_COLUMN_VISIBILITY";
+    ExploreActionKind["UpdateFilter"] = "UPDATE_FILTER";
+    ExploreActionKind["UpdateSorting"] = "UPDATE_SORTING";
+})(ExploreActionKind = exports.ExploreActionKind || (exports.ExploreActionKind = {}));
+/**
+ * Explore reducer.
+ * @param state - Explore state.
+ * @param action - Reducer action.
+ * @param exploreContext - Explore context.
+ * @returns updated explore state.
+ */
+function exploreReducer(state, action, exploreContext) {
+    const { payload, type } = action;
+    const { categoryConfigs, config, entityList } = exploreContext;
+    switch (type) {
+        /**
+         * Clear all filters
+         **/
+        case ExploreActionKind.ClearFilters: {
+            return Object.assign(Object.assign({}, state), { filterCount: 0, filterState: [], paginationState: (0, utils_1.resetPage)(state.paginationState) });
+        }
+        /**
+         * Paginate table
+         **/
+        case ExploreActionKind.PaginateTable: {
+            const nextPaginationState = Object.assign({}, state.paginationState);
+            if (payload == "next") {
+                nextPaginationState.currentPage++;
+                nextPaginationState.index = nextPaginationState.nextIndex;
+            }
+            else {
+                nextPaginationState.currentPage--;
+                nextPaginationState.index = nextPaginationState.previousIndex;
+            }
+            return Object.assign(Object.assign({}, state), { paginationState: nextPaginationState });
+        }
+        /**
+         * Process explore response
+         **/
+        case ExploreActionKind.ProcessExploreResponse: {
+            return Object.assign(Object.assign({}, state), { categoryViews: payload.selectCategories
+                    ? (0, useCategoryFilter_1.buildCategoryViews)(payload.selectCategories, categoryConfigs, state.filterState)
+                    : state.categoryViews, listItems: payload.loading ? [] : payload.listItems, loading: payload.loading, paginationState: Object.assign(Object.assign({}, state.paginationState), payload.paginationResponse) });
+        }
+        /**
+         * Process related response
+         */
+        case ExploreActionKind.ProcessRelatedResponse: {
+            return Object.assign(Object.assign({}, state), { relatedListItems: payload.relatedListItems });
+        }
+        /**
+         * Reset explore response.
+         **/
+        case ExploreActionKind.ResetExploreResponse: {
+            return Object.assign(Object.assign({}, state), { listItems: [], loading: true, paginationState: constants_1.DEFAULT_PAGINATION_STATE });
+        }
+        /**
+         * Reset the current state to the initial
+         */
+        case ExploreActionKind.ResetState: {
+            return (0, utils_1.initExploreState)(config, entityList, "");
+        }
+        /**
+         * Select entity type
+         **/
+        case ExploreActionKind.SelectEntityType: {
+            if (payload === state.tabValue) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { listItems: [], loading: true, paginationState: (0, utils_1.resetPage)(state.paginationState), tabValue: payload });
+        }
+        /**
+         * Toggle entity view
+         */
+        case ExploreActionKind.ToggleEntityView: {
+            return Object.assign(Object.assign({}, state), { isRelatedView: payload === ENTITY_VIEW.RELATED, listView: payload });
+        }
+        /**
+         * Update filter
+         **/
+        case ExploreActionKind.UpdateFilter: {
+            const filterState = (0, useCategoryFilter_1.buildNextFilterState)(state.filterState, payload.categoryKey, payload.selectedValue, payload.selected);
+            return Object.assign(Object.assign({}, state), { filterCount: (0, utils_1.getFilterCount)(filterState), filterState, paginationState: (0, utils_1.resetPage)(state.paginationState) });
+        }
+        /**
+         * Update sorting
+         **/
+        case ExploreActionKind.UpdateSorting: {
+            const currentEntity = state.tabValue;
+            const currentPageState = state.entityPageState[currentEntity];
+            return Object.assign(Object.assign({}, state), { entityPageState: Object.assign(Object.assign({}, state.entityPageState), { [currentEntity]: Object.assign(Object.assign({}, currentPageState), { sorting: payload }) }), paginationState: (0, utils_1.resetPage)(state.paginationState) });
+        }
+        /**
+         * Update column visibility
+         **/
+        case ExploreActionKind.UpdateColumnVisibility: {
+            const currentEntity = state.tabValue;
+            const currentPageState = state.entityPageState[currentEntity];
+            return Object.assign(Object.assign({}, state), { entityPageState: Object.assign(Object.assign({}, state.entityPageState), { [currentEntity]: Object.assign(Object.assign({}, currentPageState), { columnsVisibility: payload }) }) });
+        }
+        default:
+            return state;
+    }
+}