@uxland/primary-shell 4.1.1 → 4.3.0

package/src/handle-views.ts

@@ -2,6 +2,7 @@ import { shellApi } from "./api/api";
 import { shellRegions } from "./api/region-manager/regions";
 import { clinicalMonitoringId, pocTestEventsId } from "./constants";
 import { shellEvents } from "./events";
+import { ExitShell } from "./features/exit/request";
 import { ClinicalMonitoring } from "./UI/components/clinical-monitoring/clinical-monitoring";
 import { PocEventsEcap } from "./UI/components/poc-events-ecap/poc-events-ecap";
 import { PrimariaNavItem } from "./UI/shared-components/primaria-nav-item/primaria-nav-item";
@@ -257,7 +258,9 @@ const registerUpperNavMenuViews = () => {
       const menuItem = new PrimariaNavItem({
         icon: "add_box",
         label: "Pàgina inici",
-        callbackFn: () => {},
+        callbackFn: () => {
+          shellApi.broker.send(new ExitShell());
+        },
       });
       return Promise.resolve(menuItem);
     },

package/src/internal-plugins/activity-history/activity-history-item/add/add-async-history-items/handler.ts

@@ -4,12 +4,14 @@ import { addBusyHistoryItem, removeBusyHistoryItem } from "../../list/handle-bus
 import { addErrorHistoryItem } from "../../list/handle-error/actions";
 import { addHistoryItemsCommand } from "../add-history-items/request";
 import { InjectAsyncHistoryItemsPayload } from "./request";
+import { validateAddAsyncCommand } from "./validate-add-async-items-command";
 
 export class InjectAsyncHistoryItemsHandler extends BaseHandler {
   async handle(payload: InjectAsyncHistoryItemsPayload) {
     this.store.dispatch(addBusyHistoryItem(payload.entityId));
     try {
       const items = await payload.asyncDataProvider();
+      validateAddAsyncCommand(payload, items);
       this.api.broker.send(addHistoryItemsCommand, {
         entityId: payload.entityId,
         items,

package/src/internal-plugins/activity-history/activity-history-item/add/add-async-history-items/request.ts

@@ -7,7 +7,7 @@ export interface InjectAsyncHistoryItemsPayload {
   componentFactory: (item: IActivityHistoryItem) => HTMLElement;
   searchPredicate?: (searchString: string, item: IActivityHistoryItem) => boolean;
   errorMessage: string;
-  filters?: IActivityHistoryCommonFilterGroup;
+  filters: IActivityHistoryCommonFilterGroup;
 }
 
 export const addAsyncHistoryItemsCommand = "inject_async_history_items_request";

package/src/internal-plugins/activity-history/activity-history-item/add/add-async-history-items/validate-add-async-items-command.ts

@@ -0,0 +1,15 @@
+import { IActivityHistoryItem } from "../../domain/model";
+import { InjectAsyncHistoryItemsPayload } from "./request";
+
+export const validateAddAsyncCommand = (payload: InjectAsyncHistoryItemsPayload, items: IActivityHistoryItem[]) => {
+    if(payload.entityId !== payload.filters.id)
+        throw new Error("entityId and filters.id must be the same");
+    if(!payload.filters.title)
+        throw new Error("filters.title is required");
+    if(!payload.asyncDataProvider)
+        throw new Error("asyncDataProvider is required");
+    if(!payload.componentFactory)
+        throw new Error("componentFactory is required");
+    if(!payload.errorMessage)
+        throw new Error("errorMessage is required for failure asyncDataProviders");
+};

package/src/internal-plugins/activity-history/activity-history-item/add/add-history-items/reducer.ts

@@ -12,11 +12,14 @@ export function addActivityHistoryItemsReducer(
   }>,
 ) {
   const { id, items, componentFactory, searchPredicate } = action.payload;
-  state.collections = addItemsToCollection(
-    state.collections,
-    id,
-    items,
-    componentFactory,
-    searchPredicate,
-  );
+  return {
+    ...state,
+    collections: addItemsToCollection(
+      state.collections,
+      id,
+      items,
+      componentFactory,
+      searchPredicate,
+    ),
+  };
 }

package/src/internal-plugins/activity-history/activity-history-item/domain/model.ts

@@ -29,6 +29,10 @@ export interface IActivityHistoryItem {
   type?: string;
 }
 
+export interface IActivityHistoryItemWithComponent extends IActivityHistoryItem {
+  component: HTMLElement;
+}
+
 export interface IActivityHistoryItemCollection {
   id: string;
   items: IActivityHistoryItem[];

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

@@ -0,0 +1,51 @@
+import { LitElement, css, html, unsafeCSS } from "lit";
+import { customElement } from "lit/decorators.js";
+import { connectedProperty } from "../../../../infrastructure/state/connected-property";
+import { lazyInject } from "../../../../infrastructure/ioc/container";
+import { PrimariaApi } from "../../../../../../api/api";
+import { TYPES } from "../../../../infrastructure/ioc/types";
+import { template } from "./template";
+import styles from "./styles.css?inline";
+import { activeGroupsWithEnabledFilters } from "../../custom-filters/selectors";
+import { SetCustomFilterValue } from "../../custom-filters/set-custom-filter-value/request";
+import { IActivityHistoryCustomFilterGroup, IActivityHistoryFilterGroup } from "../../model";
+import { activityHistoryEnabledCommonFiltersSelector } from "../../common-filters/selectors";
+import { SetCommonFilter } from "../../common-filters/set-common-filter/request";
+
+//@ts-ignore
+@customElement("active-filters-badges")
+export class ActiveFiltersBadges extends LitElement {
+  render() {
+    return html`${template(this)}`;
+  }
+
+  static styles = css`
+    ${unsafeCSS(styles)}
+  `;
+
+  @lazyInject(TYPES.primaryApi)
+  api: PrimariaApi;
+
+  activityHistoryCommonFiltersSelector;
+
+  @connectedProperty(activityHistoryEnabledCommonFiltersSelector)
+  enabledCommonFilters: IActivityHistoryFilterGroup[];
+
+  @connectedProperty(activeGroupsWithEnabledFilters)
+  enabledFilters: IActivityHistoryCustomFilterGroup[];
+
+  _onDeleteFilterValue(filterGroupId: string, filterId: string, optionId: string, value: boolean) {
+    this.api.broker.send(
+      new SetCustomFilterValue({
+        filterGroupId,
+        filterId,
+        optionId,
+        enabled: value,
+      }),
+    );
+  }
+
+  _onDeleteCommonFilterValue(filterId: string) {
+    this.api.broker.send(new SetCommonFilter({ id: filterId, enabled: false }));
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-badges/styles.css

@@ -0,0 +1,31 @@
+.filters-container{
+  display: flex;
+  gap: var(--dss-spacing-md);
+}
+
+.filters-header{
+  font-weight: 700;
+}
+
+.filter-groups{
+  display: flex;
+  gap: var(--dss-spacing-xs);
+}
+
+.filter-group{
+  display: flex;
+  gap: var(--dss-spacing-xs);
+  color: var(--color-neutral-600);
+  font-weight: 600;
+}
+
+.popover-content {
+  box-sizing: border-box;
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--dss-spacing-xs);
+  padding: 10px;
+  max-width: 368px; 
+  max-height: 336px; 
+  overflow: auto;
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-badges/template.ts

@@ -0,0 +1,103 @@
+import { html, nothing } from "lit";
+import { ActiveFiltersBadges } from "./active-filters-badges";
+import { translate } from "../../../../localization";
+import { formatShowFilterTitle, normalizeDeletedFilterBooleanValue } from "../../utils";
+
+const MAX_VISIBLE_CHIPS = 5;
+
+const renderChip = (id, filter, value, props) => html`
+  <dss-chip
+    label=${value}
+    size="sm"
+    hasdelete
+    selected
+    @click=${() => props._onDeleteFilterValue(id, filter.id, value, false)}
+    @onDelete=${() => props._onDeleteFilterValue(id, filter.id, value, false)}
+  ></dss-chip>
+`;
+
+const renderCommonChip = (filter, props) => html`
+  <dss-chip
+    label=${formatShowFilterTitle(filter.title)}
+    size="sm"
+    hasdelete
+    selected
+    @click=${() => props._onDeleteCommonFilterValue(filter.id)}
+    @onDelete=${() => props._onDeleteCommonFilterValue(filter.id)}
+  ></dss-chip>
+`;
+
+const renderFilterTitle = (title) => html`<div class="filter-title">${`${title}:`}</div>`;
+
+export const template = (props: ActiveFiltersBadges) => {
+  if (props.enabledFilters.length === 0 && props.enabledCommonFilters.length === 0) return nothing;
+
+  let visibleCount = 0;
+  const visibleChips: any[] = [];
+  const hiddenElements: any[] = [];
+  const hiddenChips: any[] = [];
+
+  for (const filter of props.enabledCommonFilters) {
+    const chip = renderCommonChip(filter, props);
+
+    if (visibleCount < MAX_VISIBLE_CHIPS) {
+      visibleChips.push(chip);
+      visibleCount++;
+    } else {
+      hiddenElements.push(chip);
+      hiddenChips.push(chip);
+    }
+  }
+
+  for (const { title, id, filters } of props.enabledFilters) {
+    let titleAddedToVisible = false;
+    let titleAddedToHidden = false;
+
+    for (const filter of filters) {
+      for (const value of [...new Set(filter.enabledValues)]) {
+        const chip = renderChip(id, filter, normalizeDeletedFilterBooleanValue(value), props);
+
+        if (visibleCount < MAX_VISIBLE_CHIPS) {
+          if (!titleAddedToVisible) {
+            visibleChips.push(renderFilterTitle(title));
+            titleAddedToVisible = true;
+          }
+          visibleChips.push(chip);
+          visibleCount++;
+        } else {
+          if (!titleAddedToHidden) {
+            hiddenElements.push(renderFilterTitle(title));
+            titleAddedToHidden = true;
+          }
+          hiddenElements.push(chip);
+          hiddenChips.push(chip);
+        }
+      }
+    }
+  }
+
+  return html`
+  <div class="filters-container">
+    <div class="filters-header">${translate("chipHeader.selection")}</div>
+    <div class="filter-groups">
+      ${visibleChips}
+      ${
+        hiddenChips.length > 0
+          ? html`
+            <div>
+              <dss-button label="+ ${hiddenChips.length}" size="sm" variant="primary"></dss-button>
+              <dss-popover title=${translate("chipHeader.selection")} position="bottom" popoverFixed>
+                <dss-popover-body slot="body">
+                  <div class="popover-content">
+                    ${hiddenElements}
+                  </div>
+                </dss-popover-body>
+              </dss-popover>
+            </div>
+          `
+          : nothing
+      }
+    </div>
+  </div>
+  `;
+};

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

@@ -0,0 +1,29 @@
+import { LitElement, css, html, unsafeCSS } from "lit";
+import { template } from "./template";
+import styles from "./styles.css?inline";
+import { customElement } from "lit/decorators.js";
+import { connectedProperty } from "../../../../infrastructure/state/connected-property";
+import { activityHistorySearchStringSelector } from "../../../search/selectors";
+import { areCustomFiltersActive } from "../../custom-filters/selectors";
+import { areCommonFiltersActive } from "../../common-filters/selectors";
+
+//@ts-ignore
+@customElement("active-filters-header")
+export class ActiveFiltersHeader extends LitElement {
+  render() {
+    return html`${template(this)}`;
+  }
+
+  static styles = css`
+    ${unsafeCSS(styles)}
+  `;
+
+  @connectedProperty(activityHistorySearchStringSelector)
+  searchString: string;
+
+  @connectedProperty(areCustomFiltersActive)
+  areCustomFiltersActive: boolean;
+
+  @connectedProperty(areCommonFiltersActive)
+  areCommonFiltersActive: boolean;
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-header/styles.css

@@ -0,0 +1,12 @@
+.active-filters-header{
+  display: flex;
+  flex-direction: column;
+  border-width: 0px 0px 1px 0px;
+  border-style: solid;
+  border-color: #D8D8D8;
+  background-color: #FFFFFF;
+  padding: var(--dss-spacing-sm) var(--dss-spacing-md);
+  gap: var(--dss-spacing-xs);
+  font-size: 14px;
+  line-height: 24px;
+}

package/src/internal-plugins/activity-history/activity-history-item/filter/UI/active-filters-header/template.ts

@@ -0,0 +1,19 @@
+import { html, nothing } from "lit";
+import { ActiveFiltersHeader } from "./active-filters-header";
+import { when } from "lit/directives/when.js";
+
+export const template = (props: ActiveFiltersHeader) => {
+  if (
+    !props.areCustomFiltersActive &&
+    !props.areCommonFiltersActive &&
+    props.searchString.length < 1
+  )
+    return nothing;
+
+  return html`
+    <div class="active-filters-header">
+      <active-filters-badges></active-filters-badges>
+      ${when(props.searchString.length > 1, () => html`<activity-history-search-results searchQuery=${props.searchString}></activity-history-search-results>`)}
+    </div>
+  `;
+};

package/src/internal-plugins/activity-history/activity-history-item/filter/common-filters/selectors.ts

@@ -12,3 +12,13 @@ export const isEnabledCommonFilterSelector = (filterId: string) =>
     activityHistoryCommonFiltersSelector,
     (filterSpecs) => filterSpecs?.find((s) => s.id === filterId)?.enabled,
   );
+
+export const activityHistoryEnabledCommonFiltersSelector = createSelector(
+  activityHistoryCommonFiltersSelector,
+  (filters) => filters.filter((f) => f.enabled),
+);
+
+export const areCommonFiltersActive = createSelector(
+  activityHistoryEnabledCommonFiltersSelector,
+  (filters) => !!filters.length,
+);

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/selectors.ts

@@ -1,5 +1,6 @@
 import { createSelector } from "@reduxjs/toolkit";
 import {
+  IActivityHistoryCustomFilter,
   IActivityHistoryCustomFilterGroup,
   IActivityHistoryFilterGroup,
   isNotCommonFilterGroup,
@@ -18,3 +19,28 @@ const sortBySortProperty = (
   a: IActivityHistoryCustomFilterGroup,
   b: IActivityHistoryCustomFilterGroup,
 ) => Number(a.sort) - Number(b.sort);
+
+export const areCustomFiltersActive = createSelector(
+  activityHistoryCustomFilterGroupsSelector,
+  (filters: IActivityHistoryCustomFilterGroup[]) => {
+    return filters.some((filter) =>
+      filter.filters.some((singleFilter) => singleFilter.enabledValues?.length),
+    );
+  },
+);
+
+export const activeGroupsWithEnabledFilters = createSelector(
+  activityHistoryCustomFilterGroupsSelector,
+  (filters: IActivityHistoryCustomFilterGroup[]) => {
+    return filters
+      .filter((group) => group.enabled)
+      .map(({ id, title, enabled, sort, filters }) => ({
+        id,
+        title,
+        enabled,
+        sort,
+        filters: filters.filter((filter) => filter.enabledValues?.length),
+      }))
+      .filter((group) => group.filters.length > 0);
+  },
+);

package/src/internal-plugins/activity-history/activity-history-item/filter/custom-filters/set-custom-filter-value/reducer.ts

@@ -1,5 +1,6 @@
 import { PayloadAction } from "@reduxjs/toolkit";
 import { SetCustomFilterValuePayload } from "./request";
+import { IActivityHistoryCustomFilter, IActivityHistoryCustomFilterGroup } from "../../model";
 
 export function setCustomFilterValueReducer(
   state,
@@ -22,8 +23,13 @@ export function setCustomFilterValueReducer(
   });
 }
 
-const setMultipleOptionsFilterValue = (filter, payload: SetCustomFilterValuePayload) => {
+const setMultipleOptionsFilterValue = (
+  filter: IActivityHistoryCustomFilter,
+  payload: SetCustomFilterValuePayload,
+) => {
   const { optionId, enabled } = payload;
+  //Si el option ya estaba habilitado, no cambiamos nada
+  if (filter.enabledValues?.some((id) => id === optionId) && enabled) return filter;
   return {
     ...filter,
     enabledValues: enabled

package/src/internal-plugins/activity-history/activity-history-item/filter/utils.ts

@@ -0,0 +1,9 @@
+import { translate } from "../../localization";
+
+export const formatShowFilterTitle = (title: string) => {
+  const filterTitle = title.replace(/veure/gi, "").trim();
+  return filterTitle.charAt(0).toUpperCase() + filterTitle.slice(1);
+};
+
+export const normalizeDeletedFilterBooleanValue = (value) =>
+  value === true ? translate("filters.deleted") : value;

package/src/internal-plugins/activity-history/activity-history-item/list/UI/main-view/template.ts

@@ -33,7 +33,7 @@ export const template = (props: ActivityHistoryMain) =>
         <div class="wrapper" ?maximized=${props.maximized}>
           <activity-history-filters .wrapperMaximized=${props.maximized}></activity-history-filters>
           <div class="content">
-            ${when(props.searchQuery.length > 1, () => html`<activity-history-search-header searchQuery="${props.searchQuery}"></activity-history-search-header>`)}
+            <active-filters-header></active-filters-header>
             <activity-history-busy></activity-history-busy>
             <activity-history-timeline></activity-history-timeline>
           </div>  

package/src/internal-plugins/activity-history/activity-history-item/list/UI/timeline/activity-history-timeline.ts

@@ -40,6 +40,36 @@ export class ActivityHistoryTimeline extends LitElement {
     this._hasUpdatedOnce = true;
   }
 
+  async updated(changedProperties) {
+    if (changedProperties.has("historyGroups") && this.historyGroups?.length) {
+      // Resolver los elementos antes de actualizar el template
+      await this.prepareComponents(this.historyGroups);
+    }
+  }
+
+  async prepareComponents(historyGroups) {
+    for (const group of historyGroups) {
+      // Resolver items del grupo principal
+      group.items = await Promise.all(
+        group.items.map(async (item) => ({
+          ...item,
+          component: await item.componentFactory({ item }),
+        })),
+      );
+
+      // Resolver subgrupos
+      for (const subGroup of group.subGroups) {
+        subGroup.items = await Promise.all(
+          subGroup.items.map(async (item) => ({
+            ...item,
+            component: await item.componentFactory({ item }),
+          })),
+        );
+      }
+    }
+    this.requestUpdate(); // 🔥 Forzar actualización del template
+  }
+
   highlightMatch(text: string, searchString: string): string {
     if (!this.searchString || this.searchString.length < 2) return text;
     const regex = new RegExp(`(${searchString})`, "gi");

package/src/internal-plugins/activity-history/activity-history-item/list/UI/timeline/template.ts

@@ -9,6 +9,7 @@ import { ifDefined } from "lit/directives/if-defined.js";
 import {
   IActivityHistoryGroup,
   IActivityHistoryItem,
+  IActivityHistoryItemWithComponent,
   IActivityHistorySubGroup,
 } from "../../../domain/model";
 import { translate } from "../../../../localization";
@@ -27,8 +28,9 @@ export const template = (props: ActivityHistoryTimeline) => {
             <div class="visit__items">
               ${repeat(
                 itemGroup.items,
-                (item: IActivityHistoryItem) =>
-                  html`<div class="item">${item?.componentFactory(item)}</div> `,
+                (item) => item.id,
+                (item: IActivityHistoryItemWithComponent) =>
+                  html`<div class="item">${item.component}</div> `,
               )}
               ${repeat(
                 itemGroup.subGroups,
@@ -38,8 +40,9 @@ export const template = (props: ActivityHistoryTimeline) => {
                       ${diagnosticHeaderTemplate(subGroup.items[0])}
                       <div class="diagnostics__items">${repeat(
                         subGroup.items,
-                        (item: IActivityHistoryItem) =>
-                          html`<div class="item">${item?.componentFactory(item)}</div>  `,
+                        (item) => item.id,
+                        (item: IActivityHistoryItemWithComponent) =>
+                          html`<div class="item">${item?.component}</div>  `,
                       )}</div>
                     </div>
                 `,

package/src/internal-plugins/activity-history/activity-history-item/list/bootstrapper.ts

@@ -1,4 +1,5 @@
 import "./UI/timeline/activity-history-timeline";
+import "../filter/UI/active-filters-header/active-filters-header";
 
 export const bootstrapListActivityHistoryItems = () => {
   () => null;

package/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-results/styles.css

@@ -1,14 +1,5 @@
 .search-header {
-  padding-inline: 16px;
-  padding-top: 12px;
-  padding-bottom: 12px;
-  gap: var(--dss-spacing-xs);
-  border-width: 0px 0px 1px 0px;
-  border-style: solid;
-  border-color: #D8D8D8;
-  background-color: #FFFFFF;
   color: var(--color-neutral-900);
   font-weight: 600;
-  font-size: 14px;
-  line-height: 24px;
+
 }

package/src/internal-plugins/activity-history/activity-history-item/search/bootstrapper.ts

@@ -4,6 +4,7 @@ import { SearchActivityHistoryItems } from "./request";
 import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
 import "./activity-history-search-results/activity-history-search-results";
 import "./activity-history-search-bar/activity-history-search-bar";
+import "../filter/UI/active-filters-badges/active-filters-badges";
 
 let request: BrokerDisposableHandler;
 

package/src/internal-plugins/activity-history/handle-views.ts

@@ -0,0 +1,17 @@
+import { PrimariaApi } from "../../api/api";
+import { clinicalMonitoringRegions } from "../../api/region-manager/regions";
+import { ActivityHistoryMain } from "./activity-history-item/list/UI/main-view/activity-history-main";
+import { container } from "./infrastructure/ioc/container";
+import { TYPES } from "./infrastructure/ioc/types";
+
+export const registerViews = (api: PrimariaApi) => {
+  api.regionManager.registerView(clinicalMonitoringRegions.content, {
+    id: api.pluginInfo.pluginId,
+    factory: () => Promise.resolve(new ActivityHistoryMain()),
+  });
+};
+
+export const unregisterViews = () => {
+  const api = container.get(TYPES.primaryApi) as PrimariaApi;
+  api.regionManager.removeView(clinicalMonitoringRegions.content, api.pluginInfo.pluginId);
+};

package/src/internal-plugins/activity-history/infrastructure/ioc/container.ts

@@ -12,3 +12,8 @@ export const bindDeps = (api: PrimariaApi) => {
   container.bind(TYPES.primaryApi).toConstantValue(api);
   container.bind(TYPES.store).toConstantValue(store);
 };
+
+export const unbindDeps = () => {
+  container.unbind(TYPES.primaryApi);
+  container.unbind(TYPES.store);
+};

package/src/internal-plugins/activity-history/infrastructure/ioc/types.ts

@@ -1,5 +1,4 @@
 export const TYPES = {
   primaryApi: Symbol.for("primaryApi"),
   store: Symbol.for("store"),
-  localeManager: Symbol.for("localeManager"),
 };

package/src/internal-plugins/activity-history/localization.ts

@@ -1,7 +1,4 @@
 import { PrimariaApi } from "../../api/api";
-import { container } from "./infrastructure/ioc/container";
-import { TYPES } from "./infrastructure/ioc/types";
-import { getLocaleManagerDependency } from "./utils/get-locale-manager-dependency";
 
 type LocaleKeys<T> = T extends object
   ? {
@@ -17,15 +14,15 @@ export type ActivityHistoryLocales = LocaleKeys<
 
 const defaultLang = "ca";
 
+let pluginLocaleManager;
+
 export const initializeLocalization = async (api: PrimariaApi) => {
-  const pluginLocaleManager = await api.createLocaleManager(locales);
-  container.bind(TYPES.localeManager).toConstantValue(pluginLocaleManager);
+  pluginLocaleManager = await api.createLocaleManager(locales);
 };
 
 export const translate = (path: ActivityHistoryLocales) => {
-  const localeManager = getLocaleManagerDependency();
-  if (localeManager) return (localeManager as any).translate(path);
-  else return path;
+  if (pluginLocaleManager) return (pluginLocaleManager as any).translate(path);
+  return path;
 };
 
 export const locales = {
@@ -54,14 +51,15 @@ export const locales = {
         allActivityHistory: "Tot l’històric d’activitat",
         onlyAppliedFilters: "Només amb filtres aplicats",
         selectDateRange: "En el cas que sigui necessari, selecciona un rang de dates",
-        helpText: "Sense seleccionar data, s'aplicarà la de la primera entrada. Sense seleccionar data de fi, s'aplicarà la de l'última entrada.",
+        helpText:
+          "Sense seleccionar data, s'aplicarà la de la primera entrada. Sense seleccionar data de fi, s'aplicarà la de l'última entrada.",
         startDate: "Data Inici",
         endDate: "Data Fi",
         cancel: "Cancel·lar",
         export: "Exportar",
       },
       filters: {
-        filters: "Filtres",  
+        filters: "Filtres",
         searchFilter: "Cercar filtre",
         ownFilters: "Els meus",
         rellevantFilters: "Rellevants",
@@ -73,6 +71,8 @@ export const locales = {
 
         selected: "seleccionats",
         applyFilters: "Aplicar filtres",
+
+        deleted: "Eliminats",
       },
       tooltips: {
         subjective: "Subjectiu",
@@ -84,6 +84,9 @@ export const locales = {
         variablees: "Variables",
         prescriptions: "Prescripcions",
       },
+      chipHeader: {
+        selection: "Selecció:",
+      },
     },
   },
 };