@uxland/primary-shell 5.4.7 → 5.6.0

package/dist/primary/shell/src/UI/components/primaria-shell/shell-header/header-divider/header-divider.d.ts

@@ -0,0 +1,6 @@
+import { LitElement } from 'lit';
+
+export declare class HeaderDivider extends LitElement {
+    render(): import('lit').TemplateResult<1>;
+    static styles: import('lit').CSSResult;
+}

package/dist/primary/shell/src/UI/components/primaria-shell/shell-header/header-divider/template.d.ts

@@ -0,0 +1,3 @@
+import { HeaderDivider } from './header-divider';
+
+export declare const template: (props: HeaderDivider) => import('lit').TemplateResult<1>;

package/dist/primary/shell/src/UI/components/primaria-shell/shell-header/shell-header.d.ts

@@ -12,5 +12,6 @@ export declare class PrimariaShellHeader extends PrimariaShellHeader_base {
     toggleMenu(): void;
     logout(): void;
     connectedCallback(): void;
+    firstUpdated(): void;
 }
 export {};

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/add/handle-busy/busy-component/component.d.ts

@@ -3,6 +3,7 @@ import { LitElement } from 'lit';
 export declare class ActivityHistoryBusy extends LitElement {
     render(): import('lit').TemplateResult<1>;
     static styles: import('lit').CSSResult;
-    isAnyCollectionLoadingWithoutAnyLoaded: boolean;
+    isCollectionInitialState: boolean;
     isSomeCollectionLoadedAndOtherLoading: boolean;
+    get skeletons(): import('lit').TemplateResult<1>[];
 }

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/add/handle-busy/selectors.d.ts

@@ -1,4 +1,4 @@
 import { RootState } from '../../../infrastructure/state/store';
 
-export declare const isAnyCollectionLoadingWithoutAnyLoaded: (state: RootState) => boolean;
 export declare const isSomeCollectionLoadedAndOtherLoading: (state: RootState) => boolean;
+export declare const isCollectionInitialState: (state: RootState) => boolean;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/specs/up-filter-spec.d.ts

@@ -0,0 +1,8 @@
+import { IActivityHistoryItem } from '../model';
+import { Spec } from './spec';
+
+export declare class UpFilterSpec extends Spec<IActivityHistoryItem> {
+    private upIds;
+    constructor(upIds: string[]);
+    isSatisfiedBy(item: IActivityHistoryItem): boolean;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/specs/up-filter-spec.test.d.ts

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

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-badges/active-filters-badges.d.ts

@@ -1,6 +1,6 @@
 import { LitElement } from 'lit';
 import { PrimariaApi } from '../../../../../../api/api';
-import { IActivityHistoryCustomFilterGroup, IActivityHistoryDiagnosticsFilter, IActivityHistoryFilter } from '../../model';
+import { IActivityHistoryCustomFilterGroup, IActivityHistoryDiagnosticsFilter, IActivityHistoryFilter, IActivityHistoryUpFilter } from '../../model';
 
 export declare class ActiveFiltersBadges extends LitElement {
     render(): import('lit').TemplateResult<1>;
@@ -10,8 +10,10 @@ export declare class ActiveFiltersBadges extends LitElement {
     enabledCommonFilters: IActivityHistoryFilter[];
     enabledFilters: IActivityHistoryCustomFilterGroup[];
     diagnosticFilterEnabled: IActivityHistoryDiagnosticsFilter;
+    upFilterEnabled: IActivityHistoryUpFilter;
     _onDeleteFilterValue(filterGroupId: string, filterId: string, optionId: string, value: boolean): void;
     _onDeleteCommonFilterValue(filterId: string): void;
     _onDeleteDiagnosticFilterValue(diagnosticValue: string): void;
+    _onDeleteUpFilterValue(upValue: string): void;
     resetFilters(): void;
 }

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-header/active-filters-header.d.ts

@@ -7,4 +7,5 @@ export declare class ActiveFiltersHeader extends LitElement {
     areCustomFiltersActive: boolean;
     areCommonFiltersActive: boolean;
     areDiagnosticFiltersActive: boolean;
+    areUpFiltersActive: boolean;
 }

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/UI/activity-history-filters/activity-history-filters.d.ts

@@ -1,6 +1,6 @@
 import { LitElement } from 'lit';
 import { PrimariaApi } from '../../../../../../api/api';
-import { IActivityHistoryCommonFilter, IActivityHistoryCustomFilterGroup, IActivityHistoryDiagnosticsFilter } from '../../model';
+import { IActivityHistoryCommonFilter, IActivityHistoryCustomFilterGroup, IActivityHistoryDiagnosticsFilter, IActivityHistoryUpFilter } from '../../model';
 
 export declare class ActivityHistoryFilters extends LitElement {
     render(): import('lit').TemplateResult<1>;
@@ -9,6 +9,8 @@ export declare class ActivityHistoryFilters extends LitElement {
     customFilterGroups: IActivityHistoryCustomFilterGroup[];
     diagnosticFilter: IActivityHistoryDiagnosticsFilter;
     diagnosticFilterEnabledValues: string[];
+    upFilter: IActivityHistoryUpFilter;
+    upFilterEnabledValues: string[];
     api: PrimariaApi;
     filtersExpanded: boolean;
     wrapperMaximized: boolean;
@@ -18,4 +20,5 @@ export declare class ActivityHistoryFilters extends LitElement {
     _onChangeCustomFilterGroupValue(filterGroupId: string, value: boolean): void;
     _onChangeCustomFilterValue(filterGroupId: string, filterId: string, optionId: string, value: boolean): void;
     _handleDiagnosticFilterChange(e: CustomEvent): void;
+    _handleUpFilterChange(e: CustomEvent): void;
 }

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/model.d.ts

@@ -4,7 +4,8 @@ import { Spec } from '../domain/specs/spec';
 type Constructor<T> = new (...args: any[]) => T;
 export declare enum ActivityHistoryFilterType {
     Switch = "switch",
-    Checkbox = "checkbox"
+    Checkbox = "checkbox",
+    Dropdown = "dropdown"
 }
 export declare enum ActivityHistoryFilterOperation {
     And = "and",
@@ -49,6 +50,7 @@ export declare const isNotCommonFilterGroup: (group: IActivityHistoryFilter) =>
 export declare const isDiagnosticFilter: (filter: IActivityHistoryFilter) => boolean;
 export declare const isNotDiagnosticFilter: (filter: IActivityHistoryFilter) => boolean;
 export declare const isCustomFilter: (filter: IActivityHistoryFilter) => boolean;
+export declare const isUpFilter: (filter: IActivityHistoryFilter) => boolean;
 export interface IActivityHistoryDiagnosticsFilter {
     id: string;
     title: string;
@@ -58,7 +60,17 @@ export interface IActivityHistoryDiagnosticsFilter {
     }[];
     enabledValues: string[];
 }
+export interface IActivityHistoryUpFilter {
+    id: string;
+    title: string;
+    values: {
+        label: string;
+        value: string;
+    }[];
+    enabledValues: string[];
+}
 export declare const diagnosticsfilterId = "history-diagnostics";
 export declare const relevantFilterId = "history-relevant";
 export declare const ownFilterId = "history-own";
+export declare const upFilterId = "history-up";
 export {};

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/slice.d.ts

@@ -8,6 +8,8 @@ import { addDiagnosticFiltersReducer } from './diagnostic-filters/add/reducer';
 import { setDiagnosticFilterValuesReducer } from './diagnostic-filters/set/reducer';
 import { resetCommonFilterValuesReducer } from './common-filters/reset-common-filter/reducer';
 import { resetCustomFilterValuesReducer } from './custom-filters/reset-custom-filter/reducer';
+import { addUpFiltersReducer } from './up-filters/add/reducer';
+import { setUpFilterValuesReducer } from './up-filters/set/reducer';
 
 export declare const activityHistoryFiltersSlice: import('@reduxjs/toolkit').Slice<{
     searchString: string;
@@ -22,6 +24,8 @@ export declare const activityHistoryFiltersSlice: import('@reduxjs/toolkit').Sli
     resetCustomFilterValues: typeof resetCustomFilterValuesReducer;
     addDiagnosticFilters: typeof addDiagnosticFiltersReducer;
     setDiagnosticFilterValues: typeof setDiagnosticFilterValuesReducer;
+    addUpFilters: typeof addUpFiltersReducer;
+    setUpFilterValues: typeof setUpFilterValuesReducer;
 }, "activity-history-filters", "activity-history-filters", import('@reduxjs/toolkit').SliceSelectors<{
     searchString: string;
     filters: IActivityHistoryFilter[];

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/add/actions.d.ts

@@ -0,0 +1 @@
+export declare const addUpFilters: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('../..').IActivityHistoryUpFilter, "activity-history-filters/addUpFilters">;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/add/bootstrapper.d.ts

@@ -0,0 +1,4 @@
+import { BrokerExtensions } from '@primaria/plugins-core';
+
+export declare const bootstrapAddUpFilter: (broker: BrokerExtensions) => void;
+export declare const teardownAddUpFilter: () => void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/add/handler.d.ts

@@ -0,0 +1,6 @@
+import { StoreBaseHandler } from '../../../../infrastructure/base-handlers';
+import { AddUpFiltersCommand } from './request';
+
+export declare class AddUpFiltersHandler extends StoreBaseHandler {
+    handle(request: AddUpFiltersCommand): Promise<void>;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/add/reducer.d.ts

@@ -0,0 +1,4 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IActivityHistoryUpFilter } from '../../model';
+
+export declare function addUpFiltersReducer(state: any, action: PayloadAction<IActivityHistoryUpFilter>): void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/add/reducer.test.d.ts

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

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/add/request.d.ts

@@ -0,0 +1,6 @@
+import { IActivityHistoryUpFilter } from '../../model';
+
+export declare class AddUpFiltersCommand {
+    payload: IActivityHistoryUpFilter;
+    constructor(payload: IActivityHistoryUpFilter);
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/handle-add-up-options-from-item.d.ts

@@ -0,0 +1,4 @@
+import { Store } from '@reduxjs/toolkit';
+import { IActivityHistoryItem } from '../../domain/model';
+
+export declare const handleAddUpFilter: (items: IActivityHistoryItem[], store: Store) => void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/selectors.d.ts

@@ -0,0 +1,185 @@
+import { IActivityHistoryFilter } from '../model';
+
+export declare const upFilterSelector: ((state: {
+    activityHistoryCollections: {
+        busy: import('../../..').IBusyHistoryItem[];
+        error: import('../../..').IErrorHistoryItem[];
+        collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: IActivityHistoryFilter[];
+    };
+}) => IActivityHistoryFilter | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IActivityHistoryFilter[]) => IActivityHistoryFilter | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilter[]) => IActivityHistoryFilter | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IActivityHistoryFilter | undefined;
+    dependencies: [(state: import('../../../infrastructure/state/store').RootState) => IActivityHistoryFilter[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const upFilterEnabledValuesSelector: ((state: {
+    activityHistoryCollections: {
+        busy: import('../../..').IBusyHistoryItem[];
+        error: import('../../..').IErrorHistoryItem[];
+        collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: IActivityHistoryFilter[];
+    };
+}) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IActivityHistoryFilter | undefined) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilter | undefined) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('../../..').IBusyHistoryItem[];
+            error: import('../../..').IErrorHistoryItem[];
+            collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: IActivityHistoryFilter[];
+        };
+    }) => IActivityHistoryFilter | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: IActivityHistoryFilter[]) => IActivityHistoryFilter | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilter[]) => IActivityHistoryFilter | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IActivityHistoryFilter | undefined;
+        dependencies: [(state: import('../../../infrastructure/state/store').RootState) => IActivityHistoryFilter[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const areUpFiltersActive: ((state: {
+    activityHistoryCollections: {
+        busy: import('../../..').IBusyHistoryItem[];
+        error: import('../../..').IErrorHistoryItem[];
+        collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: IActivityHistoryFilter[];
+    };
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: string[]) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: string[]) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('../../..').IBusyHistoryItem[];
+            error: import('../../..').IErrorHistoryItem[];
+            collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: IActivityHistoryFilter[];
+        };
+    }) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: IActivityHistoryFilter | undefined) => string[];
+        memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilter | undefined) => string[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string[];
+        dependencies: [((state: {
+            activityHistoryCollections: {
+                busy: import('../../..').IBusyHistoryItem[];
+                error: import('../../..').IErrorHistoryItem[];
+                collections: Record<string, import('../../..').IActivityHistoryItemCollection>;
+            };
+            activityHistoryFilters: {
+                searchString: string;
+                filters: IActivityHistoryFilter[];
+            };
+        }) => IActivityHistoryFilter | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: IActivityHistoryFilter[]) => IActivityHistoryFilter | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryFilter[]) => IActivityHistoryFilter | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => IActivityHistoryFilter | undefined;
+            dependencies: [(state: import('../../../infrastructure/state/store').RootState) => IActivityHistoryFilter[]];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+            memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/set/actions.d.ts

@@ -0,0 +1 @@
+export declare const setUpFilterValues: import('@reduxjs/toolkit').ActionCreatorWithPayload<string[], "activity-history-filters/setUpFilterValues">;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/set/bootstrapper.d.ts

@@ -0,0 +1,4 @@
+import { BrokerExtensions } from '@primaria/plugins-core';
+
+export declare const bootstrapSetUpFilter: (broker: BrokerExtensions) => void;
+export declare const teardownSetUpFilter: () => void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/set/handler.d.ts

@@ -0,0 +1,6 @@
+import { StoreBaseHandler } from '../../../../infrastructure/base-handlers';
+import { SetUpFiltersCommand } from './request';
+
+export declare class SetUpFiltersHandler extends StoreBaseHandler {
+    handle(request: SetUpFiltersCommand): Promise<void>;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/set/reducer.d.ts

@@ -0,0 +1,3 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+
+export declare function setUpFilterValuesReducer(state: any, action: PayloadAction<string[]>): void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/filter/up-filters/set/request.d.ts

@@ -0,0 +1,4 @@
+export declare class SetUpFiltersCommand {
+    payload: string[];
+    constructor(payload: string[]);
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/UI/main-view/activity-history-main.d.ts

@@ -11,6 +11,8 @@ export declare class ActivityHistoryMain extends ActivityHistoryMain_base {
     maximized: boolean;
     api: PrimariaApi;
     historyItems: any[];
+    isCollectionInitialState: boolean;
+    isSomeCollectionLoadedAndOtherLoading: boolean;
     _maximize(): void;
     _minimize(): void;
     _subscribeEvents(): void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/selectors.d.ts

@@ -342,6 +342,66 @@ export declare const activityHistoryGroupedItems: ((state: {
     } & {
         argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
         memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, ((state: {
+        activityHistoryCollections: {
+            busy: import('..').IBusyHistoryItem[];
+            error: import('..').IErrorHistoryItem[];
+            collections: Record<string, IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('./filter').IActivityHistoryFilter[];
+        };
+    }) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('./filter').IActivityHistoryFilter | undefined) => string[];
+        memoizedResultFunc: ((resultFuncArgs_0: import('./filter').IActivityHistoryFilter | undefined) => string[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => string[];
+        dependencies: [((state: {
+            activityHistoryCollections: {
+                busy: import('..').IBusyHistoryItem[];
+                error: import('..').IErrorHistoryItem[];
+                collections: Record<string, IActivityHistoryItemCollection>;
+            };
+            activityHistoryFilters: {
+                searchString: string;
+                filters: import('./filter').IActivityHistoryFilter[];
+            };
+        }) => import('./filter').IActivityHistoryFilter | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import('./filter').IActivityHistoryFilter[]) => import('./filter').IActivityHistoryFilter | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: import('./filter').IActivityHistoryFilter[]) => import('./filter').IActivityHistoryFilter | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => import('./filter').IActivityHistoryFilter | undefined;
+            dependencies: [(state: RootState) => import('./filter').IActivityHistoryFilter[]];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+            memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
     }];
     recomputations: () => number;
     resetRecomputations: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "5.4.7",
+  "version": "5.6.0",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",
@@ -31,7 +31,7 @@
   "devDependencies": {
     "@primaria/plugins-core": "^1.0.14",
     "@reduxjs/toolkit": "^2.6.1",
-    "@salut/design-system-salut": "../../design-system-salut-2.5.1.tgz",
+    "@salut/design-system-salut": "../../design-system-salut-2.6.0.tgz",
     "@types/react": "^19.0.12",
     "@uxland/lit-utilities": "^1.0.0",
     "@uxland/localization": "^1.0.3",

package/src/UI/components/bootstrapper.ts

@@ -7,6 +7,7 @@ import { PocEventsEcap } from "./poc-events-ecap/poc-events-ecap";
 import { FinalizeVisitButton } from "../../features/visit/finalize-visit/component/finalize-visit-button";
 import { PrimariaAccordion } from "./primaria-accordion/primaria-accordion";
 import { CommunicationActionMenu } from "./communication-action-menu/communication-action-menu";
+import { HeaderDivider } from "./primaria-shell/shell-header/header-divider/header-divider";
 
 export const useComponents = () => {
   //@ts-ignore
@@ -16,6 +17,7 @@ export const useComponents = () => {
   customElement("primaria-error-view")(PrimariaErrorView);
   customElement("quick-actions-menu")(QuickActionsMenu);
   customElement("finalize-visit-button")(FinalizeVisitButton);
+  customElement('header-divider')(HeaderDivider);
   customElement("communication-action-menu")(CommunicationActionMenu);
   //@ts-ignore
   customElement("poc-events-ecap")(PocEventsEcap);

package/src/UI/components/communication-action-menu/template.ts

@@ -15,9 +15,10 @@ export const template = (props: CommunicationActionMenu) => {
           </dss-tooltip>`
             : nothing
         }
-        <dss-action-menu id="communication-sidenav-region-container" slot="content" >
-        </dss-action-menu>
       </div>
+      <dss-action-menu id="communication-sidenav-region-container" slot="content" >
+      </dss-action-menu>
+      ${props.showText ? html`<dss-icon icon="chevron_right" size="md"></dss-icon>` : nothing}
     </div>
   `;
 };

package/src/UI/components/primaria-shell/shell-header/header-divider/header-divider.ts

@@ -0,0 +1,13 @@
+import { html, LitElement, css, unsafeCSS } from "lit";
+import styles from "./styles.css?inline";
+import { template } from "./template";
+
+export class HeaderDivider extends LitElement {
+  render() {
+    return html`${template(this)}`;
+  }
+
+  static styles = css`
+  ${unsafeCSS(styles)}
+`;
+}

package/src/UI/components/primaria-shell/shell-header/header-divider/styles.css

@@ -0,0 +1,5 @@
+.header-container {
+  width: 1px;
+  height: 40px;
+  background-color: var(--color-neutral-100);
+}

package/src/UI/components/primaria-shell/shell-header/header-divider/template.ts

@@ -0,0 +1,8 @@
+import { html } from "lit";
+import { HeaderDivider } from "./header-divider";
+
+export const template = (props: HeaderDivider) => {
+  return html`
+    <div class="header-container"></div>
+  `;
+};

package/src/UI/components/primaria-shell/shell-header/shell-header.ts

@@ -44,4 +44,31 @@ export class PrimariaShellHeader extends PrimariaRegionHost(LitElement) {
       this.professional = response;
     });
   }
+
+  firstUpdated() {
+    const container = this.renderRoot?.querySelector('#header-region-container');
+    if (!container) return;
+
+    let observer: MutationObserver;
+
+    const updateDividers = () => {
+      observer.disconnect();
+
+      Array.from(container.querySelectorAll('header-divider')).forEach(div => (div as HTMLElement).remove());
+
+      const children = Array.from(container.children).filter(
+        el => (el as HTMLElement).tagName !== 'HEADER-DIVIDER'
+      );
+
+      for (let i = 1; i < children.length; i++) {
+        const divider = document.createElement('header-divider');
+        container.insertBefore(divider, children[i]);
+      }
+
+      observer.observe(container, { childList: true });
+    };
+
+    observer = new MutationObserver(updateDividers);
+    observer.observe(container, { childList: true });
+  }
 }

package/src/UI/components/primaria-shell/shell-header/styles.css

@@ -1,5 +1,5 @@
 :host {
-  z-index: 101;
+  z-index: 205;
 }
 .header {
   display: flex;
@@ -18,7 +18,7 @@
     display: flex;
     flex-direction: row;
     align-items: center;
-    gap: 24px;
+    gap: 16px;
 
     .header-logo {
       align-self: center;
@@ -27,7 +27,7 @@
       display: flex;
       flex-direction: row;
       align-items: center;
-      gap: 24px;
+      gap: 16px;
     }
   }
 
@@ -35,7 +35,7 @@
     display: flex;
     flex-direction: row;
     align-items: center;
-    gap: 24px;
+    gap: 16px;
 
     #header-actions-region-container {
       display: flex;