@leav/ui 0.0.1-alpha-2 → 0.0.1-alpha-4

package/src/components/LibraryItemsList/hooks/useSearchReducer/searchReducer.test.ts

@@ -1,380 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-import {AttributeConditionFilter, FilterType, SidebarContentType} from '_ui/types/search';
-import {AttributeType, SortOrder} from '_ui/_gqlTypes';
-import {mockAttributeSimple} from '_ui/__mocks__/common/attribute';
-import {mockLibrarySimple} from '_ui/__mocks__/common/library';
-import {mockRecord} from '_ui/__mocks__/common/record';
-import searchReducer, {initialSearchState, SearchActionTypes} from './searchReducer';
-
-describe('searchReducer', () => {
-    test('UPDATE_RESULT', async () => {
-        const newState = searchReducer(
-            {...initialSearchState, loading: true},
-            {
-                type: SearchActionTypes.UPDATE_RESULT,
-                records: [
-                    {
-                        whoAmI: {
-                            ...mockRecord,
-                            id: '123456',
-                            label: 'My record'
-                        },
-                        index: 0,
-                        fields: []
-                    }
-                ],
-                totalCount: 42
-            }
-        );
-
-        expect(newState.records).toHaveLength(1);
-        expect(newState.records[0].whoAmI.id).toBe('123456');
-        expect(newState.totalCount).toBe(42);
-        expect(newState.loading).toBe(false);
-    });
-
-    test('SET_PAGINATION', async () => {
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.SET_PAGINATION,
-                page: 2
-            }
-        );
-
-        expect(newState.pagination).toBe(2);
-    });
-
-    test('SET_OFFSET', async () => {
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.SET_OFFSET,
-                offset: 50
-            }
-        );
-
-        expect(newState.offset).toBe(50);
-    });
-
-    test('SET_LOADING', async () => {
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.SET_LOADING,
-                loading: true
-            }
-        );
-
-        expect(newState.loading).toBe(true);
-    });
-
-    test('SET_SORT', async () => {
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.SET_SORT,
-                sort: {
-                    order: SortOrder.desc,
-                    field: 'label'
-                }
-            }
-        );
-
-        expect(newState.sort).toEqual({
-            order: SortOrder.desc,
-            field: 'label'
-        });
-    });
-
-    test('CANCEL_SORT', async () => {
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.CANCEL_SORT
-            }
-        );
-
-        expect(newState.sort).toBe(undefined);
-    });
-
-    test('SET_ATTRIBUTES', async () => {
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.SET_ATTRIBUTES,
-                attributes: [{...mockAttributeSimple, isLink: false, isMultiple: false, library: mockLibrarySimple.id}]
-            }
-        );
-
-        expect(newState.attributes.length).toBe(1);
-        expect(newState.attributes[0].id).toBe(mockAttributeSimple.id);
-    });
-
-    test('SET_FIELDS', async () => {
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.SET_FIELDS,
-                fields: [
-                    {
-                        id: 'field',
-                        type: AttributeType.simple,
-                        library: 'test',
-                        label: 'my field',
-                        key: '123456'
-                    }
-                ]
-            }
-        );
-
-        expect(newState.fields.length).toBe(1);
-        expect(newState.fields[0].id).toBe('field');
-    });
-
-    test('SET_FULLTEXT', async () => {
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.SET_FULLTEXT,
-                fullText: 'test'
-            }
-        );
-
-        expect(newState.fullText).toBe('test');
-    });
-
-    test('SET_FILTERS', async () => {
-        const filter = {
-            type: FilterType.ATTRIBUTE,
-            index: 1,
-            key: '1',
-            value: {value: 'test'},
-            active: true,
-            condition: AttributeConditionFilter.EQUAL
-            // FIXME: missing attribute
-        };
-
-        const newState = searchReducer(
-            {...initialSearchState},
-            {
-                type: SearchActionTypes.SET_FILTERS,
-                filters: [filter]
-            }
-        );
-
-        expect(newState.filters).toEqual(expect.arrayContaining([expect.objectContaining(filter)]));
-    });
-
-    test('RESET_FILTERS', async () => {
-        const newState = searchReducer({...initialSearchState}, {type: SearchActionTypes.RESET_FILTERS});
-
-        expect(newState.filters).toHaveLength(0);
-        expect(newState.loading).toBe(true);
-    });
-
-    test('DISABLE_FILTERS', async () => {
-        const filter = {
-            type: FilterType.ATTRIBUTE,
-            index: 1,
-            key: '1',
-            value: {value: 'test'},
-            active: true,
-            condition: AttributeConditionFilter.EQUAL
-        };
-
-        const newState = searchReducer(
-            {...initialSearchState, filters: [filter]},
-            {type: SearchActionTypes.DISABLE_FILTERS}
-        );
-
-        expect(newState.filters).toHaveLength(1);
-        expect(newState.filters[0].active).toBe(false);
-        expect(newState.loading).toBe(true);
-    });
-
-    test('ENABLE_FILTERS', async () => {
-        const filter = {
-            type: FilterType.ATTRIBUTE,
-            index: 1,
-            key: '1',
-            value: {value: 'test'},
-            active: false,
-            condition: AttributeConditionFilter.EQUAL
-        };
-
-        const newState = searchReducer(
-            {...initialSearchState, filters: [filter]},
-            {type: SearchActionTypes.ENABLE_FILTERS}
-        );
-
-        expect(newState.filters).toHaveLength(1);
-        expect(newState.filters[0].active).toBe(true);
-        expect(newState.loading).toBe(true);
-    });
-
-    test('APPLY_FILTERS', async () => {
-        const filter = {
-            type: FilterType.ATTRIBUTE,
-            index: 1,
-            key: 'id',
-            value: {value: 'test'},
-            active: true,
-            condition: AttributeConditionFilter.EQUAL
-        };
-
-        const newState = searchReducer(
-            {...initialSearchState, filters: [filter]},
-            {type: SearchActionTypes.APPLY_FILTERS}
-        );
-
-        expect(newState.filters).toHaveLength(1);
-        expect(newState.loading).toBe(true);
-    });
-
-    test('SET_VALUES_VERSIONS', async () => {
-        const valuesVersions = {
-            my_tree: {
-                label: 'My node',
-                id: '123456'
-            }
-        };
-
-        const newState = searchReducer(
-            {
-                ...initialSearchState,
-                valuesVersions: {
-                    some_tree: {
-                        label: 'Some node',
-                        id: '987654'
-                    }
-                }
-            },
-            {
-                type: SearchActionTypes.SET_VALUES_VERSIONS,
-                valuesVersions
-            }
-        );
-
-        expect(Object.keys(newState.valuesVersions)).toHaveLength(2);
-        expect(newState.valuesVersions.my_tree.id).toBe('123456');
-        expect(newState.valuesVersions.some_tree.id).toBe('987654');
-    });
-
-    test('TOGGLE_TRANSPARENCY', () => {
-        const newState = searchReducer(initialSearchState, {type: SearchActionTypes.TOGGLE_TRANSPARENCY});
-        expect(newState.showTransparency).toBe(true);
-
-        const newState2 = searchReducer(newState, {type: SearchActionTypes.TOGGLE_TRANSPARENCY});
-        expect(newState2.showTransparency).toBe(false);
-    });
-
-    test('TOGGLE_SIDEBAR', () => {
-        const newState = searchReducer(initialSearchState, {type: SearchActionTypes.TOGGLE_SIDEBAR});
-        expect(newState.sideBar.visible).toBe(true);
-
-        const newState2 = searchReducer(newState, {type: SearchActionTypes.TOGGLE_SIDEBAR});
-        expect(newState2.sideBar.visible).toBe(false);
-    });
-
-    test('SET_SIDEBAR', () => {
-        const newState = searchReducer(initialSearchState, {
-            type: SearchActionTypes.SET_SIDEBAR,
-            sidebarType: SidebarContentType.view,
-            visible: true
-        });
-
-        expect(newState.sideBar.type).toBe(SidebarContentType.view);
-        expect(newState.sideBar.visible).toBe(true);
-    });
-
-    test('SET_SELECTION', () => {
-        const newState = searchReducer(initialSearchState, {
-            type: SearchActionTypes.SET_SELECTION,
-            selected: [{id: '123456', label: 'My record', library: 'test_lib'}]
-        });
-        expect(newState.selection.selected).toEqual([{id: '123456', label: 'My record', library: 'test_lib'}]);
-
-        const newStateWithAllSelected = searchReducer(
-            {...initialSearchState, selection: {selected: [], allSelected: true}},
-            {
-                type: SearchActionTypes.SET_SELECTION,
-                selected: [{id: '123456', label: 'My record', library: 'test_lib'}]
-            }
-        );
-        expect(newStateWithAllSelected.selection.selected).toEqual([
-            {id: '123456', label: 'My record', library: 'test_lib'}
-        ]);
-        expect(newStateWithAllSelected.selection.allSelected).toBe(false);
-    });
-
-    test('TOGGLE_RECORD_SELECTION', async () => {
-        const newState = searchReducer(
-            {
-                ...initialSearchState,
-                selection: {
-                    selected: [
-                        {id: '1', label: 'My record 1', library: 'test_lib'},
-                        {id: '2', label: 'My record 2', library: 'test_lib'},
-                        {id: '3', label: 'My record 3', library: 'test_lib'}
-                    ],
-                    allSelected: false
-                }
-            },
-            {
-                type: SearchActionTypes.TOGGLE_RECORD_SELECTION,
-                record: {id: '2', label: 'My record', library: 'test_lib'}
-            }
-        );
-        expect(newState.selection.selected).toEqual([
-            {id: '1', label: 'My record 1', library: 'test_lib'},
-            {id: '3', label: 'My record 3', library: 'test_lib'}
-        ]);
-
-        const newState2 = searchReducer(newState, {
-            type: SearchActionTypes.TOGGLE_RECORD_SELECTION,
-            record: {id: '2', label: 'My record 2', library: 'test_lib'}
-        });
-        expect(newState2.selection.selected).toEqual([
-            {id: '1', label: 'My record 1', library: 'test_lib'},
-            {id: '3', label: 'My record 3', library: 'test_lib'},
-            {id: '2', label: 'My record 2', library: 'test_lib'}
-        ]);
-    });
-
-    test('SELECT_ALL', () => {
-        const newState = searchReducer(initialSearchState, {type: SearchActionTypes.SELECT_ALL});
-        expect(newState.selection.allSelected).toBe(true);
-
-        const newStateWithSelection = searchReducer(
-            {
-                ...initialSearchState,
-                selection: {selected: [{id: '123456', label: 'My record', library: 'test_lib'}], allSelected: false}
-            },
-            {type: SearchActionTypes.SELECT_ALL}
-        );
-        expect(newStateWithSelection.selection.selected).toEqual([]);
-        expect(newStateWithSelection.selection.allSelected).toBe(true);
-    });
-
-    test('CLEAR_SELECTION', () => {
-        const newState = searchReducer(
-            {
-                ...initialSearchState,
-                selection: {
-                    selected: [
-                        {id: '1', label: 'My record 1', library: 'test_lib'},
-                        {id: '2', label: 'My record 2', library: 'test_lib'},
-                        {id: '3', label: 'My record 3', library: 'test_lib'}
-                    ],
-                    allSelected: false
-                }
-            },
-            {type: SearchActionTypes.CLEAR_SELECTION}
-        );
-        expect(newState.selection.selected).toEqual([]);
-        expect(newState.selection.allSelected).toBe(false);
-    });
-});

package/src/components/LibraryItemsList/hooks/useSearchReducer/searchReducer.ts

@@ -1,302 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-import {ApolloError} from '@apollo/client';
-import getFieldsFromView from '_ui/components/LibraryItemsList/helpers/getFieldsFromView';
-import {IAttribute, IField, IFilter, ISelectedRecord, SearchMode, SidebarContentType} from '_ui/types/search';
-import {IValueVersion} from '_ui/types/values';
-import {IView, IViewDisplay} from '_ui/types/views';
-import {ViewSizes, ViewTypes} from '_ui/_gqlTypes';
-import {defaultView, viewSettingsField} from '../../constants';
-import {ISearchRecord, ISearchSort, ISearchState} from './_types';
-
-export enum SearchActionTypes {
-    UPDATE_RESULT = 'UPDATE_RESULT',
-    SET_ERROR = 'SET_ERROR',
-    SET_PAGINATION = 'SET_PAGINATION',
-    SET_OFFSET = 'SET_OFFSET',
-    SET_LOADING = 'SET_LOADING',
-    SET_SORT = 'SET_SORT',
-    CANCEL_SORT = 'CANCEL_SORT',
-    SET_ATTRIBUTES = 'SET_ATTRIBUTES',
-    SET_FIELDS = 'SET_FIELDS',
-    SET_FULLTEXT = 'SET_FULLTEXT',
-    SET_FILTERS = 'SET_FILTERS',
-    SET_VIEW_RELOAD = 'SET_VIEW_RELOAD',
-    SET_VIEW_SYNC = 'SET_VIEW_SYNC',
-    CHANGE_VIEW = 'CHANGE_VIEW',
-    SET_USER_VIEWS_ORDER = 'SET_USER_VIEWS_ORDER',
-    SET_SHARED_VIEWS_ORDER = 'SET_SHARED_VIEWS_ORDER',
-    SET_DISPLAY = 'SET_DISPLAY',
-    RESET_FILTERS = 'RESET_FILTERS',
-    DISABLE_FILTERS = 'DISABLE_FILTERS',
-    ENABLE_FILTERS = 'ENABLE_FILTERS',
-    APPLY_FILTERS = 'APPLY_FILTERS',
-    SET_VALUES_VERSIONS = 'SET_VALUES_VERSIONS',
-    TOGGLE_TRANSPARENCY = 'TOGGLE_TRANSPARENCY',
-    TOGGLE_SIDEBAR = 'TOGGLE_SIDEBAR',
-    SET_SIDEBAR = 'SET_SIDEBAR',
-    SET_SELECTION = 'SET_SELECTION',
-    TOGGLE_RECORD_SELECTION = 'TOGGLE_RECORD_SELECTION',
-    SELECT_ALL = 'SELECT_ALL',
-    CLEAR_SELECTION = 'CLEAR_SELECTION'
-}
-
-interface ISearchResult {
-    type: SearchActionTypes.UPDATE_RESULT;
-    records: ISearchRecord[];
-    totalCount: number;
-}
-
-interface ISearchResultError {
-    type: SearchActionTypes.UPDATE_RESULT;
-    error: ApolloError;
-}
-
-export type SearchAction =
-    | ({type: SearchActionTypes.UPDATE_RESULT} & (ISearchResult | ISearchResultError))
-    | {type: SearchActionTypes.SET_PAGINATION; page: number}
-    | {type: SearchActionTypes.SET_OFFSET; offset: number}
-    | {type: SearchActionTypes.SET_LOADING; loading: boolean}
-    | {type: SearchActionTypes.SET_SORT; sort: ISearchSort}
-    | {type: SearchActionTypes.CANCEL_SORT}
-    | {type: SearchActionTypes.SET_ATTRIBUTES; attributes: IAttribute[]}
-    | {type: SearchActionTypes.SET_FIELDS; fields: IField[]}
-    | {type: SearchActionTypes.SET_FULLTEXT; fullText: string}
-    | {type: SearchActionTypes.SET_FILTERS; filters: IFilter[]}
-    | {type: SearchActionTypes.SET_VIEW_RELOAD; reload: boolean}
-    | {type: SearchActionTypes.SET_VIEW_SYNC; sync: boolean}
-    | {type: SearchActionTypes.CHANGE_VIEW; view: IView}
-    | {type: SearchActionTypes.SET_DISPLAY; display: IViewDisplay}
-    | {type: SearchActionTypes.SET_USER_VIEWS_ORDER; userViewsOrder: string[]}
-    | {type: SearchActionTypes.SET_SHARED_VIEWS_ORDER; sharedViewsOrder: string[]}
-    | {type: SearchActionTypes.RESET_FILTERS}
-    | {type: SearchActionTypes.DISABLE_FILTERS}
-    | {type: SearchActionTypes.ENABLE_FILTERS}
-    | {type: SearchActionTypes.APPLY_FILTERS}
-    | {type: SearchActionTypes.SET_VALUES_VERSIONS; valuesVersions: IValueVersion}
-    | {type: SearchActionTypes.TOGGLE_TRANSPARENCY}
-    | {type: SearchActionTypes.TOGGLE_SIDEBAR}
-    | {type: SearchActionTypes.SET_SIDEBAR; sidebarType: SidebarContentType; visible: boolean}
-    | {type: SearchActionTypes.SET_SELECTION; selected: ISelectedRecord[]}
-    | {type: SearchActionTypes.TOGGLE_RECORD_SELECTION; record: ISelectedRecord}
-    | {type: SearchActionTypes.SELECT_ALL}
-    | {type: SearchActionTypes.CLEAR_SELECTION};
-
-export const initialSearchState: ISearchState = {
-    library: null,
-    records: [],
-    totalCount: 0,
-    loading: false,
-    pagination: 20,
-    offset: 0,
-    attributes: [],
-    trees: [],
-    fields: [],
-    fullText: '',
-    filters: [],
-    display: {type: ViewTypes.list, size: ViewSizes.MEDIUM},
-    view: {current: defaultView, reload: false, sync: true},
-    userViewsOrder: [],
-    sharedViewsOrder: [],
-    valuesVersions: {},
-    lang: null,
-    sideBar: {
-        visible: false,
-        type: SidebarContentType.filters
-    },
-    selection: {
-        selected: [],
-        allSelected: false
-    },
-    showTransparency: false,
-    mode: SearchMode.search
-};
-
-const checkSync = (
-    state: ISearchState,
-    toCheck: {sort: boolean; filters: boolean; display: boolean; fields: boolean; valuesVersions: boolean}
-): boolean => {
-    let sync = true;
-
-    if (toCheck.sort) {
-        sync =
-            state.sort?.field === state.view?.current?.sort?.field &&
-            state.sort?.order === state.view?.current?.sort?.order;
-    }
-
-    if (toCheck.filters) {
-        sync = sync && JSON.stringify(state.view.current?.filters) === JSON.stringify(state.filters);
-    }
-
-    if (toCheck.display) {
-        sync =
-            sync &&
-            state.display.type === state.view.current?.display?.type &&
-            state.display.size === state.view.current?.display?.size;
-    }
-
-    if (toCheck.fields) {
-        const viewFieldsKeys: string[] = !!state.view.current?.settings?.find(s => s.name === viewSettingsField)
-            ? state.view.current?.settings.find(s => s.name === viewSettingsField).value
-            : [];
-
-        sync = sync && state.fields.map(f => f.id).join('.') === viewFieldsKeys.join('.');
-    }
-
-    return sync;
-};
-
-const searchReducer = (state: ISearchState, action: SearchAction): ISearchState => {
-    let sync = checkSync(state, {
-        sort: action.type !== SearchActionTypes.SET_SORT,
-        filters: action.type !== SearchActionTypes.SET_FILTERS,
-        display: action.type !== SearchActionTypes.SET_DISPLAY,
-        fields: action.type !== SearchActionTypes.SET_FIELDS,
-        valuesVersions: action.type !== SearchActionTypes.SET_VALUES_VERSIONS
-    });
-
-    switch (action.type) {
-        case SearchActionTypes.UPDATE_RESULT: {
-            return {
-                ...state,
-                records: (action as ISearchResult).records ?? [],
-                totalCount: (action as ISearchResult).totalCount ?? 0,
-                error: (action as ISearchResultError).error,
-                loading: false
-            };
-        }
-        case SearchActionTypes.SET_PAGINATION:
-            return {...state, pagination: action.page, loading: true};
-        case SearchActionTypes.SET_OFFSET:
-            return {...state, offset: action.offset, loading: true};
-        case SearchActionTypes.SET_LOADING:
-            return {...state, loading: action.loading};
-        case SearchActionTypes.SET_SORT:
-            sync =
-                sync &&
-                state.view.current.sort?.field === action.sort.field &&
-                state.view.current.sort?.order === action.sort.order;
-
-            return {...state, sort: action.sort, view: {...state.view, sync}};
-        case SearchActionTypes.CANCEL_SORT:
-            const {sort, ...newState} = state;
-
-            sync = sync && typeof state.view.current.sort === 'undefined';
-
-            return {...newState, view: {...state.view, sync}, loading: true};
-        case SearchActionTypes.SET_ATTRIBUTES:
-            return {...state, attributes: action.attributes};
-        case SearchActionTypes.SET_FIELDS:
-            const viewFieldsKeys: IField[] = !!state.view.current.settings?.find(s => s.name === viewSettingsField)
-                ? state.view.current?.settings.find(s => s.name === viewSettingsField).value
-                : [];
-
-            sync = sync && action.fields.map(f => f.id).join('.') === viewFieldsKeys.join('.');
-
-            return {...state, fields: action.fields, view: {...state.view, sync}, loading: true};
-        case SearchActionTypes.SET_FULLTEXT:
-            return {...state, fullText: action.fullText};
-        case SearchActionTypes.SET_FILTERS:
-            sync = sync && JSON.stringify(state.view.current.filters) === JSON.stringify(action.filters);
-            return {...state, filters: action.filters, view: {...state.view, sync}};
-        case SearchActionTypes.CHANGE_VIEW:
-            return {
-                ...state,
-                view: {
-                    current: action.view,
-                    reload: true,
-                    sync: true
-                },
-                fields: getFieldsFromView(action.view, state.library, state.lang),
-                filters: action.view.filters,
-                sort: action.view.sort,
-                display: action.view.display,
-                valuesVersions: action.view.valuesVersions
-            };
-        case SearchActionTypes.SET_VIEW_RELOAD:
-            return {...state, view: {...state.view, reload: action.reload}};
-        case SearchActionTypes.SET_VIEW_SYNC:
-            return {...state, view: {...state.view, sync: action.sync}};
-        case SearchActionTypes.SET_DISPLAY:
-            sync =
-                sync &&
-                action.display.type === state.view.current.display.type &&
-                action.display.size === state.view.current.display.size;
-            return {...state, display: action.display, view: {...state.view, sync}};
-        case SearchActionTypes.SET_USER_VIEWS_ORDER:
-            return {...state, userViewsOrder: action.userViewsOrder};
-        case SearchActionTypes.SET_SHARED_VIEWS_ORDER:
-            return {...state, sharedViewsOrder: action.sharedViewsOrder};
-        case SearchActionTypes.RESET_FILTERS:
-            return {...state, filters: [], loading: true};
-        case SearchActionTypes.DISABLE_FILTERS:
-            return {
-                ...state,
-                filters: state.filters.map(f => ({...f, active: false})),
-                loading: true
-            };
-        case SearchActionTypes.ENABLE_FILTERS:
-            return {
-                ...state,
-                filters: state.filters.map(f => ({...f, active: true})),
-                loading: true
-            };
-        case SearchActionTypes.APPLY_FILTERS:
-            // Reset pagination when applying filters as this may lead to unexpected behavior
-            // if new filters return less results
-            return {
-                ...state,
-                offset: 0,
-                loading: true
-            };
-        case SearchActionTypes.SET_VALUES_VERSIONS: {
-            sync = sync && JSON.stringify(state.view.current.valuesVersions) === JSON.stringify(action.valuesVersions);
-            return {
-                ...state,
-                view: {...state.view, sync},
-                valuesVersions: {...state.valuesVersions, ...action.valuesVersions}
-            };
-        }
-        case SearchActionTypes.TOGGLE_TRANSPARENCY:
-            return {...state, showTransparency: !state.showTransparency};
-        case SearchActionTypes.TOGGLE_SIDEBAR:
-            return {...state, sideBar: {...state.sideBar, visible: !state.sideBar.visible}};
-        case SearchActionTypes.SET_SIDEBAR:
-            return {...state, sideBar: {...state.sideBar, type: action.sidebarType, visible: action.visible}};
-        case SearchActionTypes.SET_SELECTION:
-            return {...state, selection: {...state.selection, selected: action.selected, allSelected: false}};
-        case SearchActionTypes.TOGGLE_RECORD_SELECTION:
-            const currentlySelected = state.selection.selected.findIndex(s => s.id === action.record.id) > -1;
-
-            return {
-                ...state,
-                selection: {
-                    ...state.selection,
-                    selected: currentlySelected
-                        ? state.selection.selected.filter(s => s.id !== action.record.id)
-                        : [...state.selection.selected, action.record]
-                }
-            };
-        case SearchActionTypes.SELECT_ALL:
-            return {
-                ...state,
-                selection: {
-                    selected: [],
-                    allSelected: true
-                }
-            };
-        case SearchActionTypes.CLEAR_SELECTION:
-            return {
-                ...state,
-                selection: {
-                    selected: [],
-                    allSelected: false
-                }
-            };
-        default:
-            return state;
-    }
-};
-
-export default searchReducer;

package/src/components/LibraryItemsList/hooks/useSearchReducer/useSearchReducer.ts

@@ -1,9 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-import {useContext} from 'react';
-import {SearchContext} from './searchContext';
-
-const useSearchReducer = () => useContext(SearchContext);
-
-export default useSearchReducer;