@geotab/zenith 1.26.6 → 2.0.0-beta.0

package/esm/dropdown/stateReducer/stateAction.js

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

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

@@ -0,0 +1,31 @@
+export declare enum StateActionType {
+    CreateMap = "CREATE_MAP",
+    SetState = "SET_STATE",
+    SetDefaultValue = "SET_DEFAULT_VALUE",
+    SetGlobalState = "SET_GLOBAL_STATE",
+    SetListData = "SET_LIST_DATA",
+    ChangeSelection = "CHANGE_SELECTION",
+    ChangeBulkSelection = "CHANGE_BULK_SELECTION",
+    ChangeSingleSelection = "CHANGE_SINGLE_SELECTION",
+    DeselectAllChildren = "DESELECT_ALL_CHILDREN",
+    SelectAllChildren = "SELECT_ALL_CHILDREN",
+    SetCurrentId = "SET_CURRENT_ID",
+    ResetSelection = "RESET_SELECTION",
+    ResetStateToGlobal = "RESET_STATE_TO_GLOBAL",
+    Show = "SHOW",
+    NothingToShow = "NOTHING_TO_SHOW",
+    ShowWaiting = "SHOW_WAITING",
+    ShowEmptyList = "SHOW_EMPTY_LIST",
+    ShowList = "SHOW_LIST",
+    SetInputValue = "SET_INPUT_VALUE",
+    SetIsOpenCombo = "SET_IS_OPEN_COMBO",
+    SetDataProblem = "SET_DATA_PROBLEM",
+    UpdateSelectedItems = "UPDATE_SELECTED_ITEMS",
+    SetPendingState = "SET_PENDING_STATE",
+    UpdateNamelessItems = "UPDATE_NAMELESS_ITEMS",
+    ToggleValueForAllSelected = "TOGGLE_VALUE_FOR_ALL_SELECTED",
+    DeselectItemsFromAllSelected = "DESELECT_ITEMS_FROM_ALL_SELECTED",
+    SetDefaultAllSelected = "SET_DEFAULT_ALL_SELECTED",
+    SetDefaultIsChecked = "SET_DEFAULT_IS_CHECKED",
+    SetIsChecked = "SET_IS_CHECKED"
+}

package/esm/dropdown/stateReducer/stateActionType.js

@@ -0,0 +1,32 @@
+export var StateActionType;
+(function (StateActionType) {
+    StateActionType["CreateMap"] = "CREATE_MAP";
+    StateActionType["SetState"] = "SET_STATE";
+    StateActionType["SetDefaultValue"] = "SET_DEFAULT_VALUE";
+    StateActionType["SetGlobalState"] = "SET_GLOBAL_STATE";
+    StateActionType["SetListData"] = "SET_LIST_DATA";
+    StateActionType["ChangeSelection"] = "CHANGE_SELECTION";
+    StateActionType["ChangeBulkSelection"] = "CHANGE_BULK_SELECTION";
+    StateActionType["ChangeSingleSelection"] = "CHANGE_SINGLE_SELECTION";
+    StateActionType["DeselectAllChildren"] = "DESELECT_ALL_CHILDREN";
+    StateActionType["SelectAllChildren"] = "SELECT_ALL_CHILDREN";
+    StateActionType["SetCurrentId"] = "SET_CURRENT_ID";
+    StateActionType["ResetSelection"] = "RESET_SELECTION";
+    StateActionType["ResetStateToGlobal"] = "RESET_STATE_TO_GLOBAL";
+    StateActionType["Show"] = "SHOW";
+    StateActionType["NothingToShow"] = "NOTHING_TO_SHOW";
+    StateActionType["ShowWaiting"] = "SHOW_WAITING";
+    StateActionType["ShowEmptyList"] = "SHOW_EMPTY_LIST";
+    StateActionType["ShowList"] = "SHOW_LIST";
+    StateActionType["SetInputValue"] = "SET_INPUT_VALUE";
+    StateActionType["SetIsOpenCombo"] = "SET_IS_OPEN_COMBO";
+    StateActionType["SetDataProblem"] = "SET_DATA_PROBLEM";
+    StateActionType["UpdateSelectedItems"] = "UPDATE_SELECTED_ITEMS";
+    StateActionType["SetPendingState"] = "SET_PENDING_STATE";
+    StateActionType["UpdateNamelessItems"] = "UPDATE_NAMELESS_ITEMS";
+    StateActionType["ToggleValueForAllSelected"] = "TOGGLE_VALUE_FOR_ALL_SELECTED";
+    StateActionType["DeselectItemsFromAllSelected"] = "DESELECT_ITEMS_FROM_ALL_SELECTED";
+    StateActionType["SetDefaultAllSelected"] = "SET_DEFAULT_ALL_SELECTED";
+    StateActionType["SetDefaultIsChecked"] = "SET_DEFAULT_IS_CHECKED";
+    StateActionType["SetIsChecked"] = "SET_IS_CHECKED";
+})(StateActionType || (StateActionType = {}));

package/esm/dropdown/stateReducer/stateReducer.d.ts

@@ -0,0 +1,57 @@
+import { Reducer } from "react";
+import { TStateAction } from "./stateAction";
+import { IGroupTree, ITypedHash } from "../../groupsFilter/groupsFilterInterfaces";
+import { IDropdownItem } from "../dropdown";
+export interface IDropdownState {
+    groupsMap: ITypedHash<IGroupTree>;
+    selectedIds: string[];
+    globalSelectedIds: string[];
+    defaultValue: string[];
+    listData: IDropdownItem[];
+    currentId: string | undefined;
+    showWaiting: boolean;
+    showEmptyList: boolean;
+    showList: boolean;
+    inputValue: string;
+    isOpenCombo: boolean;
+    hasDataProblem: boolean;
+    groupsMapSelected: Map<string, IDropdownItem>;
+    namelessIds: Set<string>;
+    pendingNamelessIds: boolean;
+    isNestedList: boolean;
+    isFullSelectionMode: boolean;
+    isAllSelected?: boolean;
+    globalIsAllSelected?: boolean;
+    defaultValueIsAllSelected?: boolean;
+    isChecked?: boolean;
+    defaultValueIsChecked?: boolean;
+    globalIsChecked?: boolean;
+}
+export interface IStateReducer extends Reducer<IDropdownState, TStateAction> {
+}
+export declare const getInitialState: (isFullSelectionMode: boolean, comboItems: IDropdownItem[], selection: string[], defaultValue?: string[], isAllSelected?: boolean, defaultValueIsAllSelected?: boolean, isChecked?: boolean, defaultValueIsChecked?: boolean) => {
+    groupsMap: ITypedHash<IGroupTree>;
+    selectedIds: string[];
+    globalSelectedIds: string[];
+    defaultValue: string[];
+    listData: never[];
+    currentId: undefined;
+    showWaiting: boolean;
+    showEmptyList: boolean;
+    showList: boolean;
+    inputValue: string;
+    isOpenCombo: boolean;
+    hasDataProblem: boolean;
+    groupsMapSelected: Map<any, any>;
+    namelessIds: Set<string>;
+    pendingNamelessIds: boolean;
+    isNestedList: boolean;
+    isFullSelectionMode: boolean;
+    isAllSelected: boolean | undefined;
+    globalIsAllSelected: boolean | undefined;
+    defaultValueIsAllSelected: boolean | undefined;
+    isChecked: boolean | undefined;
+    defaultValueIsChecked: boolean | undefined;
+    globalIsChecked: boolean | undefined;
+};
+export declare function stateReducer(state: IDropdownState, action: TStateAction): IDropdownState;

package/esm/dropdown/stateReducer/stateReducer.js

@@ -0,0 +1,360 @@
+import { StateActionType } from "./stateActionType";
+import { getChildList } from "./stateReducerHelper";
+import { createGroupsMap } from "../../groupsFilter/groupsFilterHelper";
+import { ENTIRE_ORGANIZATION_GROUP_ID } from "../../groupsFilter/groupsHelper";
+export const getInitialState = (isFullSelectionMode, comboItems, selection, defaultValue, isAllSelected, defaultValueIsAllSelected, isChecked, defaultValueIsChecked) => {
+    const updatedGroupsMapSelected = new Map();
+    const updatedGroupsMap = comboItems.length ? createGroupsMap(comboItems, ENTIRE_ORGANIZATION_GROUP_ID) : {};
+    const namelessIds = new Set();
+    if (selection.length > 0) {
+        selection.forEach(id => {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            const item = updatedGroupsMap[id];
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (item) {
+                updatedGroupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+            }
+            else {
+                namelessIds.add(id);
+            }
+        });
+    }
+    const isCurrentListNested = Object.keys(updatedGroupsMap).length > 0 && (updatedGroupsMap[ENTIRE_ORGANIZATION_GROUP_ID].children || []).some(el => el.children && el.children.length);
+    return {
+        groupsMap: updatedGroupsMap,
+        selectedIds: selection,
+        globalSelectedIds: selection,
+        defaultValue: defaultValue || [],
+        listData: [],
+        currentId: undefined,
+        showWaiting: false,
+        showEmptyList: false,
+        showList: false,
+        inputValue: "",
+        isOpenCombo: false,
+        hasDataProblem: false,
+        groupsMapSelected: updatedGroupsMapSelected,
+        namelessIds: namelessIds,
+        pendingNamelessIds: false,
+        isNestedList: isCurrentListNested,
+        isFullSelectionMode: isFullSelectionMode,
+        isAllSelected: isAllSelected,
+        globalIsAllSelected: isFullSelectionMode ? isAllSelected || false : undefined,
+        defaultValueIsAllSelected: isFullSelectionMode ? defaultValueIsAllSelected || false : undefined,
+        isChecked: isChecked,
+        defaultValueIsChecked: isChecked !== undefined ? defaultValueIsChecked || false : undefined,
+        globalIsChecked: isChecked
+    };
+};
+// eslint-disable-next-line complexity
+export function stateReducer(state, action) {
+    var _a, _b, _c, _d;
+    const { type, payload } = action;
+    switch (type) {
+        case StateActionType.CreateMap: {
+            const updatedGroupsMap = payload.length ? createGroupsMap(payload, ENTIRE_ORGANIZATION_GROUP_ID) : {};
+            const newNamelessIds = new Set(state.namelessIds);
+            if (Object.keys(updatedGroupsMap).length && state.selectedIds.length) {
+                state.selectedIds.forEach(id => {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = updatedGroupsMap[id];
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    if (item) {
+                        state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                        newNamelessIds.delete(id);
+                    }
+                    else {
+                        newNamelessIds.add(id);
+                    }
+                });
+            }
+            const isCurrentListNested = Object.keys(updatedGroupsMap).length > 0 && (updatedGroupsMap[ENTIRE_ORGANIZATION_GROUP_ID].children || []).some(el => el.children && el.children.length);
+            return Object.assign(Object.assign({}, state), { groupsMap: updatedGroupsMap, namelessIds: newNamelessIds, isNestedList: state.isNestedList ? state.isNestedList : isCurrentListNested });
+        }
+        case StateActionType.SetListData: {
+            state.selectedIds.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    const item = payload.find(el => el.id === id);
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                    item && state.namelessIds.delete(id);
+                }
+            });
+            const isCurrentDataNested = payload.some(el => el.children && el.children.length > 0);
+            return Object.assign(Object.assign({}, state), { listData: payload, hasDataProblem: Object.keys(state.groupsMap).length === 0 && isCurrentDataNested, isNestedList: isCurrentDataNested ? isCurrentDataNested : state.isNestedList });
+        }
+        case StateActionType.SetDataProblem:
+            return Object.assign(Object.assign({}, state), { hasDataProblem: payload });
+        case StateActionType.SetIsChecked:
+            return Object.assign(Object.assign({}, state), { isChecked: payload });
+        case StateActionType.SetDefaultIsChecked:
+            return Object.assign(Object.assign({}, state), { defaultValueIsChecked: payload });
+        case StateActionType.SetCurrentId:
+            return Object.assign(Object.assign({}, state), { currentId: payload || undefined });
+        case StateActionType.SetIsOpenCombo:
+            return Object.assign(Object.assign({}, state), { isOpenCombo: payload });
+        case StateActionType.ResetSelection:
+            return Object.assign(Object.assign({}, state), { selectedIds: [...state.defaultValue], isAllSelected: state.defaultValueIsAllSelected, isChecked: typeof state.isChecked === "boolean" ? state.defaultValueIsChecked || false : undefined });
+        case StateActionType.ResetStateToGlobal:
+            return Object.assign(Object.assign({}, state), { selectedIds: [...state.globalSelectedIds], isAllSelected: state.globalIsAllSelected, isChecked: state.globalIsChecked });
+        case StateActionType.NothingToShow:
+            return Object.assign(Object.assign({}, state), { showWaiting: false, showEmptyList: false, showList: false });
+        case StateActionType.Show:
+            return Object.assign(Object.assign({}, state), { [payload.show]: payload.value });
+        case StateActionType.ShowWaiting:
+            return Object.assign(Object.assign({}, state), { showWaiting: true, showEmptyList: false, showList: false });
+        case StateActionType.ShowEmptyList:
+            return Object.assign(Object.assign({}, state), { showWaiting: false, showEmptyList: true, showList: false });
+        case StateActionType.ShowList:
+            return Object.assign(Object.assign({}, state), { showWaiting: false, showEmptyList: false, showList: true });
+        case StateActionType.SetInputValue:
+            return Object.assign(Object.assign({}, state), { inputValue: payload });
+        case StateActionType.SetState: {
+            const newNamelessIds = new Set(state.namelessIds);
+            payload.selected.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = state.groupsMap[id];
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    !item && newNamelessIds.add(id);
+                }
+            });
+            return Object.assign(Object.assign({}, state), { selectedIds: payload.selected, namelessIds: newNamelessIds, isAllSelected: payload.isAllSelected });
+        }
+        case StateActionType.UpdateNamelessItems: {
+            if (state.pendingNamelessIds) {
+                return state;
+            }
+            const newNamelessIds = new Set(state.namelessIds);
+            state.selectedIds.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = state.groupsMap[id];
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    !item && newNamelessIds.add(id);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && newNamelessIds.delete(id);
+                }
+                else {
+                    newNamelessIds.delete(id);
+                }
+            });
+            return Object.assign(Object.assign({}, state), { namelessIds: newNamelessIds });
+        }
+        case StateActionType.UpdateSelectedItems: {
+            payload.forEach(item => {
+                if (!state.groupsMapSelected.has(item.id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    state.groupsMapSelected.set(item.id, Object.assign(Object.assign({ id: item.id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                }
+            });
+            const newNamelessIds = new Set();
+            return Object.assign(Object.assign({}, state), { namelessIds: newNamelessIds, pendingNamelessIds: false });
+        }
+        case StateActionType.SetPendingState: {
+            return Object.assign(Object.assign({}, state), { pendingNamelessIds: payload });
+        }
+        case StateActionType.SetGlobalState:
+            return Object.assign(Object.assign({}, state), { globalSelectedIds: payload.selected, globalIsAllSelected: payload.isAllSelected, globalIsChecked: payload.isChecked !== undefined ? payload.isChecked : state.globalIsChecked });
+        case StateActionType.SetDefaultValue: {
+            const newNamelessIds = new Set(state.namelessIds);
+            payload.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = state.groupsMap[id] || state.listData.find(el => el.id === id);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    !item && newNamelessIds.add(id);
+                }
+            });
+            return Object.assign(Object.assign({}, state), { defaultValue: payload, namelessIds: newNamelessIds });
+        }
+        case StateActionType.SetDefaultAllSelected: {
+            return Object.assign(Object.assign({}, state), { defaultValueIsAllSelected: payload });
+        }
+        case StateActionType.ChangeSingleSelection: {
+            const newSelectedId = payload.value ? payload.value : state.defaultValue[0];
+            if (newSelectedId && !state.groupsMapSelected.has(newSelectedId)) {
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                const item = state.groupsMap[newSelectedId] || state.listData.find(el => el.id === newSelectedId);
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                item && state.groupsMapSelected.set(newSelectedId, Object.assign(Object.assign({ id: newSelectedId }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+            }
+            return Object.assign(Object.assign({}, state), { selectedIds: payload.value ? [payload.value] : (payload.reset ? [...state.defaultValue] : []) });
+        }
+        case StateActionType.ChangeSelection: {
+            const currentSelectedIds = new Set(state.selectedIds);
+            if (currentSelectedIds.has(payload.itemId)) {
+                currentSelectedIds.delete(payload.itemId);
+            }
+            else {
+                currentSelectedIds.add(payload.itemId);
+            }
+            if (payload.value) {
+                // deselect parent
+                const parentForDeselect = [];
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                let parent = (_b = (_a = state.groupsMap[payload.itemId]) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.id;
+                while (parent && parent !== "root") {
+                    parentForDeselect.push(parent);
+                    parent = (_c = state.groupsMap[parent].parent) === null || _c === void 0 ? void 0 : _c.id;
+                }
+                parentForDeselect.forEach(parentId => {
+                    currentSelectedIds.delete(parentId);
+                });
+                // deselect children
+                const childrenForDeselect = [];
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                const currentChild = getChildList((_d = state.groupsMap[payload.itemId]) === null || _d === void 0 ? void 0 : _d.children);
+                currentChild.forEach(el => {
+                    childrenForDeselect.push(el.id);
+                });
+                childrenForDeselect.forEach(childId => currentSelectedIds.delete(childId));
+            }
+            currentSelectedIds.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = state.groupsMap[id] || state.listData.find(el => el.id === id);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                }
+            });
+            return Object.assign(Object.assign({}, state), { selectedIds: Array.from(currentSelectedIds) });
+        }
+        case StateActionType.ChangeBulkSelection: {
+            const { itemsIds, value } = payload;
+            const currentSelectedIds = new Set(state.selectedIds);
+            const parentsToProcess = new Set();
+            const childrenToProcess = new Set();
+            itemsIds.forEach(itemId => {
+                var _a, _b, _c, _d;
+                if (value) {
+                    currentSelectedIds.add(itemId);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    let parent = (_b = (_a = state.groupsMap[itemId]) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.id;
+                    while (parent && parent !== "root") {
+                        parentsToProcess.add(parent);
+                        parent = (_c = state.groupsMap[parent].parent) === null || _c === void 0 ? void 0 : _c.id;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const currentChild = getChildList((_d = state.groupsMap[itemId]) === null || _d === void 0 ? void 0 : _d.children);
+                    currentChild.forEach(childId => childrenToProcess.add(childId.id));
+                }
+                else {
+                    currentSelectedIds.delete(itemId);
+                }
+            });
+            childrenToProcess.forEach(childId => currentSelectedIds.delete(childId));
+            parentsToProcess.forEach(parentId => currentSelectedIds.delete(parentId));
+            currentSelectedIds.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = state.groupsMap[id] || state.listData.find(el => el.id === id);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                }
+            });
+            return Object.assign(Object.assign({}, state), { selectedIds: Array.from(currentSelectedIds) });
+        }
+        case StateActionType.SelectAllChildren: {
+            const currentEl = state.groupsMap[payload];
+            const newSelected = new Set(state.selectedIds);
+            const isDisableStateProhibited = state.isNestedList;
+            (currentEl.children || []).forEach(el => {
+                var _a, _b;
+                if (!newSelected.has(el.id)) {
+                    // select when isDisableStateProhibited, or when disabled elements are allowed to be displayed, and this element is not disabled
+                    (isDisableStateProhibited || !el.disabled) && newSelected.add(el.id);
+                    // deselect parent
+                    const parentForDeselect = [];
+                    let parent = (_a = state.groupsMap[el.id].parent) === null || _a === void 0 ? void 0 : _a.id;
+                    while (parent && parent !== "root") {
+                        parentForDeselect.push(parent);
+                        parent = (_b = state.groupsMap[parent].parent) === null || _b === void 0 ? void 0 : _b.id;
+                    }
+                    parentForDeselect.forEach(parentId => {
+                        newSelected.delete(parentId);
+                    });
+                    //deselect children
+                    const childrenForDeselect = [];
+                    const currentChild = getChildList(state.groupsMap[el.id].children);
+                    currentChild.forEach(elt => {
+                        childrenForDeselect.push(elt.id);
+                    });
+                    childrenForDeselect.forEach(childId => newSelected.delete(childId));
+                }
+            });
+            newSelected.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = state.groupsMap[id] || state.listData.find(el => el.id === id);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                }
+            });
+            return Object.assign(Object.assign({}, state), { selectedIds: Array.from(newSelected) });
+        }
+        case StateActionType.DeselectItemsFromAllSelected: {
+            const currentEl = state.groupsMap[ENTIRE_ORGANIZATION_GROUP_ID];
+            // action not submitted for disabled item, other items, even if disabled, not change their state
+            const deselectedItems = payload ? new Set([payload]) : new Set(state.listData.filter(elem => !elem.disabled).map(el => el.id));
+            const newSelected = new Set();
+            (currentEl.children || []).forEach(el => {
+                if (!newSelected.has(el.id) && !deselectedItems.has(el.id)) {
+                    newSelected.add(el.id);
+                }
+            });
+            state.listData.forEach(el => {
+                if (!newSelected.has(el.id) && !deselectedItems.has(el.id)) {
+                    newSelected.add(el.id);
+                }
+            });
+            newSelected.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = state.groupsMap[id] || state.listData.find(el => el.id === id);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                }
+            });
+            return Object.assign(Object.assign({}, state), { selectedIds: Array.from(newSelected), isAllSelected: state.isFullSelectionMode ? false : undefined });
+        }
+        case StateActionType.ToggleValueForAllSelected: {
+            const currentEl = state.groupsMap[ENTIRE_ORGANIZATION_GROUP_ID];
+            const newSelected = new Set();
+            state.isAllSelected && (currentEl.children || []).forEach(el => {
+                if (!newSelected.has(el.id) && el.disabled) {
+                    newSelected.add(el.id);
+                }
+            });
+            newSelected.forEach(id => {
+                if (!state.groupsMapSelected.has(id)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    const item = state.groupsMap[id] || state.listData.find(el => el.id === id);
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    item && state.groupsMapSelected.set(id, Object.assign(Object.assign({ id }, (item.name ? { name: item.name } : {})), (item.color ? { color: item.color } : {})));
+                }
+            });
+            return Object.assign(Object.assign({}, state), { selectedIds: state.isAllSelected ? Array.from(newSelected) : [], isAllSelected: state.isFullSelectionMode ? !state.isAllSelected : undefined });
+        }
+        case StateActionType.DeselectAllChildren: {
+            const childrenForDeselect = [];
+            const currentChild = getChildList(state.groupsMap[payload].children);
+            const isDisableStateProhibited = state.isNestedList;
+            currentChild.forEach(el => {
+                // deselect when isDisableStateProhibited, or when disabled elements are allowed to be displayed, and this element is not disabled
+                (isDisableStateProhibited || !el.disabled) && childrenForDeselect.push(el.id);
+            });
+            const newSelected = new Set(state.selectedIds);
+            childrenForDeselect.forEach(childId => newSelected.delete(childId));
+            return Object.assign(Object.assign({}, state), { selectedIds: Array.from(newSelected) });
+        }
+        default: {
+            throw Error("Unknown action: " + type);
+        }
+    }
+}

package/esm/dropdown/stateReducer/stateReducerHelper.d.ts

@@ -0,0 +1,2 @@
+import { IDropdownItem } from "../dropdown";
+export declare function getChildList(childArr: IDropdownItem[] | undefined): IDropdownItem[];

package/esm/dropdown/stateReducer/stateReducerHelper.js

@@ -0,0 +1,14 @@
+export function getChildList(childArr) {
+    const list = [];
+    if (!childArr) {
+        return [];
+    }
+    (childArr || []).forEach((el) => {
+        el && list.push(el);
+        if ((el === null || el === void 0 ? void 0 : el.children) && el.children.length > 0) {
+            const childList = getChildList(el.children);
+            childList.length > 0 && list.push(...childList);
+        }
+    });
+    return list;
+}

package/esm/dropdown/useDropdownState.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const useDropdownState: (withCheckbox?: boolean) => {
+    checked?: boolean | undefined;
+    setChecked?: import("react").Dispatch<import("react").SetStateAction<boolean>> | undefined;
+    search: string;
+    setSearch: import("react").Dispatch<import("react").SetStateAction<string>>;
+};

package/esm/dropdown/useDropdownState.js

@@ -0,0 +1,6 @@
+import { useState } from "react";
+export const useDropdownState = (withCheckbox) => {
+    const [search, setSearch] = useState("");
+    const [checked, setChecked] = useState(false);
+    return Object.assign({ search, setSearch }, (withCheckbox ? { checked, setChecked } : {}));
+};

package/esm/dropdownOld/dropdownOld.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import "./dropdownOld.less";
+import { IZenComponentProps } from "../commonHelpers/zenComponent";
+import { ISelectListItem } from "../selectList/selectListItem";
+export interface IDropdownOld extends IZenComponentProps {
+    onChange: (selectedIds: string[]) => void;
+    items: ISelectListItem[];
+    selectedOption: string[];
+    title: string;
+    placeholder: string;
+    id?: string;
+    disabled?: boolean;
+    multiselect?: boolean;
+    footer?: JSX.Element;
+    fullWidth?: boolean;
+}
+export declare const DropdownOld: React.FC<IDropdownOld>;

package/esm/dropdownOld/dropdownOld.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment, useCallback, useMemo, useRef, useState } from "react";
+import { FilterButton } from "../filterButton/filterButton";
+import { SelectList } from "../selectList/selectList";
+import { CheckboxState } from "../checkbox/checkboxState";
+import { ControlledPopup } from "../controlledPopup/controlledPopup";
+import { getSelectValue } from "../selectRaw/select.helpers";
+import { isDropdownStateTheSame } from "./dropdownOldHelpers/isDropdownStateTheSame";
+import { useUniqueId } from "../commonHelpers/useUniqueId";
+// get default active item (based on items array)
+const getItemById = (items, id) => items.find(item => item.id === id);
+export const DropdownOld = (props) => {
+    var _a;
+    const { fullWidth, footer, multiselect, disabled, placeholder, title, id, className, selectedOption, items: outerItems, onChange } = props;
+    const [isOpen, setIsOpen] = useState(false);
+    const innerTriggerRef = useRef(null);
+    // items IDs
+    const buttonReactId = useUniqueId();
+    const selectListId = useUniqueId();
+    const popupId = useUniqueId();
+    // memoized items
+    const items = useMemo(() => outerItems, [outerItems]);
+    const itemsMap = useMemo(() => items.reduce((acc, obj) => acc.set(obj.id, selectedOption.includes(obj.id) ? CheckboxState.On : CheckboxState.Off), new Map()), [items, selectedOption]);
+    // trigger button text value
+    const value = getSelectValue(itemsMap, items);
+    const triggerValue = value ? (_a = getItemById(items, value)) === null || _a === void 0 ? void 0 : _a.children : placeholder;
+    const onOptionsToggle = (isCurrentlyOpen) => {
+        setIsOpen(isCurrentlyOpen);
+    };
+    const onOptionChange = useCallback((newItemState) => {
+        const newSelection = [...newItemState].reduce((res, [selectedId, checkedState]) => {
+            if (checkedState === CheckboxState.On) {
+                res.push(selectedId);
+            }
+            return res;
+        }, []);
+        if (!isDropdownStateTheSame(newSelection, selectedOption)) {
+            onChange(newSelection);
+        }
+    }, [onChange, selectedOption]);
+    return _jsxs(Fragment, { children: [_jsx(FilterButton, { ref: innerTriggerRef, id: id || buttonReactId, className: className, onClick: () => {
+                    setIsOpen(!isOpen);
+                }, disabled: disabled, isActive: isOpen, fullWidth: fullWidth, quantity: multiselect && selectedOption.length > 0 ? selectedOption.length : undefined, children: triggerValue }), _jsx(ControlledPopup, { id: popupId, useTrapFocusWithTrigger: "withTrigger", alignment: "bottom-left", onOpenChange: (isCurrentlyOpen) => {
+                    onOptionsToggle(isCurrentlyOpen);
+                }, isOpen: isOpen, triggerRef: innerTriggerRef, children: _jsxs("div", { className: "zen-dropdown-old", children: [title ? _jsx("div", { className: "zen-dropdown-old__header", children: title }) : null, _jsx(SelectList, { id: selectListId, title: title, showCheckbox: multiselect, value: itemsMap, multiselect: multiselect, items: [
+                                ...items.reduce((acc, obj) => acc.set(obj.id, Object.assign(Object.assign({}, obj), { state: selectedOption.includes(obj.id) ? CheckboxState.On : CheckboxState.Off })), new Map()).values()
+                            ], onChange: onOptionChange }), footer
+                            ? _jsx("div", { className: "zen-dropdown-old__footer", children: footer })
+                            : null] }) })] });
+};

package/esm/dropdownOld/dropdownOldHelpers/isDropdownStateTheSame.d.ts

@@ -0,0 +1 @@
+export declare const isDropdownStateTheSame: (newState: string[], oldState: string[]) => boolean;

package/esm/dropdownOld/dropdownOldHelpers/isDropdownStateTheSame.js

@@ -0,0 +1,6 @@
+export const isDropdownStateTheSame = (newState, oldState) => {
+    if (newState.length !== oldState.length) {
+        return false;
+    }
+    return newState.sort().join(",") === oldState.sort().join(",");
+};

package/esm/favoriteButton/favoriteButton.d.ts

@@ -0,0 +1,7 @@
+import "./favoriteButton.less";
+import { IZenComponentProps } from "../commonHelpers/zenComponent";
+export interface IFavoriteButton extends IZenComponentProps {
+    isFavorite: boolean;
+    onChange: (isFavorite: boolean) => void;
+}
+export declare const FavoriteButton: ({ isFavorite, onChange, className }: IFavoriteButton) => import("react/jsx-runtime").JSX.Element;

package/esm/favoriteButton/favoriteButton.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo } from "react";
+import { classNames } from "../commonHelpers/classNames/classNames";
+import { IconStar } from "../icons/iconStar";
+import { IconStarFilled } from "../icons/iconStarFilled";
+import { useLanguage } from "../utils/localization/useLanguage";
+import { useDriveClassName } from "../utils/theme/useDriveClassName";
+import { useDrive } from "../utils/theme/useDrive";
+export const FavoriteButton = ({ isFavorite, onChange, className }) => {
+    const { translate } = useLanguage();
+    const driveClassName = useDriveClassName("zen-favorite-button");
+    const isDrive = useDrive();
+    const iconSize = useMemo(() => isDrive ? "huge" : "large", [isDrive]);
+    const filledClassName = isFavorite ? "zen-favorite-button--filled" : "";
+    const onClick = useCallback(() => onChange(!isFavorite), [isFavorite, onChange]);
+    return (_jsxs("button", { onClick: onClick, className: classNames(["zen-favorite-button", driveClassName || "", filledClassName, className || ""]), title: translate("Favorite"), "aria-label": translate("Favorite"), "aria-pressed": isFavorite, children: [_jsx(IconStar, { size: iconSize, className: "zen-favorite-button__empty" }), _jsx(IconStarFilled, { size: iconSize, className: "zen-favorite-button__filled" })] }));
+};

package/esm/feedbackContainer/feedbackContainer.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import "./feedbackContainer.less";
+export declare const FeedbackContainer: React.FC;