@deviceinsight/ng-ui-components 6.18.0-SNAPSHOT

package/lib/esm/components/reactable/helpers/helper.js

@@ -0,0 +1,90 @@
+import * as React from 'react';
+import { Checkbox } from '@deviceinsight/ng-ui-basic-components';
+export function makePageable(items, columnDefs, filterSettings, paginationSettings, customSortFunction) {
+    if (!items) {
+        return null;
+    }
+    const { page, size, sort } = paginationSettings;
+    const sortedItems = customSortFunction ? customSortFunction(items, sort, sortItems) : sortItems(items, sort);
+    return {
+        content: sortedItems.slice(page * size, (page + 1) * size),
+        totalElements: items.length,
+        totalPages: Math.ceil(items.length / size),
+        number: page,
+        size,
+        sort: [sort]
+    };
+}
+const getDefaultFilterFn = (filterType, fieldName) => {
+    if (filterType === 'text') {
+        return (item, filterValue) => item[fieldName] && item[fieldName].toString().toLowerCase().includes(filterValue.toLowerCase());
+    }
+    else {
+        return (item, filterValue) => item[fieldName] === filterValue;
+    }
+};
+export function filterItems(items, columnDefs, filterSettings) {
+    if (items) {
+        return items.filter((item) => {
+            return Object.keys(filterSettings).every((columnName) => {
+                const filterValue = filterSettings[columnName];
+                if (filterValue && filterValue.length > 0) {
+                    const columnDef = findColumnDefByName(columnName, columnDefs);
+                    if (columnDef.filterable) {
+                        const filterFn = columnDef.filterable.filterFn ||
+                            getDefaultFilterFn(columnDef.filterable.filterType, columnDef.name);
+                        return filterFn(item, filterValue);
+                    }
+                    return false;
+                }
+                return true;
+            });
+        });
+    }
+    return null;
+}
+function findColumnDefByName(columnName, columnDefs) {
+    const columnDef = columnDefs.find((cd) => cd.name === columnName);
+    if (!columnDef) {
+        throw Error(`column definition not found for ${columnName}`);
+    }
+    return columnDef;
+}
+export function sortItems(items, sort) {
+    return items.sort((itemA, itemB) => {
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        const a = ((typeof itemA === 'object' && itemA?.[sort.property]) || 0);
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        const b = ((typeof itemB === 'object' && itemB?.[sort.property]) || 0);
+        const reverseFactor = sort.direction === 'ASC' ? 1 : -1;
+        if (a === b) {
+            return 0;
+        }
+        else if (typeof a === 'string' && typeof b === 'string') {
+            return a.localeCompare(b) * reverseFactor;
+        }
+        else if (typeof a === 'number' && typeof b === 'number') {
+            return (a - b) * reverseFactor;
+        }
+        else {
+            return a.toString().localeCompare(b.toString()) * reverseFactor;
+        }
+    });
+}
+export function extendColumnDefsWithCheckboxes(columnDefs, onSelectChange, onSelectAllChange, selectedAll, selectedItems, uniqueItemKey) {
+    return [
+        {
+            name: 'checkbox',
+            label: (React.createElement(Checkbox, { value: selectedAll, onChange: onSelectAllChange, title: {
+                    id: 'components.filtertable.selectAllItems',
+                    defaultValue: 'Select/deselect all items in search result'
+                } })),
+            sortable: false,
+            render: (item) => {
+                return (React.createElement(Checkbox, { value: selectedItems.includes(uniqueItemKey(item)), onChange: (selected) => onSelectChange(selected, item) }));
+            },
+            width: '1%'
+        },
+        ...columnDefs
+    ];
+}

package/lib/esm/components/reactable/types.d.ts

@@ -0,0 +1,38 @@
+import * as React from 'react';
+import { CSSProperties } from 'react';
+import { TranslationDescriptor } from '../../types/i18n';
+import { SortDirection } from '../../types/pagination';
+export declare type ReactableColumnLabel = string | TranslationDescriptor | React.ReactNode;
+declare type ReactableColumnFilterable<T> = {
+    filterType: 'text' | 'options';
+    filterOptions?: Array<{
+        value: string;
+        label: string | TranslationDescriptor;
+    }>;
+    filterFn?: (item: T, value: string) => boolean;
+    initialValue?: string;
+    placeholder?: string;
+};
+export declare type ReactableColumnDef<T> = {
+    name: string;
+    label: ReactableColumnLabel;
+    sortable?: boolean;
+    defaultSortDirection?: SortDirection;
+    render: (element: T) => React.ReactNode;
+    onClick?: (element: T) => void;
+    width?: string;
+    align?: 'left' | 'right' | 'center';
+    whiteSpace?: string;
+    filterable?: ReactableColumnFilterable<T>;
+};
+export declare type ReactableFilterSettings = {
+    [columName: string]: string;
+};
+export declare type ReactableRowDef<T> = {
+    onClick?: (element: T) => void;
+    getRowClass?: (element: T) => string;
+    getRowStyle?: (element: T) => CSSProperties;
+    getTooltip?: (element: T) => string;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/esm/components/reactable/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/reactable/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAC,aAAa,EAAC,MAAM,OAAO,CAAC;AAEpC,OAAO,EAAC,qBAAqB,EAAC,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAC,aAAa,EAAC,MAAM,wBAAwB,CAAC;AAErD,oBAAY,oBAAoB,GAAG,MAAM,GAAG,qBAAqB,GAAG,KAAK,CAAC,SAAS,CAAC;AAEpF,aAAK,yBAAyB,CAAC,CAAC,IAAI;IACnC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,aAAa,CAAC,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAAA;KAAC,CAAC,CAAC;IAC9E,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,oBAAY,kBAAkB,CAAC,CAAC,IAAI;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,oBAAoB,CAAC;IAC5B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oBAAoB,CAAC,EAAE,aAAa,CAAC;IACrC,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,KAAK,CAAC,SAAS,CAAC;IACxC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,yBAAyB,CAAC,CAAC,CAAC,CAAC;CAC1C,CAAC;AAEF,oBAAY,uBAAuB,GAAG;IAAC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,CAAC;AAEpE,oBAAY,eAAe,CAAC,CAAC,IAAI;IAChC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;IAC/B,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,CAAC;IACrC,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,aAAa,CAAC;IAC5C,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,CAAC;CACpC,CAAC"}

package/lib/esm/components/reactable/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/components/reactableWithClientSidePagination/ReactableWithClientSidePagination.d.ts

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { Pageable, PaginationSettings, Sort, SortDirection } from '../../types/pagination';
+import { ReactableColumnDef, ReactableRowDef, ReactableFilterSettings } from '../reactable/types';
+export declare type Props<T, ID extends string | number | undefined | null = any> = {
+    /** Array of column definitions, each column can be configured independently */
+    columnDefs: Array<ReactableColumnDef<T>>;
+    /** (Optional) can set custom event handler and/or functions in general */
+    rowDef?: ReactableRowDef<T>;
+    /** Function, sets identifier for each element in Reactable */
+    uniqueItemKey: (arg0: T) => ID;
+    /**
+     * (Deprecated) This property will be removed in the future release, use paginationSettings instead
+     * @deprecated
+     */
+    initialPaginationSettings?: PaginationSettings;
+    /** (Optional) settings for paginated content */
+    paginationSettings?: PaginationSettings;
+    /** Array of elements */
+    items: Array<T> | null | undefined;
+    /** It true, shows loading indicator */
+    isLoading: boolean;
+    /** (Optional) sets custom sort function */
+    customSortFunction?: (items: Array<T>, sort: Sort, defaultSortItems: (items: Array<T>, sort: Sort) => Array<T>) => Array<T>;
+    /** (Optional) if set, resets pagination to initial state if items change */
+    forceResetPaginationOnItemsChange?: boolean;
+    /** (Optional) Function, executed on filter */
+    onFilter?: (filterSettings: ReactableFilterSettings) => void;
+    /** (Optional) Function, executed on content change */
+    onContentChange?: (content: Array<T>) => void;
+    /** (Optional) Function, executed if filtered items change */
+    onFilteredItemsChanged?: (filteredItems: Array<T>) => void;
+    /** (Optional) if true, makes rows clickable */
+    clickable?: boolean;
+    /** If equals *true* additional column with checkboxes is rendered */
+    selectable?: boolean;
+    /** (Optional) enables selection of items */
+    selectedItems?: Array<ID>;
+    /** (Optional) function, executed on change of selected items */
+    onSelectedItemsChange?: (selectedItems: Array<ID>) => void;
+    /** (Optional) function, executed if the page size changes */
+    onChangeSize?: (size: number) => void;
+    'data-testid'?: string;
+};
+declare type State<T> = {
+    paginationSettings: PaginationSettings;
+    filterSettings: ReactableFilterSettings;
+    filteredItems: Array<T> | null | undefined;
+};
+/**
+ * Reactable displays paginated results nicely, while adding the possibility to add further functionality to each row.
+ * Each column can also be extended to be sortable and/or filterable.
+ * Also adds client-side pagination.
+ */
+export default class ReactableWithClientSidePagination<T = any, ID extends string | number | undefined | null = any> extends React.Component<Props<T, ID>, State<T>> {
+    constructor(props: Props<T>);
+    private content;
+    calculatePageNumber: (items: Array<T>, paginationSettings: PaginationSettings) => void;
+    componentDidUpdate(prevProps: Props<T>): void;
+    handleChangePage: (page: number) => void;
+    handleSort: (property: string, direction: SortDirection) => void;
+    handleFilter: (filterSettings: ReactableFilterSettings) => void;
+    getPageable: () => Pageable<T> | null | undefined;
+    handleSelectChange: (selected: boolean, item: T) => void;
+    handleSelectAllChange: (selectedAll: boolean) => void;
+    areSelectedAll: () => boolean;
+    render(): JSX.Element;
+}
+export {};
+//# sourceMappingURL=ReactableWithClientSidePagination.d.ts.map

package/lib/esm/components/reactableWithClientSidePagination/ReactableWithClientSidePagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactableWithClientSidePagination.d.ts","sourceRoot":"","sources":["../../../../src/components/reactableWithClientSidePagination/ReactableWithClientSidePagination.tsx"],"names":[],"mappings":"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"}

package/lib/esm/components/reactableWithClientSidePagination/ReactableWithClientSidePagination.js

@@ -0,0 +1,155 @@
+import * as React from 'react';
+import { isEqual, difference, uniqWith } from 'lodash';
+import Reactable from '../reactable/Reactable';
+import { extendColumnDefsWithCheckboxes, filterItems, makePageable } from '../reactable/helpers/helper';
+const DEFAULT_PAGINATION_SETTINGS = {
+    page: 0,
+    size: 15,
+    sort: {
+        property: 'name',
+        direction: 'DESC'
+    }
+};
+/**
+ * Reactable displays paginated results nicely, while adding the possibility to add further functionality to each row.
+ * Each column can also be extended to be sortable and/or filterable.
+ * Also adds client-side pagination.
+ */
+export default class ReactableWithClientSidePagination extends React.Component {
+    constructor(props) {
+        super(props);
+        this.content = [];
+        this.calculatePageNumber = (items, paginationSettings) => {
+            const { forceResetPaginationOnItemsChange } = this.props;
+            if (!forceResetPaginationOnItemsChange) {
+                const maxPageNumber = Math.floor((items.length - 1) / paginationSettings.size);
+                if (maxPageNumber <= 0) {
+                    this.handleChangePage(0);
+                }
+                else if (maxPageNumber < paginationSettings.page) {
+                    this.handleChangePage(maxPageNumber);
+                }
+            }
+            else {
+                this.handleChangePage(0);
+            }
+        };
+        this.handleChangePage = (page) => {
+            this.setState({
+                paginationSettings: { ...this.state.paginationSettings, page }
+            });
+        };
+        this.handleSort = (property, direction) => {
+            this.setState({
+                paginationSettings: {
+                    ...this.state.paginationSettings,
+                    sort: {
+                        property,
+                        direction
+                    }
+                }
+            });
+        };
+        this.handleFilter = (filterSettings) => {
+            const { items, onFilter, columnDefs, onFilteredItemsChanged } = this.props;
+            this.setState({
+                paginationSettings: { ...this.state.paginationSettings, page: 0 },
+                filterSettings
+            }, () => {
+                onFilter && onFilter(filterSettings);
+                const filteredItems = filterItems(items, columnDefs, filterSettings);
+                this.setState({
+                    filteredItems
+                });
+                onFilteredItemsChanged && filteredItems && onFilteredItemsChanged(filteredItems);
+            });
+        };
+        this.getPageable = () => {
+            const { customSortFunction, items, columnDefs, onContentChange } = this.props;
+            const { filterSettings, paginationSettings } = this.state;
+            const filteredItems = filterItems(items, columnDefs, filterSettings);
+            const pageable = makePageable(filteredItems, columnDefs, filterSettings, paginationSettings, customSortFunction);
+            if (pageable && pageable.content && !isEqual(pageable.content, this.content)) {
+                this.content = pageable.content;
+                if (onContentChange) {
+                    onContentChange(this.content);
+                }
+            }
+            return pageable;
+        };
+        this.handleSelectChange = (selected, item) => {
+            const { onSelectedItemsChange, selectedItems = [], uniqueItemKey } = this.props;
+            if (onSelectedItemsChange) {
+                if (selected) {
+                    const newSelectedItems = selectedItems.concat(uniqueItemKey(item));
+                    onSelectedItemsChange(newSelectedItems);
+                }
+                else {
+                    onSelectedItemsChange(selectedItems.filter((key) => key !== uniqueItemKey(item)));
+                }
+            }
+            else {
+                console.warn('ReactableWithClientSidePagination: onSelectedItemsChange property is missing');
+            }
+        };
+        this.handleSelectAllChange = (selectedAll) => {
+            const { onSelectedItemsChange, items, selectedItems = [], uniqueItemKey } = this.props;
+            const { filteredItems } = this.state;
+            const visibleItems = (filteredItems || items || []).map(uniqueItemKey);
+            if (onSelectedItemsChange) {
+                if (selectedAll) {
+                    onSelectedItemsChange(uniqWith([...selectedItems, ...visibleItems], isEqual).sort());
+                }
+                else {
+                    onSelectedItemsChange(difference(selectedItems, visibleItems));
+                }
+            }
+            else {
+                console.warn('ReactableWithClientSidePagination: onSelectedItemsChange property is missing');
+            }
+        };
+        this.areSelectedAll = () => {
+            const { items, selectedItems, uniqueItemKey } = this.props;
+            const { filteredItems } = this.state;
+            const visibleItems = filteredItems || items || [];
+            return (!!selectedItems && visibleItems.every((item) => selectedItems.some((key) => key === uniqueItemKey(item))));
+        };
+        let paginationSettings = DEFAULT_PAGINATION_SETTINGS;
+        if (props.paginationSettings) {
+            paginationSettings = props.paginationSettings;
+        }
+        else if (props.initialPaginationSettings) {
+            console.warn('initialPaginationSettings is deprecated! Please use "paginationSettings" instead');
+            paginationSettings = props.initialPaginationSettings;
+        }
+        else {
+            console.error('Missing pagination settings!');
+        }
+        this.state = {
+            paginationSettings: paginationSettings || DEFAULT_PAGINATION_SETTINGS,
+            filterSettings: {},
+            filteredItems: null
+        };
+    }
+    componentDidUpdate(prevProps) {
+        const { items } = this.props;
+        const { items: prevItems } = prevProps;
+        const settings = this.props.paginationSettings || this.props.initialPaginationSettings;
+        const prevSettings = prevProps.paginationSettings || prevProps.initialPaginationSettings;
+        if (items && prevItems && items.length !== prevItems.length) {
+            this.calculatePageNumber(items, this.state.paginationSettings);
+        }
+        if (settings && !isEqual(settings, prevSettings)) {
+            this.setState({
+                paginationSettings: settings
+            }, () => this.handleChangePage(0));
+        }
+    }
+    render() {
+        const { uniqueItemKey, isLoading, columnDefs, rowDef, clickable, selectable, selectedItems, onChangeSize } = this.props;
+        const finalColumnDefs = selectable
+            ? extendColumnDefsWithCheckboxes(columnDefs, this.handleSelectChange, this.handleSelectAllChange, this.areSelectedAll(), selectedItems || [], uniqueItemKey)
+            : columnDefs;
+        return (React.createElement(Reactable, { columnDefs: finalColumnDefs, rowDef: rowDef, uniqueItemKey: uniqueItemKey, paginationSettings: this.state.paginationSettings, onChangePage: this.handleChangePage, onChangeSize: onChangeSize, onSort: this.handleSort, onFilter: this.handleFilter, pageable: this.getPageable(), isLoading: isLoading, clickable: clickable, "data-testid": this.props['data-testid'] }));
+    }
+}

package/lib/esm/components/reactableWithClientSidePagination/__tests__/ReactableWithClientSidePagination.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ReactableWithClientSidePagination.spec.d.ts.map

package/lib/esm/components/reactableWithClientSidePagination/__tests__/ReactableWithClientSidePagination.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactableWithClientSidePagination.spec.d.ts","sourceRoot":"","sources":["../../../../../src/components/reactableWithClientSidePagination/__tests__/ReactableWithClientSidePagination.spec.tsx"],"names":[],"mappings":""}

package/lib/esm/components/reactableWithClientSidePagination/__tests__/ReactableWithClientSidePagination.spec.js

@@ -0,0 +1,138 @@
+import * as React from 'react';
+import { shallow } from 'enzyme';
+import toJson from 'enzyme-to-json';
+import ReactableWithClientSidePagination from '../ReactableWithClientSidePagination';
+const ITEMS = [
+    {
+        id: 1,
+        name: 'Hans Wurst',
+        description: 'Lorem ipsum dolor sit amet, consectetur adipisici elit'
+    },
+    {
+        id: 2,
+        name: 'August Tina',
+        description: "Hopfen und Malz, Gott erhalt's"
+    },
+    {
+        id: 3,
+        name: 'Paul Aner',
+        description: 'Salve pater patriae'
+    },
+    {
+        id: 4,
+        name: 'Franz Iskaner',
+        description: 'Da braut sich was zusammen'
+    }
+];
+const INITIAL_PAGINATION_SETTINGS = {
+    page: 0,
+    size: ITEMS.length,
+    sort: {
+        property: 'name',
+        direction: 'ASC'
+    }
+};
+const COLUMN_DEFS = [
+    {
+        name: 'name',
+        render: (item) => item.name,
+        filterable: {
+            filterType: 'text',
+            filterFn: (item, value) => new RegExp(value).test(item.name)
+        }
+    },
+    {
+        name: 'description',
+        render: (item) => item.description
+    }
+];
+const COMMON_PROPS = {
+    columnDefs: COLUMN_DEFS,
+    uniqueItemKey: (item) => item.id,
+    paginationSettings: INITIAL_PAGINATION_SETTINGS,
+    items: ITEMS,
+    selectable: true,
+    isLoading: false
+};
+describe('ReactableWithClientSidePagination.js', () => {
+    describe('selectable feature', () => {
+        it('should match snapshot', () => {
+            const wrapper = shallow(
+            // @ts-ignore
+            React.createElement(ReactableWithClientSidePagination, { ...COMMON_PROPS, selectedItems: [], onSelectedItemsChange: () => { } }));
+            expect(toJson(wrapper)).toMatchSnapshot();
+        });
+        it('should call the callback with correct argument when checkbox is checked', () => {
+            const selectedItemsBefore = [1, 2];
+            const selectedItemsAfter = [1, 2, 4];
+            const selectedItemsChangeHandler = jest.fn();
+            const wrapper = shallow(
+            // @ts-ignore
+            React.createElement(ReactableWithClientSidePagination, { ...COMMON_PROPS, selectedItems: selectedItemsBefore, onSelectedItemsChange: selectedItemsChangeHandler }));
+            // @ts-ignore
+            wrapper.instance().handleSelectChange(true, ITEMS[3]);
+            expect(selectedItemsChangeHandler.mock.calls[0][0]).toEqual(selectedItemsAfter);
+        });
+        it('should call the callback with correct argument when checkbox is unchecked', () => {
+            const selectedItemsBefore = [1, 2, 4];
+            const selectedItemsAfter = [1, 2];
+            const selectedItemsChangeHandler = jest.fn();
+            const wrapper = shallow(
+            // @ts-ignore
+            React.createElement(ReactableWithClientSidePagination, { ...COMMON_PROPS, selectedItems: selectedItemsBefore, onSelectedItemsChange: selectedItemsChangeHandler }));
+            // @ts-ignore
+            wrapper.instance().handleSelectChange(false, ITEMS[3]);
+            expect(selectedItemsChangeHandler.mock.calls[0][0]).toEqual(selectedItemsAfter);
+        });
+        it('should call the callback with correct argument when the selectAll checkbox is checked', () => {
+            const selectedItemsBefore = [1];
+            const selectedItemsAfter = [1, 2, 3, 4];
+            const selectedItemsChangeHandler = jest.fn();
+            const wrapper = shallow(
+            // @ts-ignore
+            React.createElement(ReactableWithClientSidePagination, { ...COMMON_PROPS, selectedItems: selectedItemsBefore, onSelectedItemsChange: selectedItemsChangeHandler }));
+            // @ts-ignore
+            wrapper.instance().handleSelectAllChange(true);
+            expect(selectedItemsChangeHandler.mock.calls[0][0]).toEqual(selectedItemsAfter);
+        });
+        it('should call the callback with correct argument when the selectAll checkbox is unchecked', () => {
+            const selectedItemsBefore = [1, 2, 3, 4];
+            // @ts-ignore
+            const selectedItemsAfter = [];
+            const selectedItemsChangeHandler = jest.fn();
+            const wrapper = shallow(
+            // @ts-ignore
+            React.createElement(ReactableWithClientSidePagination, { ...COMMON_PROPS, selectedItems: selectedItemsBefore, onSelectedItemsChange: selectedItemsChangeHandler }));
+            // @ts-ignore
+            wrapper.instance().handleSelectAllChange(false);
+            // @ts-ignore
+            expect(selectedItemsChangeHandler.mock.calls[0][0]).toEqual(selectedItemsAfter);
+        });
+        it('should select all available items if selectAll checkbox is checked and data is filtered', () => {
+            const selectedItemsBefore = [1, 4];
+            const selectedItemsAfter = [1, 2, 4];
+            const selectedItemsChangeHandler = jest.fn();
+            const wrapper = shallow(
+            // @ts-ignore
+            React.createElement(ReactableWithClientSidePagination, { ...COMMON_PROPS, selectedItems: selectedItemsBefore, onSelectedItemsChange: selectedItemsChangeHandler }));
+            // @ts-ignore
+            wrapper.instance().handleFilter({ name: ITEMS[1].name });
+            // @ts-ignore
+            wrapper.instance().handleSelectAllChange(true);
+            expect(selectedItemsChangeHandler.mock.calls[0][0]).toEqual(selectedItemsAfter);
+        });
+        it('should unselect all available items if selectAll checkbox is checked and data is filtered', () => {
+            const selectedItemsBefore = [1, 2, 3, 4];
+            const selectedItemsAfter = [1, 3, 4];
+            const selectedItemsChangeHandler = jest.fn();
+            const wrapper = shallow(
+            // @ts-ignore
+            React.createElement(ReactableWithClientSidePagination, { ...COMMON_PROPS, selectedItems: selectedItemsBefore, onSelectedItemsChange: selectedItemsChangeHandler }));
+            // @ts-ignore
+            wrapper.instance().handleFilter({ name: ITEMS[1].name });
+            // @ts-ignore
+            wrapper.instance().handleSelectAllChange(false);
+            expect(selectedItemsChangeHandler.mock.calls[0][0]).toEqual(selectedItemsAfter);
+        });
+    });
+});

package/lib/esm/components/slider/Slider.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+export declare type Props = {
+    /** minimum value the slider renders */
+    min: number;
+    /** maximum value the slider renders */
+    max: number;
+    /** step in which increments/decrements have to be made */
+    step?: number;
+    /** current value of the slider */
+    value: number;
+    /** show or hide tooltip (default: true) */
+    tooltip?: boolean;
+    /** object containing key-value pairs to label the slider */
+    labels?: Record<string, number | string>;
+    /** formats the value in label or tooltip */
+    format?: (value: number) => string;
+    /** gets called whenever the slider handle is being dragged or clicked */
+    onChange?: (value: number) => void;
+    /** gets called whenever the user stops dragging the slider handle */
+    onChangeComplete?: (value: number) => void;
+    /**  maximum value the slider can hold */
+    limit?: number;
+};
+/**
+ * Enables picking the desired value from a specified range.
+ * Can have a tooltip and labels
+ */
+declare const Slider: ({ min, max, step, value, tooltip, labels, format, onChange, onChangeComplete, limit }: Props) => JSX.Element;
+export default Slider;
+//# sourceMappingURL=Slider.d.ts.map

package/lib/esm/components/slider/Slider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slider.d.ts","sourceRoot":"","sources":["../../../../src/components/slider/Slider.tsx"],"names":[],"mappings":";AAKA,oBAAY,KAAK,GAAG;IACnB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IAEZ,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IAEZ,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IAEd,2CAA2C;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IAEzC,4CAA4C;IAC5C,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAEnC,yEAAyE;IACzE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAEnC,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE3C,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAIF;;;GAGG;AACH,QAAA,MAAM,MAAM,0FAAgG,KAAK,gBAoChH,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/lib/esm/components/slider/Slider.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import RcSlider, { createSliderWithTooltip } from 'rc-slider';
+import useLimitStyling from './useLimitStyling';
+const RcSliderWithTooltip = createSliderWithTooltip(RcSlider);
+/**
+ * Enables picking the desired value from a specified range.
+ * Can have a tooltip and labels
+ */
+const Slider = ({ min, max, step, value, tooltip = true, labels, format, onChange, onChangeComplete, limit }) => {
+    const setSliderRef = useLimitStyling(limit, min, max);
+    const handleChange = (value) => {
+        if (!onChange)
+            return;
+        const numericValue = typeof value === 'number' ? value : value[0];
+        const allowedValue = limit != null ? Math.min(numericValue, limit) : numericValue;
+        onChange(allowedValue);
+    };
+    const handleChangeComplete = () => {
+        if (!onChangeComplete) {
+            return;
+        }
+        onChangeComplete(value);
+    };
+    const basicProps = {
+        min,
+        max,
+        step,
+        value,
+        onChange: handleChange,
+        onAfterChange: handleChangeComplete,
+        marks: labels
+    };
+    return (React.createElement("div", { className: "di slider", ref: setSliderRef }, tooltip ? (React.createElement(RcSliderWithTooltip, { ...basicProps, className: "di slider with-tooltip", tipFormatter: format })) : (React.createElement(RcSlider, { ...basicProps, className: "di slider" }))));
+};
+export default Slider;

package/lib/esm/components/slider/useLimitStyling.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export default function useLimitStyling(limit: number | undefined, min: number, max: number): import("react").Dispatch<import("react").SetStateAction<HTMLDivElement | null>>;
+//# sourceMappingURL=useLimitStyling.d.ts.map

package/lib/esm/components/slider/useLimitStyling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLimitStyling.d.ts","sourceRoot":"","sources":["../../../../src/components/slider/useLimitStyling.ts"],"names":[],"mappings":";AAEA,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,mFAiD1F"}

package/lib/esm/components/slider/useLimitStyling.js

@@ -0,0 +1,49 @@
+import { useCallback, useEffect, useState } from 'react';
+export default function useLimitStyling(limit, min, max) {
+    const [slider, setSlider] = useState(null);
+    useEffect(() => {
+        if (slider) {
+            const containerEl = slider.querySelector('.rc-slider-rail');
+            if (!containerEl)
+                throw new Error('.rc-slider-rail element missing');
+            const disabledAreaEl = containerEl?.querySelector(`.disabled-area-element`);
+            const sliderWidth = containerEl.getBoundingClientRect().width;
+            if (disabledAreaEl) {
+                if (limit == null) {
+                    disabledAreaEl.remove();
+                }
+                else {
+                    const width = Math.round(((max - limit) / (max - min)) * sliderWidth);
+                    disabledAreaEl.style.width = `${width}px`;
+                }
+            }
+            else if (limit != null) {
+                const width = Math.round(((max - limit) / (max - min)) * sliderWidth);
+                const disabledAreaEl = document.createElement('div');
+                disabledAreaEl.classList.add('disabled-area-element');
+                disabledAreaEl.style.width = `${width}px`;
+                containerEl.appendChild(disabledAreaEl);
+            }
+        }
+    }, [limit, slider, min, max]);
+    const updateLimitAreaSize = useCallback(() => {
+        if (slider && limit != null) {
+            const containerEl = slider.querySelector('.rc-slider-rail');
+            if (!containerEl)
+                throw new Error('.rc-slider-rail element missing');
+            const disabledAreaEl = containerEl?.querySelector(`.disabled-area-element`);
+            const sliderWidth = containerEl.getBoundingClientRect().width;
+            if (disabledAreaEl) {
+                const width = Math.round(((max - limit) / (max - min)) * sliderWidth);
+                disabledAreaEl.style.width = `${width}px`;
+            }
+        }
+    }, [limit, max, min, slider]);
+    useEffect(() => {
+        if (slider) {
+            const resizeObserver = new ResizeObserver(() => updateLimitAreaSize());
+            resizeObserver.observe(slider);
+        }
+    }, [slider, updateLimitAreaSize]);
+    return setSlider;
+}

package/lib/esm/components/svg/SvgImage.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Modification } from './types';
+export declare type Props = {
+    /** base64 encoded content of the SVG file */
+    imageData: string | null | undefined;
+    /** list of modifications that should be applied to the svg elements */
+    modifications?: Modification[];
+    /** called with list of conflicting IDs which means IDs existing in the DOM and duplicated by the elements from the SVG */
+    onConflict?: (conflictingIds: string[]) => void;
+};
+export default function SvgImage({ imageData, modifications, onConflict }: Props): JSX.Element;
+//# sourceMappingURL=SvgImage.d.ts.map