@cloud-ru/ds-uikit-product-header 1.0.1-preview-7665e9c3.0

package/dist/esm/components/MainMenu/utils/dedupeSearchGroups.d.ts

@@ -0,0 +1,15 @@
+import { LinksGroup } from '../types.js';
+/**
+ * Один и тот же сервис может быть представлен в разных сегментах с разной
+ * детализацией — например, простой карточкой в общем каталоге и раскрытой
+ * аккордеоном карточкой с вложенными сервисами в «Центре управления». Обе
+ * версии используют общий {@link InnerLink.id}.
+ *
+ * При поиске результаты сегментов объединяются в один список (см.
+ * {@link MainMenuProps.segments}), поэтому такой сервис может совпасть сразу в
+ * нескольких сегментах. Функция оставляет только первое по порядку `groups`
+ * (то есть по приоритету сегментов) вхождение каждого id, а группы, опустевшие
+ * после удаления дублей, убирает целиком — иначе группа с тем же заголовком
+ * задублируется в выдаче.
+ */
+export declare function dedupeSearchGroups(groups: LinksGroup[]): LinksGroup[];

package/dist/esm/components/MainMenu/utils/dedupeSearchGroups.js

@@ -0,0 +1,29 @@
+/**
+ * Один и тот же сервис может быть представлен в разных сегментах с разной
+ * детализацией — например, простой карточкой в общем каталоге и раскрытой
+ * аккордеоном карточкой с вложенными сервисами в «Центре управления». Обе
+ * версии используют общий {@link InnerLink.id}.
+ *
+ * При поиске результаты сегментов объединяются в один список (см.
+ * {@link MainMenuProps.segments}), поэтому такой сервис может совпасть сразу в
+ * нескольких сегментах. Функция оставляет только первое по порядку `groups`
+ * (то есть по приоритету сегментов) вхождение каждого id, а группы, опустевшие
+ * после удаления дублей, убирает целиком — иначе группа с тем же заголовком
+ * задублируется в выдаче.
+ */
+export function dedupeSearchGroups(groups) {
+    const seenItemIds = new Set();
+    return groups.reduce((acc, group) => {
+        const items = group.items.filter(item => {
+            if (seenItemIds.has(item.id)) {
+                return false;
+            }
+            seenItemIds.add(item.id);
+            return true;
+        });
+        if (items.length > 0) {
+            acc.push({ ...group, items });
+        }
+        return acc;
+    }, []);
+}

package/dist/esm/components/MainMenu/utils/dnd/favoriteListCollisionDetection.d.ts

@@ -0,0 +1,2 @@
+import { CollisionDetection } from '@dnd-kit/core';
+export declare const favoriteListCollisionDetection: CollisionDetection;

package/dist/esm/components/MainMenu/utils/dnd/favoriteListCollisionDetection.js

@@ -0,0 +1,28 @@
+import { closestCenter, rectIntersection } from '@dnd-kit/core';
+import { FAVORITES_DROP_ID, isFavoritesDroppableId, isServiceDragId, isServiceFavoriteDragId } from './ids.js';
+export const favoriteListCollisionDetection = args => {
+    const collisions = closestCenter(args);
+    // Group reorder: ignore favorites droppables so they don't steal collisions from groups.
+    if (!isServiceDragId(args.active.id)) {
+        return collisions.filter(({ id }) => !isFavoritesDroppableId(id));
+    }
+    // Favorite reorder: stay among favorite cards.
+    if (isServiceFavoriteDragId(args.active.id)) {
+        return collisions.filter(({ id }) => isServiceFavoriteDragId(id));
+    }
+    // Source → favorites: only when pointer (or rect) actually hits the favorites panel.
+    // closestCenter always returns a nearest favorite even while still over the catalog —
+    // that would add the card on a pick-up-and-release without moving into favorites.
+    // const hits = args.pointerCoordinates ? pointerWithin(args) : rectIntersection(args);
+    const hits = rectIntersection(args);
+    const hasFavoriteCards = args.droppableContainers.some(({ id }) => id != null && isServiceFavoriteDragId(id));
+    // With cards in the list, ignore FAVORITES_DROP_ID — padding/gaps would otherwise
+    // oscillate between "append" and a card-based insert index.
+    const favoriteHits = hits.filter(({ id }) => {
+        if (isServiceFavoriteDragId(id)) {
+            return true;
+        }
+        return id === FAVORITES_DROP_ID && !hasFavoriteCards;
+    });
+    return favoriteHits;
+};

package/dist/esm/components/MainMenu/utils/dnd/getDragReferenceY.d.ts

@@ -0,0 +1,9 @@
+import { ClientRectLike } from './getFavoriteInsertIndex.js';
+type GetDragReferenceYParams = {
+    activatorEvent?: Event | null;
+    deltaY?: number;
+    activeRect?: ClientRectLike | null;
+};
+/** Pointer Y (activator + delta), or active rect center as fallback (keyboard). */
+export declare function getDragReferenceY({ activatorEvent, deltaY, activeRect }: GetDragReferenceYParams): number | null;
+export {};

package/dist/esm/components/MainMenu/utils/dnd/getDragReferenceY.js

@@ -0,0 +1,14 @@
+import { getEventCoordinates } from '@dnd-kit/utilities';
+/** Pointer Y (activator + delta), or active rect center as fallback (keyboard). */
+export function getDragReferenceY({ activatorEvent, deltaY = 0, activeRect }) {
+    if (activatorEvent) {
+        const coordinates = getEventCoordinates(activatorEvent);
+        if (coordinates) {
+            return coordinates.y + deltaY;
+        }
+    }
+    if (!activeRect) {
+        return null;
+    }
+    return activeRect.top + activeRect.height / 2;
+}

package/dist/esm/components/MainMenu/utils/dnd/getFavoriteInsertIndex.d.ts

@@ -0,0 +1,12 @@
+export type ClientRectLike = Pick<ClientRect, 'top' | 'height'>;
+/** Before `overIndex` if referenceY is above the over item center, otherwise after. */
+export declare function getInsertIndexByRects(overIndex: number, referenceY?: number | null, overRect?: ClientRectLike | null): number;
+export type GetFavoriteInsertIndexParams = {
+    activeId: string | number;
+    overId?: string | number;
+    favoriteIds: string[];
+    referenceY?: number | null;
+    overRect?: ClientRectLike | null;
+};
+/** Insert index for a new source card; shared by indicator and drag-end. */
+export declare function getFavoriteInsertIndex({ activeId, overId, favoriteIds, referenceY, overRect, }: GetFavoriteInsertIndexParams): number | null;

package/dist/esm/components/MainMenu/utils/dnd/getFavoriteInsertIndex.js

@@ -0,0 +1,32 @@
+import { FAVORITES_DROP_ID, isServiceFavoriteDragId, isServiceSourceDragId, parseServiceDragId } from './ids.js';
+/** Before `overIndex` if referenceY is above the over item center, otherwise after. */
+export function getInsertIndexByRects(overIndex, referenceY, overRect) {
+    if (referenceY == null || !overRect) {
+        return overIndex;
+    }
+    const overCenterY = overRect.top + overRect.height / 2;
+    return referenceY > overCenterY ? overIndex + 1 : overIndex;
+}
+/** Insert index for a new source card; shared by indicator and drag-end. */
+export function getFavoriteInsertIndex({ activeId, overId, favoriteIds, referenceY, overRect, }) {
+    if (!isServiceSourceDragId(activeId) || overId == null) {
+        return null;
+    }
+    const activeServiceId = parseServiceDragId(activeId);
+    if (favoriteIds.includes(activeServiceId)) {
+        return null;
+    }
+    // Empty list only: drop zone is the sole target. With cards, ignore it — padding/gaps
+    // would make the indicator jump between "append" and card before/after.
+    if (String(overId) === FAVORITES_DROP_ID) {
+        return favoriteIds.length === 0 ? 0 : null;
+    }
+    if (!isServiceFavoriteDragId(overId)) {
+        return null;
+    }
+    const overIndex = favoriteIds.indexOf(parseServiceDragId(overId));
+    if (overIndex === -1) {
+        return null;
+    }
+    return getInsertIndexByRects(overIndex, referenceY, overRect);
+}

package/dist/esm/components/MainMenu/utils/dnd/ids.d.ts

@@ -0,0 +1,8 @@
+export declare const FAVORITES_DROP_ID = "favorites-drop-zone";
+export declare function getServiceSourceDragId(groupId: string, serviceId: string): string;
+export declare function getServiceFavoriteDragId(serviceId: string): string;
+export declare function isServiceSourceDragId(id: string | number | symbol): boolean;
+export declare function isServiceFavoriteDragId(id: string | number | symbol): boolean;
+export declare function isServiceDragId(id: string | number | symbol): boolean;
+export declare function isFavoritesDroppableId(id: string | number | symbol): boolean;
+export declare function parseServiceDragId(id: string | number | symbol): string;

package/dist/esm/components/MainMenu/utils/dnd/ids.js

@@ -0,0 +1,38 @@
+const SERVICE_DRAG_SOURCE_PREFIX = 'service-drag:source:';
+const SERVICE_DRAG_FAVORITE_PREFIX = 'service-drag:favorite:';
+// Символьный сепаратор для исключения пересечения с символами, которые могут быть в groupId или serviceId
+const SERVICE_DRAG_SOURCE_GROUP_SEPARATOR = '\u0000';
+export const FAVORITES_DROP_ID = 'favorites-drop-zone';
+export function getServiceSourceDragId(groupId, serviceId) {
+    return `${SERVICE_DRAG_SOURCE_PREFIX}${groupId}${SERVICE_DRAG_SOURCE_GROUP_SEPARATOR}${serviceId}`;
+}
+export function getServiceFavoriteDragId(serviceId) {
+    return `${SERVICE_DRAG_FAVORITE_PREFIX}${serviceId}`;
+}
+export function isServiceSourceDragId(id) {
+    return String(id).startsWith(SERVICE_DRAG_SOURCE_PREFIX);
+}
+export function isServiceFavoriteDragId(id) {
+    return String(id).startsWith(SERVICE_DRAG_FAVORITE_PREFIX);
+}
+export function isServiceDragId(id) {
+    return isServiceSourceDragId(id) || isServiceFavoriteDragId(id);
+}
+export function isFavoritesDroppableId(id) {
+    return id === FAVORITES_DROP_ID || isServiceFavoriteDragId(id);
+}
+export function parseServiceDragId(id) {
+    const value = String(id);
+    if (value.startsWith(SERVICE_DRAG_SOURCE_PREFIX)) {
+        const rest = value.slice(SERVICE_DRAG_SOURCE_PREFIX.length);
+        const separatorIndex = rest.lastIndexOf(SERVICE_DRAG_SOURCE_GROUP_SEPARATOR);
+        if (separatorIndex >= 0) {
+            return rest.slice(separatorIndex + 1);
+        }
+        return rest;
+    }
+    if (value.startsWith(SERVICE_DRAG_FAVORITE_PREFIX)) {
+        return value.slice(SERVICE_DRAG_FAVORITE_PREFIX.length);
+    }
+    return value;
+}

package/dist/esm/components/MainMenu/utils/dnd/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ids.js';
+export * from './getDragReferenceY.js';
+export * from './getFavoriteInsertIndex.js';
+export * from './resolveFavoriteOrderOnDragEnd.js';
+export * from './favoriteListCollisionDetection.js';

package/dist/esm/components/MainMenu/utils/dnd/index.js

@@ -0,0 +1,5 @@
+export * from './ids.js';
+export * from './getDragReferenceY.js';
+export * from './getFavoriteInsertIndex.js';
+export * from './resolveFavoriteOrderOnDragEnd.js';
+export * from './favoriteListCollisionDetection.js';

package/dist/esm/components/MainMenu/utils/dnd/resolveFavoriteOrderOnDragEnd.d.ts

@@ -0,0 +1,10 @@
+import { ClientRectLike } from './getFavoriteInsertIndex.js';
+type ResolveFavoriteOrderOnDragEndParams = {
+    activeId: string | number;
+    overId?: string | number;
+    favoriteIds: string[];
+    referenceY?: number | null;
+    overRect?: ClientRectLike | null;
+};
+export declare function resolveFavoriteOrderOnDragEnd({ activeId, overId, favoriteIds, referenceY, overRect, }: ResolveFavoriteOrderOnDragEndParams): string[] | null;
+export {};

package/dist/esm/components/MainMenu/utils/dnd/resolveFavoriteOrderOnDragEnd.js

@@ -0,0 +1,42 @@
+import { arrayMove } from '@dnd-kit/sortable';
+import { getFavoriteInsertIndex } from './getFavoriteInsertIndex.js';
+import { FAVORITES_DROP_ID, isServiceDragId, isServiceFavoriteDragId, parseServiceDragId } from './ids.js';
+export function resolveFavoriteOrderOnDragEnd({ activeId, overId, favoriteIds, referenceY, overRect, }) {
+    if (!isServiceDragId(activeId) || overId == null) {
+        return null;
+    }
+    const activeServiceId = parseServiceDragId(activeId);
+    const activeFavoriteIndex = isServiceFavoriteDragId(activeId) ? favoriteIds.indexOf(activeServiceId) : -1;
+    // Reorder an existing favorite.
+    if (activeFavoriteIndex !== -1) {
+        if (String(overId) === FAVORITES_DROP_ID) {
+            const lastIndex = favoriteIds.length - 1;
+            if (activeFavoriteIndex === lastIndex) {
+                return null;
+            }
+            return arrayMove(favoriteIds, activeFavoriteIndex, lastIndex);
+        }
+        if (!isServiceFavoriteDragId(overId)) {
+            return null;
+        }
+        const overFavoriteIndex = favoriteIds.indexOf(parseServiceDragId(overId));
+        if (overFavoriteIndex === -1 || activeFavoriteIndex === overFavoriteIndex) {
+            return null;
+        }
+        return arrayMove(favoriteIds, activeFavoriteIndex, overFavoriteIndex);
+    }
+    // Insert from catalog — same index as the insert indicator.
+    const insertIndex = getFavoriteInsertIndex({
+        activeId,
+        overId,
+        favoriteIds,
+        referenceY,
+        overRect,
+    });
+    if (insertIndex == null) {
+        return null;
+    }
+    const nextOrder = [...favoriteIds];
+    nextOrder.splice(insertIndex, 0, activeServiceId);
+    return nextOrder;
+}

package/dist/esm/components/MainMenu/utils/filterLinksGroupsFuzzy.d.ts

@@ -0,0 +1,2 @@
+import { LinksGroup } from '../types.js';
+export declare function filterLinksGroupsFuzzy(searchValue: string, links: LinksGroup[]): LinksGroup[];

package/dist/esm/components/MainMenu/utils/filterLinksGroupsFuzzy.js

@@ -0,0 +1,149 @@
+import Fuse from 'fuse.js';
+import { FUZZY_SEARCH_THRESHOLD, SearchGroupsAccessor } from '../constants.js';
+import { findNestedInnerLinkParent, flatInnerLinks, hasNestedItems } from './innerLink.js';
+import { toggleLayout } from './search.js';
+const prepareItemAccessorKey = (groupId, alias) => `${groupId}-${alias}`;
+function createItemsMap(links) {
+    const itemsMap = {};
+    links.forEach(group => {
+        flatInnerLinks(group.items).forEach(item => {
+            item.aliases.forEach(alias => {
+                const key = prepareItemAccessorKey(group.id, alias);
+                itemsMap[key] = item;
+            });
+        });
+    });
+    return itemsMap;
+}
+function appendFilteredGroupItem(group, itemsInnerMap, items, item) {
+    if (!itemsInnerMap[item.id]) {
+        itemsInnerMap[item.id] = item;
+        items.push(item);
+    }
+}
+function appendNestedLeafMatch(group, itemsInnerMap, items, leafItem) {
+    const parent = findNestedInnerLinkParent(group, leafItem.id);
+    if (!parent) {
+        appendFilteredGroupItem(group, itemsInnerMap, items, leafItem);
+        return;
+    }
+    const existingParent = itemsInnerMap[parent.id];
+    if (existingParent) {
+        const hasLeaf = existingParent.items?.some(item => item.id === leafItem.id);
+        if (!hasLeaf) {
+            existingParent.items = [...(existingParent.items ?? []), leafItem];
+        }
+        return;
+    }
+    itemsInnerMap[parent.id] = {
+        ...parent,
+        items: [leafItem],
+    };
+    items.push(itemsInnerMap[parent.id]);
+}
+function isGroupLabelMatch(matchKey) {
+    return (matchKey === SearchGroupsAccessor.GroupLabelText ||
+        matchKey === SearchGroupsAccessor.GroupId ||
+        matchKey === SearchGroupsAccessor.GroupAliases);
+}
+export function filterLinksGroupsFuzzy(searchValue, links) {
+    if (!searchValue) {
+        return links;
+    }
+    const itemsMap = createItemsMap(links);
+    const linksFuse = new Fuse(links, {
+        keys: Object.values(SearchGroupsAccessor),
+        includeMatches: true,
+        threshold: FUZZY_SEARCH_THRESHOLD,
+    });
+    let fuseSearchResults = linksFuse.search(searchValue);
+    if (fuseSearchResults.length < 1) {
+        const fixedLayoutValue = toggleLayout(searchValue);
+        fuseSearchResults = linksFuse.search(fixedLayoutValue);
+    }
+    return fuseSearchResults.reduce((accResult, fuseResult) => {
+        if (!fuseResult.matches) {
+            return accResult;
+        }
+        const isMatchByGroup = fuseResult.matches.some(match => isGroupLabelMatch(match.key));
+        if (isMatchByGroup) {
+            accResult.push(fuseResult.item);
+            return accResult;
+        }
+        const group = fuseResult.item;
+        const originalGroupIndex = fuseResult.refIndex;
+        const itemsInnerMap = {};
+        const items = [];
+        fuseResult.matches.forEach(match => {
+            if (match.refIndex === undefined) {
+                return;
+            }
+            switch (match.key) {
+                case SearchGroupsAccessor.ItemLabelText:
+                case SearchGroupsAccessor.ItemId: {
+                    const item = links[originalGroupIndex].items[match.refIndex];
+                    if (item && !item.hidden) {
+                        if (hasNestedItems(item)) {
+                            appendFilteredGroupItem(group, itemsInnerMap, items, item);
+                        }
+                        else {
+                            appendNestedLeafMatch(group, itemsInnerMap, items, item);
+                        }
+                    }
+                    break;
+                }
+                case SearchGroupsAccessor.ItemNestedLabelText:
+                case SearchGroupsAccessor.ItemNestedId: {
+                    // Fuse `refIndex` для `items.items.*` — индекс во вложенном массиве (или «плоский» по всем
+                    // nested), а не индекс родителя в `group.items`. Ищем leaf по value среди всех родителей.
+                    const nestedItem = links[originalGroupIndex].items
+                        .flatMap(parent => parent.items ?? [])
+                        .find(child => match.key === SearchGroupsAccessor.ItemNestedLabelText
+                        ? child.label === match.value
+                        : child.id === match.value);
+                    if (nestedItem && !nestedItem.hidden) {
+                        appendNestedLeafMatch(group, itemsInnerMap, items, nestedItem);
+                    }
+                    break;
+                }
+                case SearchGroupsAccessor.ItemNestedAliases: {
+                    if (!match.value) {
+                        break;
+                    }
+                    const groupId = fuseResult.item.id;
+                    const alias = match.value;
+                    const key = prepareItemAccessorKey(groupId, alias);
+                    const item = itemsMap[key];
+                    if (item) {
+                        appendNestedLeafMatch(group, itemsInnerMap, items, item);
+                    }
+                    break;
+                }
+                case SearchGroupsAccessor.ItemAliases: {
+                    if (!match.value) {
+                        break;
+                    }
+                    const groupId = fuseResult.item.id;
+                    const alias = match.value;
+                    const key = prepareItemAccessorKey(groupId, alias);
+                    const item = itemsMap[key];
+                    if (item) {
+                        appendNestedLeafMatch(group, itemsInnerMap, items, item);
+                    }
+                    break;
+                }
+                case SearchGroupsAccessor.GroupLabelText:
+                case SearchGroupsAccessor.GroupId:
+                default:
+                    return;
+            }
+        });
+        if (items.length > 0) {
+            accResult.push({
+                ...group,
+                items,
+            });
+        }
+        return accResult;
+    }, []);
+}

package/dist/esm/components/MainMenu/utils/flatLinksGroups.d.ts

@@ -0,0 +1,2 @@
+import { InnerLink, LinksGroup } from '../types.js';
+export declare function flatLinksGroups(groups?: LinksGroup[]): InnerLink[];

package/dist/esm/components/MainMenu/utils/flatLinksGroups.js

@@ -0,0 +1,4 @@
+import { flatInnerLinks } from './innerLink.js';
+export function flatLinksGroups(groups = []) {
+    return groups.flatMap(({ items }) => flatInnerLinks(items));
+}

package/dist/esm/components/MainMenu/utils/getAvatarNameFromLabel.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Формирует двухбуквенный текст для пропа `name` компонента Avatar в MainMenu.
+ *
+ * - Одно слово — первые две буквы в верхнем регистре (`Маркетплейс` → `МА`).
+ * - Два и более слов — первая буква первых двух слов (`Партнерский кабинет` → `ПК`).
+ *
+ * @param label — подпись карточки (`InnerLink.label`).
+ * @returns Строка из двух символов для отображения в аватаре.
+ *
+ * @example
+ * getAvatarNameFromLabel('Маркетплейс'); // 'МА'
+ * getAvatarNameFromLabel('Партнерский кабинет'); // 'ПК'
+ */
+export declare function getAvatarNameFromLabel(label: string): string;

package/dist/esm/components/MainMenu/utils/getAvatarNameFromLabel.js

@@ -0,0 +1,21 @@
+/**
+ * Формирует двухбуквенный текст для пропа `name` компонента Avatar в MainMenu.
+ *
+ * - Одно слово — первые две буквы в верхнем регистре (`Маркетплейс` → `МА`).
+ * - Два и более слов — первая буква первых двух слов (`Партнерский кабинет` → `ПК`).
+ *
+ * @param label — подпись карточки (`InnerLink.label`).
+ * @returns Строка из двух символов для отображения в аватаре.
+ *
+ * @example
+ * getAvatarNameFromLabel('Маркетплейс'); // 'МА'
+ * getAvatarNameFromLabel('Партнерский кабинет'); // 'ПК'
+ */
+export function getAvatarNameFromLabel(label) {
+    const words = label.trim().split(/\s+/).filter(Boolean);
+    if (words.length >= 2) {
+        return `${words[0][0] ?? ''}${words[1][0] ?? ''}`.toUpperCase();
+    }
+    const word = words[0] ?? '';
+    return word.slice(0, 2).toUpperCase();
+}

package/dist/esm/components/MainMenu/utils/getLinkEmblem.d.ts

@@ -0,0 +1,3 @@
+import { CardServiceLightProps } from '@cloud-ru/ds-uikit-product-card-predefined';
+import { InnerLink } from '../types.js';
+export declare function getLinkEmblem(link: InnerLink): CardServiceLightProps['icon'];

package/dist/esm/components/MainMenu/utils/getLinkEmblem.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Avatar } from '@cloud-ru/ds-avatar';
+import { createElement } from 'react';
+import { getAvatarNameFromLabel } from './getAvatarNameFromLabel.js';
+function createAvatarIcon(displayName) {
+    return function LinkAvatarIcon({ className }) {
+        return (_jsx(Avatar, { name: displayName, showTwoSymbols: true, shape: 'squared', appearance: 'neutral', size: 's', className: className }));
+    };
+}
+export function getLinkEmblem(link) {
+    if (!link.icon) {
+        return createElement(createAvatarIcon(getAvatarNameFromLabel(link.label)));
+    }
+    return createElement(link.icon);
+}

package/dist/esm/components/MainMenu/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from './innerLink.js';
+export * from './getAvatarNameFromLabel.js';
+export * from './flatLinksGroups.js';
+export * from './getLinkEmblem.js';
+export * from './mapInnerLinksToListItems.js';
+export * from './pinGroupToBottom.js';
+export * from './dedupeSearchGroups.js';
+export * from './filterLinksGroupsFuzzy.js';
+export * from './resolveInnerLinksByIds.js';
+export * from './mapOrderedFavoriteIdsToLinks.js';
+export * from './resolveGroupBlockColor.js';
+export * from './dnd/index.js';

package/dist/esm/components/MainMenu/utils/index.js

@@ -0,0 +1,12 @@
+export * from './innerLink.js';
+export * from './getAvatarNameFromLabel.js';
+export * from './flatLinksGroups.js';
+export * from './getLinkEmblem.js';
+export * from './mapInnerLinksToListItems.js';
+export * from './pinGroupToBottom.js';
+export * from './dedupeSearchGroups.js';
+export * from './filterLinksGroupsFuzzy.js';
+export * from './resolveInnerLinksByIds.js';
+export * from './mapOrderedFavoriteIdsToLinks.js';
+export * from './resolveGroupBlockColor.js';
+export * from './dnd/index.js';

package/dist/esm/components/MainMenu/utils/innerLink.d.ts

@@ -0,0 +1,7 @@
+import { InnerLink, LinksGroup } from '../types.js';
+export declare function hasNestedItems(item: InnerLink): boolean;
+export declare function flatInnerLinks(items?: InnerLink[]): InnerLink[];
+export declare function getLinksGroupVisibleItemsCount(group: LinksGroup): number;
+export declare function getSubCategoryId(groupId: string, serviceId: string): string;
+export declare function getNestedServiceGroupId(groupId: string, serviceId: string): string;
+export declare function findNestedInnerLinkParent(group: LinksGroup, leafId: string): InnerLink | undefined;

package/dist/esm/components/MainMenu/utils/innerLink.js

@@ -0,0 +1,34 @@
+export function hasNestedItems(item) {
+    return Boolean(item.items?.some(child => !child.hidden));
+}
+export function flatInnerLinks(items = []) {
+    return items.flatMap(item => {
+        if (item.hidden) {
+            return [];
+        }
+        if (hasNestedItems(item)) {
+            return [item, ...flatInnerLinks(item.items)];
+        }
+        return [item];
+    });
+}
+export function getLinksGroupVisibleItemsCount(group) {
+    return group.items.reduce((count, item) => {
+        if (item.hidden) {
+            return count;
+        }
+        if (hasNestedItems(item)) {
+            return count + flatInnerLinks(item.items).length;
+        }
+        return count + 1;
+    }, 0);
+}
+export function getSubCategoryId(groupId, serviceId) {
+    return `${groupId}__${serviceId}`;
+}
+export function getNestedServiceGroupId(groupId, serviceId) {
+    return `${groupId}/${serviceId}`;
+}
+export function findNestedInnerLinkParent(group, leafId) {
+    return group.items.find(item => hasNestedItems(item) && item.items?.some(child => child.id === leafId));
+}

package/dist/esm/components/MainMenu/utils/mapInnerLinksToListItems.d.ts

@@ -0,0 +1,3 @@
+import { BaseItemProps } from '@cloud-ru/ds-list';
+import { InnerLink } from '../types.js';
+export declare function mapInnerLinksToListItems(items: InnerLink[]): BaseItemProps[];

package/dist/esm/components/MainMenu/utils/mapInnerLinksToListItems.js

@@ -0,0 +1,13 @@
+import { getLinkEmblem } from './getLinkEmblem.js';
+export function mapInnerLinksToListItems(items) {
+    return items.map(link => ({
+        id: link.id,
+        content: {
+            label: link.label,
+        },
+        beforeContent: getLinkEmblem(link),
+        onClick: link.onClick,
+        href: link.href,
+        disabled: link.disabled,
+    }));
+}

package/dist/esm/components/MainMenu/utils/mapOrderedFavoriteIdsToLinks.d.ts

@@ -0,0 +1,2 @@
+import { InnerLink } from '../types.js';
+export declare function mapOrderedFavoriteIdsToLinks(orderedIds: string[], currentFavorites: InnerLink[], catalog: Map<string, InnerLink>): InnerLink[];

package/dist/esm/components/MainMenu/utils/mapOrderedFavoriteIdsToLinks.js

@@ -0,0 +1,6 @@
+export function mapOrderedFavoriteIdsToLinks(orderedIds, currentFavorites, catalog) {
+    const currentById = new Map(currentFavorites.map(service => [service.id, service]));
+    return orderedIds
+        .map(id => currentById.get(id) ?? catalog.get(id))
+        .filter((service) => Boolean(service));
+}

package/dist/esm/components/MainMenu/utils/pinGroupToBottom.d.ts

@@ -0,0 +1,2 @@
+import { LinksGroup } from '../types.js';
+export declare function pinGroupToBottom(groups: LinksGroup[], adminGroupIds: string | string[]): LinksGroup[];

package/dist/esm/components/MainMenu/utils/pinGroupToBottom.js

@@ -0,0 +1,12 @@
+export function pinGroupToBottom(groups, adminGroupIds) {
+    const ids = Array.isArray(adminGroupIds) ? adminGroupIds : [adminGroupIds];
+    if (ids.length === 0) {
+        return groups;
+    }
+    const adminIdSet = new Set(ids);
+    const adminGroups = ids
+        .map(id => groups.find(group => group.id === id))
+        .filter((group) => Boolean(group));
+    const otherGroups = groups.filter(group => !adminIdSet.has(group.id));
+    return [...otherGroups, ...adminGroups];
+}

package/dist/esm/components/MainMenu/utils/resolveGroupBlockColor.d.ts

@@ -0,0 +1,8 @@
+import { LinksGroupBlockColor } from '../types.js';
+/**
+ * Резолвит цвет блока группы с учётом глобального переключателя `showGroupsColors`.
+ *
+ * `showGroupsColors === false` скрывает цвета всех групп — возвращает `undefined`,
+ * что даёт `SortableGroup` дефолт `'neutral'`.
+ */
+export declare function resolveGroupBlockColor(blockColor: LinksGroupBlockColor | undefined, showGroupsColors: boolean | undefined): LinksGroupBlockColor | undefined;

package/dist/esm/components/MainMenu/utils/resolveGroupBlockColor.js

@@ -0,0 +1,9 @@
+/**
+ * Резолвит цвет блока группы с учётом глобального переключателя `showGroupsColors`.
+ *
+ * `showGroupsColors === false` скрывает цвета всех групп — возвращает `undefined`,
+ * что даёт `SortableGroup` дефолт `'neutral'`.
+ */
+export function resolveGroupBlockColor(blockColor, showGroupsColors) {
+    return showGroupsColors === false ? undefined : blockColor;
+}

package/dist/esm/components/MainMenu/utils/resolveInnerLinksByIds.d.ts

@@ -0,0 +1,2 @@
+import { InnerLink, LinksGroup } from '../types.js';
+export declare function resolveInnerLinksByIds(ids: string[], groups: LinksGroup[]): InnerLink[];