@geotab/zenith 1.26.6 → 2.0.0-beta.1

package/esm/groupsFilter/groupsFilterStatesHelper.js

@@ -0,0 +1,67 @@
+import { getAdvancedFilterString, prepareAdvancedOptions, prepareOptions, prepareSelectedOptions } from "./groupsFilterHelper";
+import { compareFilters, getDefaultFilterState, getGroupDescription } from "./groupsHelper";
+import { getAdvancedFilterNamedState, getCurrentlyDeselectedMenu, getCurrentlySelectedMenu, getGroupsTreeItem, getMenu, getPathToRoot, getSearchResultFromObject, getSelectedChildren } from "./stateReducer/stateReducerHelper";
+export const getBackButtonName = (stateObj, currentId) => {
+    if (!currentId) {
+        return undefined;
+    }
+    const currentEl = getGroupsTreeItem(stateObj, currentId);
+    return currentEl ? getGroupDescription(currentEl, stateObj.translate) : undefined;
+};
+export const isAllChildrenSelected = (stateObj, currentId) => {
+    if (!currentId) {
+        return false;
+    }
+    const selectedIds = new Set(stateObj.selectedIds);
+    const currentEl = getGroupsTreeItem(stateObj, currentId);
+    return currentEl && currentEl.children && currentEl.children.length ? currentEl.children.every(el => selectedIds.has(el.id)) : false;
+};
+const defaultGroupsMenu = { builtInGroups: [], userGroups: [], currentId: undefined };
+export const createInitialOptions = (stateObj, limit, searchStr, value) => {
+    let options;
+    if (!searchStr) {
+        options = getMenu(stateObj);
+    }
+    else {
+        options = getSearchResultFromObject(stateObj, searchStr) || defaultGroupsMenu;
+    }
+    const preparedOptions = prepareOptions(stateObj.translate, value ? options[value].slice(0, limit) : [...options.builtInGroups.slice(0, limit / 2), ...options.userGroups.slice(0, limit / 2)], () => stateObj.selectedIds, (id) => getSelectedChildren(stateObj, id), false, (id) => getPathToRoot(stateObj, id));
+    return preparedOptions;
+};
+export const createAdjustmentOptions = (stateObj, isWithColor, limit, currentId, value) => {
+    let options;
+    if (!currentId) {
+        options = defaultGroupsMenu;
+    }
+    else {
+        options = getMenu(stateObj, currentId);
+    }
+    const preparedOptions = prepareOptions(stateObj.translate, value ? options[value].slice(0, limit) : [...options.builtInGroups.slice(0, limit / 2), ...options.userGroups.slice(0, limit / 2)], () => stateObj.selectedIds, (id) => getSelectedChildren(stateObj, id), isWithColor, (id) => getPathToRoot(stateObj, id));
+    return preparedOptions;
+};
+const getAdvancedFilterOptions = (state, newAdvancedOptions, additionalState) => {
+    let advancedFilter;
+    if (additionalState && !compareFilters(additionalState, getDefaultFilterState())) {
+        advancedFilter = getAdvancedFilterNamedState(state, additionalState);
+    }
+    else {
+        advancedFilter = newAdvancedOptions && !compareFilters(newAdvancedOptions, getDefaultFilterState()) ? getAdvancedFilterNamedState(state, newAdvancedOptions) : undefined;
+    }
+    const advancedOptionsStrings = newAdvancedOptions ? getAdvancedFilterString(state.translate, getAdvancedFilterNamedState(state, state.advancedFilterState)) : "";
+    const currentOptionsString = advancedFilter ? getAdvancedFilterString(state.translate, advancedFilter) : "";
+    return advancedFilter ? prepareAdvancedOptions([currentOptionsString], advancedOptionsStrings) : [];
+};
+export const createCurrentlySelectedOptions = (stateObj, value, isWithColor, additionalItems, limit, additionalState) => {
+    const selectedItems = getCurrentlySelectedMenu(stateObj);
+    const deselectedItems = additionalItems.length ? getCurrentlyDeselectedMenu(stateObj, additionalItems) : undefined;
+    let preparedOptions;
+    if (value === "advancedGroups") {
+        preparedOptions = getAdvancedFilterOptions(stateObj, selectedItems.advancedGroups, additionalState);
+    }
+    else {
+        const sortedItems = deselectedItems ? [...selectedItems[value], ...deselectedItems[value]].sort((val1, val2) => val1.id > val2.id ? 1 : -1)
+            : [...selectedItems[value]].sort((val1, val2) => val1.id > val2.id ? 1 : -1);
+        preparedOptions = prepareSelectedOptions(stateObj.translate, sortedItems.slice(0, limit), () => stateObj.selectedIds, isWithColor, (id) => getPathToRoot(stateObj, id));
+    }
+    return preparedOptions;
+};

package/esm/groupsFilter/groupsFilterTrigger.d.ts

@@ -0,0 +1,23 @@
+import React, { ChangeEvent } from "react";
+import "./groupsFilter.less";
+interface IGroupsFilterTrigger {
+    value: string;
+    className?: string;
+    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    handleClick: () => void;
+    /**
+    * @deprecated
+    * @param translate - will be removed in the next major release
+    */
+    translate?: (s: string) => string;
+    placeholder?: string;
+    id?: string;
+    isOpenPopup: boolean;
+    count: number;
+    withGlobeIcon: boolean;
+    inputRef: React.RefObject<HTMLInputElement>;
+    fullSize?: boolean;
+}
+export declare const GroupsFilterTrigger: React.ForwardRefExoticComponent<IGroupsFilterTrigger & React.RefAttributes<HTMLDivElement>>;
+export declare const TRANSLATIONS: string[];
+export {};

package/esm/groupsFilter/groupsFilterTrigger.js

@@ -0,0 +1,44 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useId } from "react";
+import { classNames } from "../commonHelpers/classNames/classNames";
+import { GroupsFilterLabelBox } from "./groupsFilterLabelBox";
+import { TextInputRaw } from "../textInputRaw/textInputRaw";
+import { IconChevronDownSmall } from "../icons/iconChevronDownSmall";
+import { useLanguage } from "../utils/localization/useLanguage";
+export const GroupsFilterTrigger = React.forwardRef((_a, ref) => {
+    var { value, className = "", onChange, placeholder, isOpenPopup, count, withGlobeIcon, inputRef, handleClick, translate: _, fullSize } = _a, otherProps = __rest(_a, ["value", "className", "onChange", "placeholder", "isOpenPopup", "count", "withGlobeIcon", "inputRef", "handleClick", "translate", "fullSize"]);
+    const { translate } = useLanguage();
+    const groupsFilterId = useId();
+    const handleKeydown = (e) => {
+        if (e.key === "Enter" && !isOpenPopup) {
+            handleClick();
+        }
+        if (e.key === "Escape" && isOpenPopup && e.nativeEvent) {
+            e.nativeEvent.stopImmediatePropagation();
+            handleClick();
+        }
+    };
+    const clickHandler = (e) => {
+        if (e.target === inputRef.current && isOpenPopup) {
+            return;
+        }
+        handleClick();
+    };
+    return _jsxs("div", Object.assign({ className: classNames(["zen-groups-filter"]), ref: ref }, otherProps, { onClick: clickHandler, role: "combobox", children: [_jsxs("div", { className: classNames(["zen-groups-filter__search-container", fullSize ? "zen-groups-filter__search-container--full-size" : "", className]), children: [_jsx("div", { className: "zen-groups-filter__input-container", onKeyDown: handleKeydown, children: _jsx(TextInputRaw, { value: value, placeholder: placeholder || translate("Filter by group"), className: classNames(["zen-groups-filter__input", count > 0 ? "zen-groups-filter__input--selected" : ""]), onChange: onChange, disabled: false, type: "text", ref: inputRef, id: groupsFilterId }) }), _jsx("div", { className: "zen-groups-filter__search-input zen-groups-filter__search-input--post", children: _jsx(GroupsFilterLabelBox, { count: count, withGlobeIcon: withGlobeIcon }) })] }), _jsx("button", { tabIndex: -1, "aria-hidden": "true", type: "button", className: "zen-groups-filter__popup-trigger", title: translate("Open filter"), children: _jsx(IconChevronDownSmall, { className: isOpenPopup ? "zen-groups-filter__arrow-icon--up" : "zen-groups-filter__arrow-icon--down", size: "large" }) })] }));
+});
+GroupsFilterTrigger.displayName = "GroupsFilterTrigger";
+export const TRANSLATIONS = [
+    "Filter by group",
+    "Open filter"
+];

package/esm/groupsFilter/groupsHelper.d.ts

@@ -0,0 +1,28 @@
+import { IEntityWithId } from "../commonHelpers/entity";
+import { IFilterState, IGroup, ILeafStateItem, ILinkedGroup, INamedEntity, RelationOperator, TFilterVal } from "./groupsFilterInterfaces";
+export declare const ENTIRE_ORGANIZATION_GROUP_ID = "GroupCompanyId";
+export declare const DEFAULT_RELATION_OPERATOR: RelationOperator;
+export declare const getDefaultFilterState: <T extends IEntityWithId = IEntityWithId>() => ILeafStateItem<T>;
+export declare const systemSecurityGroups: string[];
+export declare const rootSecurityGroups: string[];
+export declare const rootGroups: string[];
+export declare const rootDefectGroups: string[];
+export declare const defaultPrivateGroupId = "GroupPrivateUserId";
+export declare const allSystemGroups: string[];
+export declare function makeBoolHash(arr: (IEntityWithId | string)[]): {
+    [itemId: string]: boolean;
+};
+export declare const isSystemGroup: (groupId: string) => boolean;
+export declare const getGroupDescription: (group: IEntityWithId & Partial<INamedEntity>, translate: (s: string) => string) => string;
+export declare function createLinkedTree<T extends ILinkedGroup>(groups: IGroup[], customCreateNode?: (group: IGroup) => T): T[];
+export declare const isIdEntity: (entity: any) => entity is IEntityWithId;
+export declare function isEntireOrganization(filter: TFilterVal<IEntityWithId | string>): boolean;
+export declare const isFilterState: <T, U>(item: IFilterState<T> | U) => item is IFilterState<T>;
+export declare const mapFilterState: <TSource, TResult>(state: IFilterState<TSource>, mapFunc: (item: TSource) => TResult) => IFilterState<TResult>;
+export declare const getId: (entity: IEntityWithId | string) => string;
+type TEntity = IEntityWithId | string;
+export declare const mergeItems: <TSource extends TEntity>(items: (IFilterState<TSource> | TSource)[][]) => (TSource | IFilterState<TSource>)[];
+export declare const simplifyFilterState: <TSource extends string | IEntityWithId>(state: IFilterState<TSource>) => IFilterState<TSource>;
+export declare const toFilterState: (state: IFilterState<IEntityWithId | string> | unknown[]) => IFilterState;
+export declare const compareFilters: <T extends string | IEntityWithId, U extends string | IEntityWithId>(filter1: TFilterVal<T>, filter2: TFilterVal<U>) => boolean;
+export {};

package/esm/groupsFilter/groupsHelper.js

@@ -0,0 +1,236 @@
+import { RelationOperator } from "./groupsFilterInterfaces";
+export const ENTIRE_ORGANIZATION_GROUP_ID = "GroupCompanyId";
+export const DEFAULT_RELATION_OPERATOR = RelationOperator.OR;
+export const getDefaultFilterState = () => ({
+    relation: DEFAULT_RELATION_OPERATOR,
+    items: [{ id: ENTIRE_ORGANIZATION_GROUP_ID }]
+});
+const systemGroups = [
+    "GroupCompanyId",
+    "GroupDriverActivityGroupId",
+    "GroupBusinessGroupId",
+    "GroupPersonalGroupId",
+    "GroupAssetInformationId",
+    "GroupAssetTypeId",
+    "GroupVehicleId",
+    "GroupTrailerId",
+    "GroupPowertrainAndFuelTypeId",
+    "GroupInternalCombustionEngineId",
+    "GroupGasolinePetrolId",
+    "GroupDieselId",
+    "GroupEthanolId",
+    "GroupBiodieselId",
+    "GroupCompressedNaturalGasId",
+    "GroupOtherFuelId",
+    "GroupPropaneLiquifiedPetroleumGasId",
+    "GroupElectricHybridPluginId",
+    "GroupBatteryElectricVehicleId",
+    "GroupPluginHybridElectricVehicleId",
+    "GroupManuallyClassifiedPowertrainId",
+    "GroupFuelCellElectricVehicleId"
+];
+export const systemSecurityGroups = [
+    "GroupEverythingSecurityId",
+    "GroupSupervisorSecurityId",
+    "GroupUserSecurityId",
+    "GroupViewOnlySecurityId",
+    "GroupDriveUserSecurityId",
+    "GroupViewMapOnlySecurityId",
+    "GroupNothingSecurityId"
+];
+export const rootSecurityGroups = [
+    "GroupSecurityId"
+];
+export const rootGroups = [
+    "GroupRootId"
+];
+export const rootDefectGroups = [
+    "GroupDefectsId"
+];
+export const defaultPrivateGroupId = "GroupPrivateUserId";
+export const allSystemGroups = [
+    ...systemGroups,
+    ...rootSecurityGroups,
+    ...rootGroups,
+    ...systemSecurityGroups,
+    ...rootDefectGroups,
+    defaultPrivateGroupId
+];
+export function makeBoolHash(arr) {
+    return (arr || []).reduce(function (result, item) {
+        result[item.id || item] = true;
+        return result;
+    }, {});
+}
+const systemGroupIds = makeBoolHash(allSystemGroups);
+export const isSystemGroup = (groupId) => !!(groupId && systemGroupIds[groupId]);
+export const getGroupDescription = function (group, translate) {
+    if (isSystemGroup(group === null || group === void 0 ? void 0 : group.id)) {
+        return translate(group.id);
+    }
+    return (group === null || group === void 0 ? void 0 : group.name) || "";
+};
+export function createLinkedTree(groups, customCreateNode) {
+    const createNode = customCreateNode || ((g) => (Object.assign(Object.assign({}, g), { parent: undefined })));
+    const nodeLookup = groups.reduce((hash, group) => {
+        hash.set(group.id, createNode(group));
+        return hash;
+    }, new Map());
+    const rGroups = groups.reduce((root, group) => {
+        const node = nodeLookup.get(group.id);
+        if (node) {
+            node.children = (group.children || []).map(child => {
+                const childNode = nodeLookup.get(child.id);
+                if (childNode) {
+                    childNode.parent = node;
+                }
+                const rootChild = root.get(child.id);
+                if (rootChild) {
+                    root.set(child.id, undefined);
+                }
+                return childNode;
+            }).filter(c => c !== undefined);
+            if (!node["parent"]) {
+                root.set(node === null || node === void 0 ? void 0 : node.id, node);
+            }
+        }
+        return root;
+    }, new Map());
+    for (const [key, value] of rGroups) {
+        if (value === undefined) {
+            rGroups.delete(key);
+        }
+    }
+    return Array.from(rGroups.values());
+}
+export const isIdEntity = (entity) => !!(entity && entity.id);
+export function isEntireOrganization(filter) {
+    let items = filter;
+    const isCompanyGroup = (entity) => {
+        const id = isIdEntity(entity) ? entity.id : entity;
+        return id === ENTIRE_ORGANIZATION_GROUP_ID;
+    };
+    const isFilterState = (entity) => entity.relation && Array.isArray(entity.items);
+    // If filter is advanced but contains only one level then we can check level items
+    if (isFilterState(filter) && (!filter.items.length || filter.items.every(item => !isFilterState(item)))) {
+        items = filter.items || [];
+        // If AND relation and all items are CompanyGroups then whole filer is entire organization
+        if (filter.relation === RelationOperator.AND) {
+            return items.every(isCompanyGroup);
+        }
+        // If OR then any item should be CompanyGroupsId
+        return items.some(isCompanyGroup);
+    }
+    return items && Array.isArray(items) && (!items.length || items.some(isCompanyGroup));
+}
+export const isFilterState = (item) => item && item.relation !== undefined;
+export const mapFilterState = (state, mapFunc) => {
+    const processItem = (item) => (Object.assign(Object.assign({}, item), { items: item.items.map(childItem => isFilterState(childItem)
+            ? processItem(childItem)
+            : mapFunc(childItem)) }));
+    return processItem(state);
+};
+export const getId = (entity) => isIdEntity(entity) ? entity.id : entity;
+const getSimpleItems = (entity) => entity.filter(e => !isFilterState(e));
+export const mergeItems = (items) => {
+    const firstItem = items[0] || [];
+    let allIds = getSimpleItems(firstItem).map(getId);
+    return items.reduce((res, item) => {
+        const advancedSubitems = item.filter(isFilterState);
+        const simpleSubitems = getSimpleItems(item);
+        const uniqueSimpleSubitems = simpleSubitems.filter(subitem => allIds.indexOf(getId(subitem)) === -1);
+        const uniqueSimpleIds = uniqueSimpleSubitems.map(getId);
+        allIds = allIds.concat(uniqueSimpleIds);
+        return res.concat([...uniqueSimpleSubitems], [...advancedSubitems]);
+    });
+};
+export const simplifyFilterState = (state) => {
+    const processItem = (item) => {
+        let newItems = item.items.reduce((res, childItem) => {
+            if (isFilterState(childItem)) {
+                const processedSubItem = processItem(childItem);
+                const prevSubItem = res[res.length - 1];
+                // If there is only one item into subitem then make it relation equal to intersection relation
+                // (pretend like we move it on the upper level)
+                const currentRelation = processedSubItem.items.length === 1 ? item.relation : processedSubItem.relation;
+                // If subitem is the first then just put it into results without changes
+                if (!prevSubItem || !isFilterState(prevSubItem)) {
+                    res.push(processedSubItem);
+                    return res;
+                }
+                const prevRelation = prevSubItem.items.length === 1 ? item.relation : prevSubItem.relation;
+                // If current and previous relations are equal to intersection relation then combine them into one condition
+                if (currentRelation === prevRelation && currentRelation === item.relation) {
+                    const isFilterStateForPrevSubItem = isFilterState(prevSubItem.items[0]);
+                    const proceccedForMerge = isFilterStateForPrevSubItem ? [{ relation: processedSubItem.relation, items: processedSubItem.items }] : processedSubItem.items;
+                    res[res.length - 1] = Object.assign(Object.assign({}, res[res.length - 1]), { relation: item.relation, items: mergeItems([prevSubItem.items, proceccedForMerge]) });
+                    return res;
+                }
+            }
+            res.push(childItem);
+            return res;
+        }, []);
+        let newRelation = item.relation;
+        if (newItems.length === 1 && isFilterState(newItems[0])) {
+            newRelation = newItems[0].relation;
+            newItems = newItems[0].items;
+        }
+        return Object.assign(Object.assign({}, item), { relation: newRelation, items: newItems });
+    };
+    return processItem(state);
+};
+export const toFilterState = (state) => {
+    const toIdEntity = (entity) => typeof entity === "string" ? { id: entity } : entity;
+    if (isFilterState(state)) {
+        return mapFilterState(state, (item) => toIdEntity(item));
+    }
+    const isSimpleFilterItem = item => typeof item === "string" || isIdEntity(item);
+    if (Array.isArray(state) && state.length && state.every(isSimpleFilterItem)) {
+        return Object.assign(Object.assign({}, getDefaultFilterState()), { items: state.map((item) => toIdEntity(item)) });
+    }
+    return getDefaultFilterState();
+};
+const compareAdvancedFilters = (filter1, filter2) => {
+    const sortItemsFunc = (a, b) => {
+        if (!isFilterState(a) && !isFilterState(b)) {
+            return getId(a) > getId(b) ? -1 : 1;
+        }
+        return 0;
+    };
+    const processItems = (item1, item2) => {
+        const relationMatch = item1.relation === item2.relation;
+        if (!relationMatch) {
+            return false;
+        }
+        const item1Children = [...item1.items];
+        const item2Children = [...item2.items];
+        if (!item1Children || !item2Children || item1Children.length !== item2Children.length) {
+            return false;
+        }
+        item1Children.sort(sortItemsFunc);
+        item2Children.sort(sortItemsFunc);
+        const compareChildren = (itm1, itm2) => {
+            if (isFilterState(itm1) && isFilterState(itm2)) {
+                return processItems(itm1, itm2);
+            }
+            if (!isFilterState(itm1) && !isFilterState(itm2)) {
+                return getId(itm1) === getId(itm2);
+            }
+            return false;
+        };
+        return item1Children.every((item1Child, i) => {
+            const item2Child = item2Children[i];
+            if (!item2Child) {
+                return false;
+            }
+            return compareChildren(item1Child, item2Child);
+        });
+    };
+    return processItems(filter1, filter2);
+};
+export const compareFilters = (filter1, filter2) => {
+    // Try to convert to standard filters because
+    const filterA = simplifyFilterState(toFilterState(filter1));
+    const filterB = simplifyFilterState(toFilterState(filter2));
+    return compareAdvancedFilters(filterA, filterB);
+};

package/esm/groupsFilter/stateReducer/stateAction.d.ts

@@ -0,0 +1,65 @@
+import { IPreparedFiltersState } from "../groupsFilterHelper";
+import { IFilterState, IGroupItem, RelationOperator } from "../groupsFilterInterfaces";
+import { StateActionType } from "./stateActionType";
+interface IPayloadInitialState {
+    value: IPreparedFiltersState;
+    global: boolean;
+}
+interface IPayloadSelectionAction {
+    value: boolean;
+    itemId: string;
+}
+interface ICreateGroupsMapAction {
+    type: StateActionType.CreateGroupsMap;
+    payload: IGroupItem[];
+}
+interface ICreateInitialStateAction {
+    type: StateActionType.CreateInitialState;
+    payload: IPayloadInitialState;
+}
+interface IFreezeSideWideAction {
+    type: StateActionType.FreezeSideWide;
+    payload: boolean;
+}
+interface IFreezeStateAction {
+    type: StateActionType.FreezeState;
+    payload: IPreparedFiltersState;
+}
+interface ISideWideAction {
+    type: StateActionType.SideWide;
+    payload: boolean;
+}
+interface ISetStateAction {
+    type: StateActionType.SetState;
+    payload: IPreparedFiltersState;
+}
+interface ISetAdvancedFilterStateAction {
+    type: StateActionType.SetAdvancedFilterState;
+    payload: IFilterState;
+}
+interface IRelationAction {
+    type: StateActionType.Relation;
+    payload: RelationOperator;
+}
+interface IChangeSelectionAction {
+    type: StateActionType.ChangeSelection;
+    payload: IPayloadSelectionAction;
+}
+interface IResetSelection {
+    type: StateActionType.ResetSelection;
+    payload: undefined;
+}
+interface ISelectAllChildrenAction {
+    type: StateActionType.SelectAllChildren;
+    payload: string;
+}
+interface IDeselectAllChildrenAction {
+    type: StateActionType.DeselectAllChildren;
+    payload: string;
+}
+interface ITurnOffGlobalChangesAction {
+    type: StateActionType.TurnOfGlobalChanges;
+    payload: undefined;
+}
+export type TStateAction = ICreateGroupsMapAction | ISetAdvancedFilterStateAction | ICreateInitialStateAction | IFreezeSideWideAction | IFreezeStateAction | ISideWideAction | ISetStateAction | IRelationAction | IChangeSelectionAction | IResetSelection | ISelectAllChildrenAction | IDeselectAllChildrenAction | ITurnOffGlobalChangesAction;
+export {};

package/esm/groupsFilter/stateReducer/stateAction.js

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

package/esm/groupsFilter/stateReducer/stateActionType.d.ts

@@ -0,0 +1,15 @@
+export declare enum StateActionType {
+    CreateGroupsMap = "CREATE_GROUPS_MAP",
+    CreateInitialState = "CREATE_INITIAL_FILTER_STATE",
+    FreezeSideWide = "FREEZE_SIDE_WIDE",
+    FreezeState = "FREEZE_STATE",
+    SideWide = "SIDE_WIDE",
+    SetState = "SET_STATE",
+    SetAdvancedFilterState = "SET_ADVANCED_FILTER_STATE",
+    Relation = "RELATION",
+    ChangeSelection = "CHANGE_SELECTION",
+    ResetSelection = "RESET_SELECTION",
+    DeselectAllChildren = "DESELECT_ALL_CHILDREN",
+    SelectAllChildren = "SELECT_ALL_CHILDREN",
+    TurnOfGlobalChanges = "TURN_OF_GLOBAL_CHANGES"
+}

package/esm/groupsFilter/stateReducer/stateActionType.js

@@ -0,0 +1,16 @@
+export var StateActionType;
+(function (StateActionType) {
+    StateActionType["CreateGroupsMap"] = "CREATE_GROUPS_MAP";
+    StateActionType["CreateInitialState"] = "CREATE_INITIAL_FILTER_STATE";
+    StateActionType["FreezeSideWide"] = "FREEZE_SIDE_WIDE";
+    StateActionType["FreezeState"] = "FREEZE_STATE";
+    StateActionType["SideWide"] = "SIDE_WIDE";
+    StateActionType["SetState"] = "SET_STATE";
+    StateActionType["SetAdvancedFilterState"] = "SET_ADVANCED_FILTER_STATE";
+    StateActionType["Relation"] = "RELATION";
+    StateActionType["ChangeSelection"] = "CHANGE_SELECTION";
+    StateActionType["ResetSelection"] = "RESET_SELECTION";
+    StateActionType["DeselectAllChildren"] = "DESELECT_ALL_CHILDREN";
+    StateActionType["SelectAllChildren"] = "SELECT_ALL_CHILDREN";
+    StateActionType["TurnOfGlobalChanges"] = "TURN_OF_GLOBAL_CHANGES";
+})(StateActionType || (StateActionType = {}));

package/esm/groupsFilter/stateReducer/stateReducer.d.ts

@@ -0,0 +1,48 @@
+import { Reducer } from "react";
+import { IPreparedFiltersState } from "../groupsFilterHelper";
+import { IGroupTree, ITypedHash, RelationOperator, ILeafStateItem, IFilterState, IGroupsFilterTotalState } from "../groupsFilterInterfaces";
+import { TStateAction } from "./stateAction";
+export interface IGroupsFilterState {
+    translate: (s: string) => string;
+    groupsMap: ITypedHash<IGroupTree>;
+    frozenSideWideState: boolean;
+    frozenState: IPreparedFiltersState;
+    sideWideState: boolean;
+    relation: RelationOperator;
+    selectedIds: string[];
+    advancedFilterState: ILeafStateItem | IFilterState;
+    globalChanges: boolean;
+}
+export interface IStateReducer extends Reducer<IGroupsFilterState, TStateAction> {
+}
+export declare const defaultPreparedFilterState: {
+    advancedFilterState: ILeafStateItem<import("../..").IEntityWithId>;
+    simpleFilterState: never[];
+    relation: RelationOperator;
+};
+export declare const getInitialState: (translate: (s: string) => string, initState?: IGroupsFilterTotalState) => {
+    translate: (s: string) => string;
+    groupsMap: {};
+    frozenSideWideState: boolean;
+    sideWideState: boolean;
+    globalChanges: boolean;
+    relation: RelationOperator;
+    selectedIds: never[];
+    advancedFilterState: ILeafStateItem<import("../..").IEntityWithId>;
+    frozenState: {
+        advancedFilterState: ILeafStateItem<import("../..").IEntityWithId>;
+        simpleFilterState: never[];
+        relation: RelationOperator;
+    };
+};
+export declare function stateReducer(state: IGroupsFilterState, action: TStateAction): {
+    groupsMap: ITypedHash<IGroupTree>;
+    translate: (s: string) => string;
+    frozenSideWideState: boolean;
+    frozenState: IPreparedFiltersState;
+    sideWideState: boolean;
+    relation: RelationOperator;
+    selectedIds: string[];
+    advancedFilterState: IFilterState<import("../..").IEntityWithId> | ILeafStateItem<import("../..").IEntityWithId>;
+    globalChanges: boolean;
+};