@provoly/dashboard 0.15.7 → 0.15.9

package/esm2022/widgets/widget-map/utils/widget-map.utils.mjs

@@ -180,10 +180,45 @@ export const geometryForLayer = (layer) => {
             return FieldType.POINT;
     }
 };
+export const getLayerOrder = (layer, index, array) => {
+    if (layer.order && array[index - 1] && array[index - 1].order && layer.order < array[index - 1].order)
+        return array[index - 1].order + 1;
+    if (layer.order)
+        return layer.order;
+    if (index === 0 && !layer.order)
+        return 0;
+    let [distanceToFirstPreviousOrder, distanceToFirstNextOrder] = [
+        array
+            .slice(0, index + 1)
+            .reverse()
+            .findIndex((element) => !!element.order),
+        array.slice(index + 1).findIndex((element) => !!element.order)
+    ];
+    let [previousOrderIndex, nextOrderIndex] = [
+        distanceToFirstPreviousOrder > -1 ? index - distanceToFirstPreviousOrder : 0,
+        distanceToFirstNextOrder + index + 1
+    ];
+    let [previousOrder, nextOrder] = [
+        distanceToFirstPreviousOrder > -1 ? array[previousOrderIndex].order : 0,
+        distanceToFirstNextOrder > -1 ? array[nextOrderIndex].order : -1
+    ];
+    if (nextOrder > 0 && nextOrder < previousOrder) {
+        const newOrder = previousOrder + (nextOrderIndex - previousOrderIndex);
+        console.warn(`the order property of layer no ${index + 2} was preset but doesn't follow the order of the other layers`);
+        nextOrder = newOrder;
+    }
+    if (nextOrder > 0) {
+        let relativeIndex = index - previousOrderIndex;
+        return previousOrder + ((nextOrder - previousOrder) / (nextOrderIndex - previousOrderIndex)) * relativeIndex;
+    }
+    else {
+        return previousOrder + distanceToFirstPreviousOrder;
+    }
+};
 export const DEFAULT_HEATMAP_RADIUS = 25;
 export const DEFAULT_RADIUS_INTENSITY_FACTOR = 10000;
 export const DEFAULT_ZOOM_MIN = 3;
 export const DEFAULT_ZOOM_START = 10;
 export const DEFAULT_ZOOM_MAX = 18;
 export const DEFAULT_MAP_CENTER = [2.2827217347381525, 48.864706031557716];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-map.utils.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/widgets/widget-map/utils/widget-map.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Attribute,\n  Class,\n  Field,\n  FieldType,\n  Item,\n  ItemUtils,\n  MapWidgetBubbleLayerOptions,\n  MapWidgetHeatMapLayerOptions,\n  MapWidgetLayerOptions,\n  MapWidgetMarkerLayerOptions,\n  Relation,\n  ResultSet\n} from '@provoly/dashboard';\nimport { Feature, Map } from 'ol';\nimport { Circle, LineString, Point } from 'ol/geom';\nimport { Style } from 'ol/style';\nimport { WidgetMapLayerService } from '../component/widget-map-layer.service';\n\nexport type LatLonCandidate = {\n  min: number;\n  max: number;\n  name: string;\n  type: string;\n};\n\nexport const populateLocationAttribute = (\n  layer: MapWidgetLayerOptions,\n  resultSet: ResultSet,\n  classesNotFiltered: Class[],\n  fields: Field[]\n) => {\n  if (\n    ['heatmap', 'marker', 'bubble', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon', 'auto'].includes(\n      layer.type\n    ) &&\n    !!resultSet &&\n    !!classesNotFiltered &&\n    classesNotFiltered.length > 0\n  ) {\n    const specificLayer = layer as\n      | MapWidgetHeatMapLayerOptions\n      | MapWidgetMarkerLayerOptions\n      | MapWidgetBubbleLayerOptions;\n\n    const classes = classesNotFiltered.filter(\n      (cl) => specificLayer.classes?.includes(cl.id) || !specificLayer.classes || specificLayer.classes.length === 0\n    );\n\n    if (!specificLayer.attribute) {\n      // No location attribute available, then try to guess one that will be ok\n\n      const geometry = geometryForLayer(layer);\n\n      let candidates = [] as { attr: Attribute; field: Field | undefined }[];\n      if (Object.keys(resultSet.items).length > 0) {\n        // Based on items that we have to display\n\n        candidates = Object.keys(resultSet.items)\n          .map((key) => ({ items: resultSet.items[key], oClass: classes.find((cl) => cl.id === key) }))\n          .map(({ items, oClass }) =>\n            (oClass ?? { attributes: [] }).attributes\n              .map((attr) => ({ attr, field: fields.find((f) => f.id === attr.field) }))\n              .filter((attr) => attr.field?.type === geometry)\n          )\n          .reduce((p, c) => [...p, ...c], []);\n      } else {\n        // We don't have any items to display, so allow all corresponding geometry fields\n        candidates = classesNotFiltered\n          .map((clazz) => clazz.attributes)\n          .flat()\n          .map((attr) => ({ attr, field: fields.find((field) => field.id === attr.field) }))\n          .filter(({ attr, field }) => field?.type === geometry);\n      }\n\n      if (candidates.length > 0) {\n        specificLayer.attribute = candidates[0].attr.name;\n      }\n    }\n  }\n};\n\nexport const populateIntensityAttribute = (\n  layer: MapWidgetLayerOptions,\n  resultSet: ResultSet,\n  classesNotFiltered: Class[],\n  fields: Field[]\n) => {\n  if (\n    ['heatmap', 'bubble'].includes(layer.type) &&\n    !!resultSet &&\n    !!classesNotFiltered &&\n    classesNotFiltered.length > 0\n  ) {\n    const specificLayer = layer as MapWidgetHeatMapLayerOptions | MapWidgetBubbleLayerOptions;\n\n    const classes = classesNotFiltered.filter(\n      (cl) =>\n        (specificLayer.classes?.includes(cl.id) || !specificLayer.classes || specificLayer.classes.length === 0) &&\n        cl.attributes.find((attr) => attr.name === (specificLayer?.attribute ?? []))\n    );\n\n    if (!specificLayer.intensityAttribute) {\n      // No intensity attribute available, then take the maximum intensity matching attribute\n      const candidatesDry = Object.keys(resultSet.items)\n        .map((key) => ({ items: resultSet.items[key], oClass: classes.find((cl) => cl.id === key) }))\n        .map(({ items, oClass }) => {\n          return (oClass ?? { attributes: [] }).attributes\n            .map((attr) => ({ attr, field: fields.find((f) => f.id === attr.field) }))\n            .filter((attr) => attr.field?.type === FieldType.DECIMAL || attr.field?.type === FieldType.INTEGER)\n            .map((attr) => {\n              const attrValues = ItemUtils.pertinentValue(items, attr.attr);\n              return {\n                min: Math.min(...attrValues),\n                max: Math.max(...attrValues),\n                name: attr.attr.name\n              };\n            });\n        })\n        .reduce((p, c) => [...p, ...c], [])\n        .sort((a, b) => b.max - a.max);\n\n      if (candidatesDry.length > 0) {\n        specificLayer.intensityAttribute = candidatesDry[0].name;\n        specificLayer.intensityAsc = true;\n      }\n    }\n  }\n};\n\nexport const getFeatureFromItem = (\n  item: Item,\n  type: string,\n  locationAttribute: Attribute,\n  iconStyle?: Style,\n  selectedIconStyle?: Style\n) => {\n  return new Feature({\n    ...item,\n    type,\n    geometry: ItemUtils.readGeometry(item, 'point', locationAttribute),\n    classicStyle: iconStyle ?? null,\n    selectedStyle: selectedIconStyle ?? null\n  });\n};\n\nexport const getCircleFeatureFromItem = (\n  item: Item,\n  locationAttribute: Attribute,\n  radius: number,\n  iconStyle: Style,\n  selectedIconStyle: Style\n) => {\n  return new Feature({\n    ...item,\n    geometry: new Circle((ItemUtils.readGeometry(item, 'point', locationAttribute) as Point).getCoordinates(), radius),\n    classicStyle: iconStyle,\n    selectedStyle: selectedIconStyle,\n    type: 'bubble'\n  });\n};\n\nexport const getLinkFeature = (\n  relation: Relation,\n  featureSource: Feature<Point>,\n  featureDestination: Feature<Point>\n) => {\n  return new Feature({\n    ...relation,\n    geometry: new LineString([\n      // @ts-ignore\n      featureSource.getGeometry()?.getCoordinates() ?? featureSource.getGeometry()?.getCenter() ?? [0, 0],\n      // @ts-ignore\n      featureDestination.getGeometry()?.getCoordinates() ?? featureDestination.getGeometry()?.getCenter() ?? [0, 0]\n    ]),\n    source: featureSource,\n    destination: featureDestination,\n    type: 'link'\n  });\n};\n\nexport const getMapAsPng = (map: Map) => {\n  return new Promise<string>((resolve, reject) => {\n    map.once('rendercomplete', function () {\n      const mapCanvas = document.createElement('canvas');\n      const size = map.getSize() || [100, 100];\n      mapCanvas.width = size[0];\n      mapCanvas.height = size[1];\n      const mapContext = mapCanvas.getContext('2d') || (null as unknown as CanvasRenderingContext2D);\n      Array.prototype.forEach.call(document.querySelectorAll('.ol-layer canvas, canvas.ol-layer'), (canvas) => {\n        if (canvas.width > 0) {\n          const opacity = canvas.parentNode.style.opacity || canvas.style.opacity;\n          mapContext.globalAlpha = opacity === '' ? 1 : Number(opacity);\n\n          const backgroundColor = canvas.parentNode.style.backgroundColor;\n          if (backgroundColor) {\n            mapContext.fillStyle = backgroundColor;\n            mapContext.fillRect(0, 0, canvas.width, canvas.height);\n          }\n\n          let matrix;\n          const transform = canvas.style.transform;\n          if (transform) {\n            // Get the transform parameters from the style's transform matrix\n            matrix = transform\n              .match(/^matrix\\(([^(]*)\\)$/)[1]\n              .split(',')\n              .map(Number);\n          } else {\n            matrix = [\n              parseFloat(canvas.style.width) / canvas.width,\n              0,\n              0,\n              parseFloat(canvas.style.height) / canvas.height,\n              0,\n              0\n            ];\n          }\n          // Apply the transform to the export map context\n          CanvasRenderingContext2D.prototype.setTransform.apply(mapContext, matrix);\n          mapContext.drawImage(canvas, 0, 0);\n        }\n      });\n      mapContext.globalAlpha = 1;\n      resolve(mapCanvas.toDataURL('image/png'));\n    });\n    map.renderSync();\n  });\n};\n\nexport const exportMapAsImage = (map: Map, filename: string) => {\n  getMapAsPng(map).then((data) => {\n    const link = document.createElement('a');\n    link.download = filename;\n    link.href = data;\n    link.click();\n  });\n};\n\nexport const geometryForLayer = (layer: MapWidgetLayerOptions): string => {\n  switch (layer.type) {\n    case 'marker':\n    case 'heatmap':\n    case 'bubble':\n    case 'point':\n      return FieldType.POINT;\n    case 'line':\n      return FieldType.LINE;\n    case 'polygon':\n      return FieldType.POLYGON;\n    case 'multi-line':\n      return FieldType.MULTILINE;\n    case 'multi-polygon':\n      return FieldType.MULTIPOLYGON;\n    case 'auto':\n      return geometryForLayer({\n        type: WidgetMapLayerService.translateFieldTypeToLayerType(layer.subType)\n      } as MapWidgetLayerOptions);\n    default:\n      return FieldType.POINT;\n  }\n};\n\nexport const DEFAULT_HEATMAP_RADIUS = 25;\nexport const DEFAULT_RADIUS_INTENSITY_FACTOR = 10000;\nexport const DEFAULT_ZOOM_MIN = 3;\nexport const DEFAULT_ZOOM_START = 10;\nexport const DEFAULT_ZOOM_MAX = 18;\nexport const DEFAULT_MAP_CENTER = [2.2827217347381525, 48.864706031557716];\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-map.utils.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/widgets/widget-map/utils/widget-map.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Attribute,\n  Class,\n  Field,\n  FieldType,\n  Item,\n  ItemUtils,\n  MapWidgetBubbleLayerOptions,\n  MapWidgetHeatMapLayerOptions,\n  MapWidgetLayerOptions,\n  MapWidgetMarkerLayerOptions,\n  Relation,\n  ResultSet\n} from '@provoly/dashboard';\nimport { Feature, Map } from 'ol';\nimport { Circle, LineString, Point } from 'ol/geom';\nimport { Style } from 'ol/style';\nimport { WidgetMapLayerService } from '../component/widget-map-layer.service';\n\nexport type LatLonCandidate = {\n  min: number;\n  max: number;\n  name: string;\n  type: string;\n};\n\nexport const populateLocationAttribute = (\n  layer: MapWidgetLayerOptions,\n  resultSet: ResultSet,\n  classesNotFiltered: Class[],\n  fields: Field[]\n) => {\n  if (\n    ['heatmap', 'marker', 'bubble', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon', 'auto'].includes(\n      layer.type\n    ) &&\n    !!resultSet &&\n    !!classesNotFiltered &&\n    classesNotFiltered.length > 0\n  ) {\n    const specificLayer = layer as\n      | MapWidgetHeatMapLayerOptions\n      | MapWidgetMarkerLayerOptions\n      | MapWidgetBubbleLayerOptions;\n\n    const classes = classesNotFiltered.filter(\n      (cl) => specificLayer.classes?.includes(cl.id) || !specificLayer.classes || specificLayer.classes.length === 0\n    );\n\n    if (!specificLayer.attribute) {\n      // No location attribute available, then try to guess one that will be ok\n\n      const geometry = geometryForLayer(layer);\n\n      let candidates = [] as { attr: Attribute; field: Field | undefined }[];\n      if (Object.keys(resultSet.items).length > 0) {\n        // Based on items that we have to display\n\n        candidates = Object.keys(resultSet.items)\n          .map((key) => ({ items: resultSet.items[key], oClass: classes.find((cl) => cl.id === key) }))\n          .map(({ items, oClass }) =>\n            (oClass ?? { attributes: [] }).attributes\n              .map((attr) => ({ attr, field: fields.find((f) => f.id === attr.field) }))\n              .filter((attr) => attr.field?.type === geometry)\n          )\n          .reduce((p, c) => [...p, ...c], []);\n      } else {\n        // We don't have any items to display, so allow all corresponding geometry fields\n        candidates = classesNotFiltered\n          .map((clazz) => clazz.attributes)\n          .flat()\n          .map((attr) => ({ attr, field: fields.find((field) => field.id === attr.field) }))\n          .filter(({ attr, field }) => field?.type === geometry);\n      }\n\n      if (candidates.length > 0) {\n        specificLayer.attribute = candidates[0].attr.name;\n      }\n    }\n  }\n};\n\nexport const populateIntensityAttribute = (\n  layer: MapWidgetLayerOptions,\n  resultSet: ResultSet,\n  classesNotFiltered: Class[],\n  fields: Field[]\n) => {\n  if (\n    ['heatmap', 'bubble'].includes(layer.type) &&\n    !!resultSet &&\n    !!classesNotFiltered &&\n    classesNotFiltered.length > 0\n  ) {\n    const specificLayer = layer as MapWidgetHeatMapLayerOptions | MapWidgetBubbleLayerOptions;\n\n    const classes = classesNotFiltered.filter(\n      (cl) =>\n        (specificLayer.classes?.includes(cl.id) || !specificLayer.classes || specificLayer.classes.length === 0) &&\n        cl.attributes.find((attr) => attr.name === (specificLayer?.attribute ?? []))\n    );\n\n    if (!specificLayer.intensityAttribute) {\n      // No intensity attribute available, then take the maximum intensity matching attribute\n      const candidatesDry = Object.keys(resultSet.items)\n        .map((key) => ({ items: resultSet.items[key], oClass: classes.find((cl) => cl.id === key) }))\n        .map(({ items, oClass }) => {\n          return (oClass ?? { attributes: [] }).attributes\n            .map((attr) => ({ attr, field: fields.find((f) => f.id === attr.field) }))\n            .filter((attr) => attr.field?.type === FieldType.DECIMAL || attr.field?.type === FieldType.INTEGER)\n            .map((attr) => {\n              const attrValues = ItemUtils.pertinentValue(items, attr.attr);\n              return {\n                min: Math.min(...attrValues),\n                max: Math.max(...attrValues),\n                name: attr.attr.name\n              };\n            });\n        })\n        .reduce((p, c) => [...p, ...c], [])\n        .sort((a, b) => b.max - a.max);\n\n      if (candidatesDry.length > 0) {\n        specificLayer.intensityAttribute = candidatesDry[0].name;\n        specificLayer.intensityAsc = true;\n      }\n    }\n  }\n};\n\nexport const getFeatureFromItem = (\n  item: Item,\n  type: string,\n  locationAttribute: Attribute,\n  iconStyle?: Style,\n  selectedIconStyle?: Style\n) => {\n  return new Feature({\n    ...item,\n    type,\n    geometry: ItemUtils.readGeometry(item, 'point', locationAttribute),\n    classicStyle: iconStyle ?? null,\n    selectedStyle: selectedIconStyle ?? null\n  });\n};\n\nexport const getCircleFeatureFromItem = (\n  item: Item,\n  locationAttribute: Attribute,\n  radius: number,\n  iconStyle: Style,\n  selectedIconStyle: Style\n) => {\n  return new Feature({\n    ...item,\n    geometry: new Circle((ItemUtils.readGeometry(item, 'point', locationAttribute) as Point).getCoordinates(), radius),\n    classicStyle: iconStyle,\n    selectedStyle: selectedIconStyle,\n    type: 'bubble'\n  });\n};\n\nexport const getLinkFeature = (\n  relation: Relation,\n  featureSource: Feature<Point>,\n  featureDestination: Feature<Point>\n) => {\n  return new Feature({\n    ...relation,\n    geometry: new LineString([\n      // @ts-ignore\n      featureSource.getGeometry()?.getCoordinates() ?? featureSource.getGeometry()?.getCenter() ?? [0, 0],\n      // @ts-ignore\n      featureDestination.getGeometry()?.getCoordinates() ?? featureDestination.getGeometry()?.getCenter() ?? [0, 0]\n    ]),\n    source: featureSource,\n    destination: featureDestination,\n    type: 'link'\n  });\n};\n\nexport const getMapAsPng = (map: Map) => {\n  return new Promise<string>((resolve, reject) => {\n    map.once('rendercomplete', function () {\n      const mapCanvas = document.createElement('canvas');\n      const size = map.getSize() || [100, 100];\n      mapCanvas.width = size[0];\n      mapCanvas.height = size[1];\n      const mapContext = mapCanvas.getContext('2d') || (null as unknown as CanvasRenderingContext2D);\n      Array.prototype.forEach.call(document.querySelectorAll('.ol-layer canvas, canvas.ol-layer'), (canvas) => {\n        if (canvas.width > 0) {\n          const opacity = canvas.parentNode.style.opacity || canvas.style.opacity;\n          mapContext.globalAlpha = opacity === '' ? 1 : Number(opacity);\n\n          const backgroundColor = canvas.parentNode.style.backgroundColor;\n          if (backgroundColor) {\n            mapContext.fillStyle = backgroundColor;\n            mapContext.fillRect(0, 0, canvas.width, canvas.height);\n          }\n\n          let matrix;\n          const transform = canvas.style.transform;\n          if (transform) {\n            // Get the transform parameters from the style's transform matrix\n            matrix = transform\n              .match(/^matrix\\(([^(]*)\\)$/)[1]\n              .split(',')\n              .map(Number);\n          } else {\n            matrix = [\n              parseFloat(canvas.style.width) / canvas.width,\n              0,\n              0,\n              parseFloat(canvas.style.height) / canvas.height,\n              0,\n              0\n            ];\n          }\n          // Apply the transform to the export map context\n          CanvasRenderingContext2D.prototype.setTransform.apply(mapContext, matrix);\n          mapContext.drawImage(canvas, 0, 0);\n        }\n      });\n      mapContext.globalAlpha = 1;\n      resolve(mapCanvas.toDataURL('image/png'));\n    });\n    map.renderSync();\n  });\n};\n\nexport const exportMapAsImage = (map: Map, filename: string) => {\n  getMapAsPng(map).then((data) => {\n    const link = document.createElement('a');\n    link.download = filename;\n    link.href = data;\n    link.click();\n  });\n};\n\nexport const geometryForLayer = (layer: MapWidgetLayerOptions): string => {\n  switch (layer.type) {\n    case 'marker':\n    case 'heatmap':\n    case 'bubble':\n    case 'point':\n      return FieldType.POINT;\n    case 'line':\n      return FieldType.LINE;\n    case 'polygon':\n      return FieldType.POLYGON;\n    case 'multi-line':\n      return FieldType.MULTILINE;\n    case 'multi-polygon':\n      return FieldType.MULTIPOLYGON;\n    case 'auto':\n      return geometryForLayer({\n        type: WidgetMapLayerService.translateFieldTypeToLayerType(layer.subType)\n      } as MapWidgetLayerOptions);\n    default:\n      return FieldType.POINT;\n  }\n};\n\nexport const getLayerOrder = (layer: MapWidgetLayerOptions, index: number, array: MapWidgetLayerOptions[]): number => {\n  if (layer.order && array[index - 1] && array[index - 1].order && layer.order < array[index - 1].order!)\n    return array[index - 1].order! + 1;\n  if (layer.order) return layer.order;\n  if (index === 0 && !layer.order) return 0;\n\n  let [distanceToFirstPreviousOrder, distanceToFirstNextOrder] = [\n    array\n      .slice(0, index + 1)\n      .reverse()\n      .findIndex((element) => !!element.order),\n    array.slice(index + 1).findIndex((element) => !!element.order)\n  ];\n\n  let [previousOrderIndex, nextOrderIndex] = [\n    distanceToFirstPreviousOrder > -1 ? index - distanceToFirstPreviousOrder : 0,\n    distanceToFirstNextOrder + index + 1\n  ];\n  let [previousOrder, nextOrder] = [\n    distanceToFirstPreviousOrder > -1 ? array[previousOrderIndex].order! : 0,\n    distanceToFirstNextOrder > -1 ? array[nextOrderIndex].order! : -1\n  ];\n\n  if (nextOrder > 0 && nextOrder < previousOrder) {\n    const newOrder = previousOrder + (nextOrderIndex - previousOrderIndex);\n    console.warn(\n      `the order property of layer no ${index + 2} was preset but doesn't follow the order of the other layers`\n    );\n    nextOrder = newOrder;\n  }\n\n  if (nextOrder > 0) {\n    let relativeIndex = index - previousOrderIndex;\n    return previousOrder + ((nextOrder - previousOrder) / (nextOrderIndex - previousOrderIndex)) * relativeIndex;\n  } else {\n    return previousOrder + distanceToFirstPreviousOrder;\n  }\n};\n\nexport const DEFAULT_HEATMAP_RADIUS = 25;\nexport const DEFAULT_RADIUS_INTENSITY_FACTOR = 10000;\nexport const DEFAULT_ZOOM_MIN = 3;\nexport const DEFAULT_ZOOM_START = 10;\nexport const DEFAULT_ZOOM_MAX = 18;\nexport const DEFAULT_MAP_CENTER = [2.2827217347381525, 48.864706031557716];\n"]}

package/esm2022/widgets/widget-table/component/widget-table.component.mjs

@@ -2,7 +2,7 @@ import { Component } from '@angular/core';
 import { baseItemProperties, ClassActions, ClassSelectors, ConfigSelectors, ContextMenuActions, ContextMenuSelectors, DashboardActions, DashboardSelectors, DataWidgetComponent, FieldSelectors, FieldType, ItemUtils, SearchSelectors, WIDGET_HEADER_HEIGHT } from '@provoly/dashboard';
 import equal from 'fast-deep-equal/es6';
 import { auditTime, BehaviorSubject, combineLatest, take } from 'rxjs';
-import { filter, map, tap, withLatestFrom } from 'rxjs/operators';
+import { delay, filter, map, tap, withLatestFrom } from 'rxjs/operators';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngrx/store";
 import * as i2 from "@angular/common";
@@ -28,6 +28,7 @@ export class WidgetTableComponent extends DataWidgetComponent {
         this.contextMenuClickedId = '';
         this._refresh$ = new BehaviorSubject(undefined);
         this.actualPage$ = new BehaviorSubject(0);
+        this.isOpen = false;
         this.classes$ = this.store.select(ClassSelectors.classes);
         this.fields$ = combineLatest([this.resultSet$, this.classes$, this.store.select(FieldSelectors.fields)]).pipe(map(([resultSet, classes, fields]) => [
             ...ItemUtils.getFieldsFromAvailabilityInResultSet(resultSet, classes, fields),
@@ -90,7 +91,7 @@ export class WidgetTableComponent extends DataWidgetComponent {
                 loadedPages
             };
         }));
-        this.subscriptions.add(this.pagination$.subscribe(() => this.refresh()));
+        this.subscriptions.add(this.pagination$.pipe(auditTime(200)).subscribe(() => this.refresh()));
         this.columns$ = this.options$.pipe(map((options) => options?.columns ?? []), tap(() => setTimeout(() => this.refresh(), 500)));
         this.isContextMenuOpened$ = this.store.select(ContextMenuSelectors.opened);
         this.subscriptions.add(this.resultSet$
@@ -118,10 +119,11 @@ export class WidgetTableComponent extends DataWidgetComponent {
             return !allIds.find((id) => !selectedIds.includes(id));
         }), tap((allSelected) => (this.areAllSelected = allSelected)));
         this.quickOrder$ = combineLatest([this.store.select(DashboardSelectors.quickOrder), this.datasourceIds$]).pipe(map(([order, nqs]) => (nqs.length === 1 ? order[nqs[0]] : undefined)));
-        this.subscriptions.add(this._refresh$.pipe(auditTime(200)).subscribe(() => this.cdr.detectChanges()));
+        this.subscriptions.add(this._refresh$.pipe(delay(100)).subscribe(() => this.cdr.detectChanges()));
     }
     refresh() {
         this._refresh$.next();
+        this.isOpen = !this.isOpen;
     }
     emitManifest() {
         this.manifestModified.emit({
@@ -212,10 +214,10 @@ export class WidgetTableComponent extends DataWidgetComponent {
         this.actualPage$.next(number);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetTableComponent, deps: [{ token: i1.Store }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: WidgetTableComponent, selector: "pry-widget-table", usesInheritance: true, ngImport: i0, template: "<pry-widget-table-css></pry-widget-table-css>\n<div class=\"o-widget o-widget--table\">\n  <pry-widget-header\n    [datasourceIds]=\"(datasourceIds$ | async) ?? []\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    #header\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n  >\n    <pry-settings\n      (saveTriggered)=\"emitManifest()\"\n      (changeTitle)=\"changeWidgetTitle($event)\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      class=\"o-settings\"\n    >\n      <div class=\"o-settings__popup__content__actions\">\n        <button type=\"button\" class=\"a-btn a-btn--icon-text -link-like\" (click)=\"addColumn()\">\n          <pry-icon iconSvg=\"post_add\"></pry-icon>\n          {{ '@pry.widget.table.addColumn' | i18n }}\n        </button>\n      </div>\n\n      <div\n        *ngFor=\"let columnDef of optionsCopy?.columns ?? []; let i = index\"\n        class=\"o-settings__popup__content__fields\"\n      >\n        <div class=\"o-settings__popup__content__fields__head\">\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.columns?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_property\">{{ '@pry.widget.table.property' | i18n }}</label>\n            <pry-select\n              (ngModelChange)=\"changePropertyName($event, columnDef)\"\n              [itemsAsOption]=\"true\"\n              [items]=\"properties$ | async\"\n              [ngModel]=\"columnDef.property\"\n              bindLabel=\"label\"\n              bindValue=\"property\"\n              id=\"table_property\"\n              class=\"a-pry-select\"\n            ></pry-select>\n          </div>\n\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_label\">{{ '@pry.widget.table.label' | i18n }}</label>\n            <input\n              id=\"table_label\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeLabel($event, columnDef)\"\n              [value]=\"columnDef.label\"\n            />\n          </div>\n        </div>\n        <button\n          (click)=\"deleteColumn(i)\"\n          aria-label=\"delete\"\n          type=\"button\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.table.deleteColumn' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"a-table-wrapper\">\n    <div class=\"a-table-loading\" *ngIf=\"isLoading$ | async; else noLoading\">\n      <span class=\"a-table-loading__loader\"></span>\n    </div>\n    <ng-template #noLoading>\n      <ng-container *ngIf=\"pagination$ | async as pagination\">\n        <ng-container *ngIf=\"pagination?.items ?? [] as allObjects\">\n          <div\n            class=\"no-result\"\n            *ngIf=\"pagination.noFillersItems === 0\"\n            [style.height.%]=\"pagination.totalPages > 0 ? 80 : 100\"\n          >\n            <img\n              class=\"no-result__search\"\n              src=\"../../../assets/svgs/pry_recherche_pas_de_resultat.svg\"\n              alt=\"{{ '@pry.widget.table.empty' | i18n }}\"\n              aria-hidden=\"true\"\n            />\n            <span class=\"no-result__text\">{{ '@pry.widget.table.empty' | i18n }}</span>\n          </div>\n\n          <ng-container *ngIf=\"pagination.noFillersItems > 0\">\n            <ng-container *ngIf=\"(selectedIds$ | async) ?? [] as selectedIds\">\n              <ng-container *ngIf=\"(columns$ | async) ?? [] as columns\">\n                <table class=\"a-table\" [attr.aria-label]=\"'@pry.widget.table.description' | i18n\">\n                  <thead>\n                    <tr>\n                      <th *ngIf=\"allObjects?.length ?? 0 > 0\">\n                        <pry-checkbox [ngModel]=\"areAllSelected\" (ngModelChange)=\"selectAll($event)\"></pry-checkbox>\n                      </th>\n                      <th *ngFor=\"let column of columns; let i = index\" resizable (click)=\"setOrder(column)\">\n                        <span>{{ column.label }}</span>\n                        <ng-container *ngIf=\"quickOrder$ | async as quickOrder\">\n                          <ng-container *ngIf=\"quickOrder.attribute === column.attributeId\">\n                            <pry-icon\n                              [iconSvg]=\"quickOrder.asc ? 'chevron_top' : 'chevron_bottom'\"\n                              [height]=\"12\"\n                              [width]=\"12\"\n                            ></pry-icon>\n                          </ng-container>\n                        </ng-container>\n                      </th>\n                    </tr>\n                  </thead>\n                  <tbody>\n                    <tr\n                      *ngFor=\"let item of allObjects\"\n                      [class.is-selected]=\"selectedIds.includes(item.id)\"\n                      [class.context-menu-selected]=\"contextMenuClickedId === item.id && (isContextMenuOpened$ | async)\"\n                      (contextmenu)=\"contextMenu($event, item)\"\n                      detachRow\n                      (selectedValue)=\"selection($event, item)\"\n                      [class.filler]=\"item.metadata!['__widget-table-filler']\"\n                    >\n                      <td class=\"checkbox-wrapper\">\n                        <pry-checkbox [ngModel]=\"selectedIds.includes(item.id)\"></pry-checkbox>\n                      </td>\n                      <td *ngFor=\"let column of columns\" class=\"u-ellipsis\">\n                        <ng-container *ngIf=\"column.property === 'metadata'\">\n                          <pry-metadata [item]=\"item\"></pry-metadata>\n                        </ng-container>\n                        <ng-container *ngIf=\"column.property === 'oClass'\">\n                          <p class=\"content-img\">\n                            <img\n                              [height]=\"25\"\n                              [width]=\"25\"\n                              [src]=\"item | translateItemToSymbol | async\"\n                              [alt]=\"item.oClass | translateId : { type: 'class', output: 'name' } | async\"\n                            />\n                          </p>\n                        </ng-container>\n                        <ng-container *ngIf=\"!['metadata', 'oClass'].includes(column.property)\">\n                          <pry-expand-value [value]=\"item | getValue : column.property | async\"></pry-expand-value>\n                        </ng-container>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </ng-container>\n            </ng-container>\n          </ng-container>\n\n          <div class=\"a-table-pagination\" *ngIf=\"pagination.totalPages > 0\">\n            <div class=\"a-table-pagination__spacing\">\n              <div>\n                <button (click)=\"goToPage(0)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"skip-left-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button (click)=\"goToPage(pagination.page - 1)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"arrow-left-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                <p>{{ pagination.page + 1 }} / {{ pagination.loadedPages }}</p>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.page + 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"arrow-right-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.loadedPages - 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"skip-right-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                ({{\n                  '@pry.widget.table.remaining' | i18n : { remaining: pagination.totalPages - pagination.loadedPages }\n                }})\n              </div>\n            </div>\n          </div>\n        </ng-container>\n      </ng-container>\n    </ng-template>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.SettingsComponent, selector: "pry-settings", inputs: ["widgetIndex", "isDisable", "headerPresent", "open$", "header"], outputs: ["saveTriggered", "changeTitle"] }, { kind: "component", type: i4.MetadataComponent, selector: "pry-metadata", inputs: ["item"] }, { kind: "component", type: i4.PryWidgetHeaderComponent, selector: "pry-widget-header", inputs: ["manifest", "openData$", "additionalOptions", "headerOptions", "displayCount", "datasourceIds", "widgetIndex"], outputs: ["manifestModified"] }, { kind: "component", type: i4.PrySelectComponent, selector: "pry-select", inputs: ["labelTranslate", "baseTranslate", "translationFn", "translationFnArgs", "clearable", "multiple", "multipleClearRight", "closeOnSelect", "placeholder", "isForm", "required", "name", "readonly", "items", "itemsAsOption", "bindData", "bindValue", "bindLabel", "bindIcon", "iconSize", "templateLabel", "templateOption", "autocomplete"] }, { kind: "component", type: i4.PryIconComponent, selector: "pry-icon", inputs: ["color", "iconSvg", "animation", "iconImage", "alt", "width", "height", "classes"] }, { kind: "component", type: i5.PryCheckboxComponent, selector: "pry-checkbox", inputs: ["circle"] }, { kind: "component", type: i6.ResizableComponent, selector: "th[resizable]" }, { kind: "directive", type: i7.ResizableDirective, selector: "[resizable]", outputs: ["resizable"] }, { kind: "component", type: i8.PryWidgetTableCssComponent, selector: "pry-widget-table-css" }, { kind: "component", type: i9.ExpandValueComponent, selector: "pry-expand-value", inputs: ["value"] }, { kind: "directive", type: i10.DetachRowDirective, selector: "[detachRow]", outputs: ["selectedValue"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TranslateIdPipe, name: "translateId" }, { kind: "pipe", type: i4.TranslateItemToSymbolPipe, name: "translateItemToSymbol" }, { kind: "pipe", type: i4.I18nPipe, name: "i18n" }, { kind: "pipe", type: i11.GetValuePipe, name: "getValue" }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: WidgetTableComponent, selector: "pry-widget-table", usesInheritance: true, ngImport: i0, template: "<pry-widget-table-css></pry-widget-table-css>\n<div class=\"o-widget o-widget--table\">\n  <pry-widget-header\n    [datasourceIds]=\"(datasourceIds$ | async) ?? []\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    #header\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n    (click)=\"refresh()\"\n  >\n    <pry-settings\n      (click)=\"refresh()\"\n      (saveTriggered)=\"emitManifest()\"\n      (changeTitle)=\"changeWidgetTitle($event)\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      (triggerClick)=\"this.refresh()\"\n      class=\"o-settings\"\n    >\n      <div class=\"o-settings__popup__content__actions\">\n        <button type=\"button\" class=\"a-btn a-btn--icon-text -link-like\" (click)=\"addColumn()\">\n          <pry-icon iconSvg=\"post_add\"></pry-icon>\n          {{ '@pry.widget.table.addColumn' | i18n }}\n        </button>\n      </div>\n\n      <div\n        *ngFor=\"let columnDef of optionsCopy?.columns ?? []; let i = index\"\n        class=\"o-settings__popup__content__fields\"\n        (click)=\"refresh()\"\n      >\n        <div class=\"o-settings__popup__content__fields__head\">\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.columns?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_property\">{{ '@pry.widget.table.property' | i18n }}</label>\n            <pry-select\n              (click)=\"refresh()\"\n              (ngModelChange)=\"changePropertyName($event, columnDef)\"\n              [itemsAsOption]=\"true\"\n              [items]=\"properties$ | async\"\n              [ngModel]=\"columnDef.property\"\n              [class.ng-select-opened]=\"isOpen\"\n              bindLabel=\"label\"\n              bindValue=\"property\"\n              id=\"table_property\"\n              class=\"a-pry-select\"\n            ></pry-select>\n          </div>\n\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_label\">{{ '@pry.widget.table.label' | i18n }}</label>\n            <input\n              id=\"table_label\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeLabel($event, columnDef)\"\n              [value]=\"columnDef.label\"\n            />\n          </div>\n        </div>\n        <button\n          (click)=\"deleteColumn(i)\"\n          aria-label=\"delete\"\n          type=\"button\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.table.deleteColumn' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"a-table-wrapper\">\n    <div class=\"a-table-loading\" *ngIf=\"isLoading$ | async; else noLoading\">\n      <span class=\"a-table-loading__loader\"></span>\n    </div>\n    <ng-template #noLoading>\n      <ng-container *ngIf=\"pagination$ | async as pagination\">\n        <ng-container *ngIf=\"pagination?.items ?? [] as allObjects\">\n          <div\n            class=\"no-result\"\n            *ngIf=\"pagination.noFillersItems === 0\"\n            [style.height.%]=\"pagination.totalPages > 0 ? 80 : 100\"\n          >\n            <img\n              class=\"no-result__search\"\n              src=\"../../../assets/svgs/pry_recherche_pas_de_resultat.svg\"\n              alt=\"{{ '@pry.widget.table.empty' | i18n }}\"\n              aria-hidden=\"true\"\n            />\n            <span class=\"no-result__text\">{{ '@pry.widget.table.empty' | i18n }}</span>\n          </div>\n\n          <ng-container *ngIf=\"pagination.noFillersItems > 0\">\n            <ng-container *ngIf=\"(selectedIds$ | async) ?? [] as selectedIds\">\n              <ng-container *ngIf=\"(columns$ | async) ?? [] as columns\">\n                <table class=\"a-table\" [attr.aria-label]=\"'@pry.widget.table.description' | i18n\">\n                  <thead>\n                    <tr>\n                      <th *ngIf=\"allObjects?.length ?? 0 > 0\">\n                        <pry-checkbox [ngModel]=\"areAllSelected\" (ngModelChange)=\"selectAll($event)\"></pry-checkbox>\n                      </th>\n                      <th *ngFor=\"let column of columns; let i = index\" resizable (click)=\"setOrder(column)\">\n                        <span>{{ column.label }}</span>\n                        <ng-container *ngIf=\"quickOrder$ | async as quickOrder\">\n                          <ng-container *ngIf=\"quickOrder.attribute === column.attributeId\">\n                            <pry-icon\n                              [iconSvg]=\"quickOrder.asc ? 'chevron_top' : 'chevron_bottom'\"\n                              [height]=\"12\"\n                              [width]=\"12\"\n                            ></pry-icon>\n                          </ng-container>\n                        </ng-container>\n                      </th>\n                    </tr>\n                  </thead>\n                  <tbody>\n                    <tr\n                      *ngFor=\"let item of allObjects\"\n                      [class.is-selected]=\"selectedIds.includes(item.id)\"\n                      [class.context-menu-selected]=\"contextMenuClickedId === item.id && (isContextMenuOpened$ | async)\"\n                      (contextmenu)=\"contextMenu($event, item)\"\n                      detachRow\n                      (selectedValue)=\"selection($event, item)\"\n                      [class.filler]=\"item.metadata!['__widget-table-filler']\"\n                    >\n                      <td class=\"checkbox-wrapper\">\n                        <pry-checkbox [ngModel]=\"selectedIds.includes(item.id)\"></pry-checkbox>\n                      </td>\n                      <td *ngFor=\"let column of columns\" class=\"u-ellipsis\">\n                        <ng-container *ngIf=\"column.property === 'metadata'\">\n                          <pry-metadata [item]=\"item\"></pry-metadata>\n                        </ng-container>\n                        <ng-container *ngIf=\"column.property === 'oClass'\">\n                          <p class=\"content-img\">\n                            <img\n                              [height]=\"25\"\n                              [width]=\"25\"\n                              [src]=\"item | translateItemToSymbol | async\"\n                              [alt]=\"item.oClass | translateId : { type: 'class', output: 'name' } | async\"\n                            />\n                          </p>\n                        </ng-container>\n                        <ng-container *ngIf=\"!['metadata', 'oClass'].includes(column.property)\">\n                          <pry-expand-value [value]=\"item | getValue : column.property | async\"></pry-expand-value>\n                        </ng-container>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </ng-container>\n            </ng-container>\n          </ng-container>\n\n          <div class=\"a-table-pagination\" *ngIf=\"pagination.totalPages > 0\">\n            <div class=\"a-table-pagination__spacing\">\n              <div>\n                <button (click)=\"goToPage(0)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"skip-left-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button (click)=\"goToPage(pagination.page - 1)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"arrow-left-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                <p>{{ pagination.page + 1 }} / {{ pagination.loadedPages }}</p>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.page + 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"arrow-right-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.loadedPages - 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"skip-right-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                ({{\n                  '@pry.widget.table.remaining' | i18n : { remaining: pagination.totalPages - pagination.loadedPages }\n                }})\n              </div>\n            </div>\n          </div>\n        </ng-container>\n      </ng-container>\n    </ng-template>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.SettingsComponent, selector: "pry-settings", inputs: ["widgetIndex", "isDisable", "headerPresent", "open$", "header"], outputs: ["triggerClick", "saveTriggered", "changeTitle"] }, { kind: "component", type: i4.MetadataComponent, selector: "pry-metadata", inputs: ["item"] }, { kind: "component", type: i4.PryWidgetHeaderComponent, selector: "pry-widget-header", inputs: ["manifest", "openData$", "additionalOptions", "headerOptions", "displayCount", "datasourceIds", "widgetIndex"], outputs: ["manifestModified"] }, { kind: "component", type: i4.PrySelectComponent, selector: "pry-select", inputs: ["labelTranslate", "baseTranslate", "translationFn", "translationFnArgs", "clearable", "multiple", "multipleClearRight", "closeOnSelect", "placeholder", "isForm", "required", "name", "readonly", "items", "itemsAsOption", "bindData", "bindValue", "bindLabel", "bindIcon", "iconSize", "templateLabel", "templateOption", "autocomplete"] }, { kind: "component", type: i4.PryIconComponent, selector: "pry-icon", inputs: ["color", "iconSvg", "animation", "iconImage", "alt", "width", "height", "classes"] }, { kind: "component", type: i5.PryCheckboxComponent, selector: "pry-checkbox", inputs: ["circle"] }, { kind: "component", type: i6.ResizableComponent, selector: "th[resizable]" }, { kind: "directive", type: i7.ResizableDirective, selector: "[resizable]", outputs: ["resizable"] }, { kind: "component", type: i8.PryWidgetTableCssComponent, selector: "pry-widget-table-css" }, { kind: "component", type: i9.ExpandValueComponent, selector: "pry-expand-value", inputs: ["value"] }, { kind: "directive", type: i10.DetachRowDirective, selector: "[detachRow]", outputs: ["selectedValue"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TranslateIdPipe, name: "translateId" }, { kind: "pipe", type: i4.TranslateItemToSymbolPipe, name: "translateItemToSymbol" }, { kind: "pipe", type: i4.I18nPipe, name: "i18n" }, { kind: "pipe", type: i11.GetValuePipe, name: "getValue" }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetTableComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'pry-widget-table', template: "<pry-widget-table-css></pry-widget-table-css>\n<div class=\"o-widget o-widget--table\">\n  <pry-widget-header\n    [datasourceIds]=\"(datasourceIds$ | async) ?? []\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    #header\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n  >\n    <pry-settings\n      (saveTriggered)=\"emitManifest()\"\n      (changeTitle)=\"changeWidgetTitle($event)\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      class=\"o-settings\"\n    >\n      <div class=\"o-settings__popup__content__actions\">\n        <button type=\"button\" class=\"a-btn a-btn--icon-text -link-like\" (click)=\"addColumn()\">\n          <pry-icon iconSvg=\"post_add\"></pry-icon>\n          {{ '@pry.widget.table.addColumn' | i18n }}\n        </button>\n      </div>\n\n      <div\n        *ngFor=\"let columnDef of optionsCopy?.columns ?? []; let i = index\"\n        class=\"o-settings__popup__content__fields\"\n      >\n        <div class=\"o-settings__popup__content__fields__head\">\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.columns?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_property\">{{ '@pry.widget.table.property' | i18n }}</label>\n            <pry-select\n              (ngModelChange)=\"changePropertyName($event, columnDef)\"\n              [itemsAsOption]=\"true\"\n              [items]=\"properties$ | async\"\n              [ngModel]=\"columnDef.property\"\n              bindLabel=\"label\"\n              bindValue=\"property\"\n              id=\"table_property\"\n              class=\"a-pry-select\"\n            ></pry-select>\n          </div>\n\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_label\">{{ '@pry.widget.table.label' | i18n }}</label>\n            <input\n              id=\"table_label\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeLabel($event, columnDef)\"\n              [value]=\"columnDef.label\"\n            />\n          </div>\n        </div>\n        <button\n          (click)=\"deleteColumn(i)\"\n          aria-label=\"delete\"\n          type=\"button\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.table.deleteColumn' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"a-table-wrapper\">\n    <div class=\"a-table-loading\" *ngIf=\"isLoading$ | async; else noLoading\">\n      <span class=\"a-table-loading__loader\"></span>\n    </div>\n    <ng-template #noLoading>\n      <ng-container *ngIf=\"pagination$ | async as pagination\">\n        <ng-container *ngIf=\"pagination?.items ?? [] as allObjects\">\n          <div\n            class=\"no-result\"\n            *ngIf=\"pagination.noFillersItems === 0\"\n            [style.height.%]=\"pagination.totalPages > 0 ? 80 : 100\"\n          >\n            <img\n              class=\"no-result__search\"\n              src=\"../../../assets/svgs/pry_recherche_pas_de_resultat.svg\"\n              alt=\"{{ '@pry.widget.table.empty' | i18n }}\"\n              aria-hidden=\"true\"\n            />\n            <span class=\"no-result__text\">{{ '@pry.widget.table.empty' | i18n }}</span>\n          </div>\n\n          <ng-container *ngIf=\"pagination.noFillersItems > 0\">\n            <ng-container *ngIf=\"(selectedIds$ | async) ?? [] as selectedIds\">\n              <ng-container *ngIf=\"(columns$ | async) ?? [] as columns\">\n                <table class=\"a-table\" [attr.aria-label]=\"'@pry.widget.table.description' | i18n\">\n                  <thead>\n                    <tr>\n                      <th *ngIf=\"allObjects?.length ?? 0 > 0\">\n                        <pry-checkbox [ngModel]=\"areAllSelected\" (ngModelChange)=\"selectAll($event)\"></pry-checkbox>\n                      </th>\n                      <th *ngFor=\"let column of columns; let i = index\" resizable (click)=\"setOrder(column)\">\n                        <span>{{ column.label }}</span>\n                        <ng-container *ngIf=\"quickOrder$ | async as quickOrder\">\n                          <ng-container *ngIf=\"quickOrder.attribute === column.attributeId\">\n                            <pry-icon\n                              [iconSvg]=\"quickOrder.asc ? 'chevron_top' : 'chevron_bottom'\"\n                              [height]=\"12\"\n                              [width]=\"12\"\n                            ></pry-icon>\n                          </ng-container>\n                        </ng-container>\n                      </th>\n                    </tr>\n                  </thead>\n                  <tbody>\n                    <tr\n                      *ngFor=\"let item of allObjects\"\n                      [class.is-selected]=\"selectedIds.includes(item.id)\"\n                      [class.context-menu-selected]=\"contextMenuClickedId === item.id && (isContextMenuOpened$ | async)\"\n                      (contextmenu)=\"contextMenu($event, item)\"\n                      detachRow\n                      (selectedValue)=\"selection($event, item)\"\n                      [class.filler]=\"item.metadata!['__widget-table-filler']\"\n                    >\n                      <td class=\"checkbox-wrapper\">\n                        <pry-checkbox [ngModel]=\"selectedIds.includes(item.id)\"></pry-checkbox>\n                      </td>\n                      <td *ngFor=\"let column of columns\" class=\"u-ellipsis\">\n                        <ng-container *ngIf=\"column.property === 'metadata'\">\n                          <pry-metadata [item]=\"item\"></pry-metadata>\n                        </ng-container>\n                        <ng-container *ngIf=\"column.property === 'oClass'\">\n                          <p class=\"content-img\">\n                            <img\n                              [height]=\"25\"\n                              [width]=\"25\"\n                              [src]=\"item | translateItemToSymbol | async\"\n                              [alt]=\"item.oClass | translateId : { type: 'class', output: 'name' } | async\"\n                            />\n                          </p>\n                        </ng-container>\n                        <ng-container *ngIf=\"!['metadata', 'oClass'].includes(column.property)\">\n                          <pry-expand-value [value]=\"item | getValue : column.property | async\"></pry-expand-value>\n                        </ng-container>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </ng-container>\n            </ng-container>\n          </ng-container>\n\n          <div class=\"a-table-pagination\" *ngIf=\"pagination.totalPages > 0\">\n            <div class=\"a-table-pagination__spacing\">\n              <div>\n                <button (click)=\"goToPage(0)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"skip-left-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button (click)=\"goToPage(pagination.page - 1)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"arrow-left-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                <p>{{ pagination.page + 1 }} / {{ pagination.loadedPages }}</p>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.page + 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"arrow-right-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.loadedPages - 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"skip-right-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                ({{\n                  '@pry.widget.table.remaining' | i18n : { remaining: pagination.totalPages - pagination.loadedPages }\n                }})\n              </div>\n            </div>\n          </div>\n        </ng-container>\n      </ng-container>\n    </ng-template>\n  </div>\n</div>\n" }]
+            args: [{ selector: 'pry-widget-table', template: "<pry-widget-table-css></pry-widget-table-css>\n<div class=\"o-widget o-widget--table\">\n  <pry-widget-header\n    [datasourceIds]=\"(datasourceIds$ | async) ?? []\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    #header\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n    (click)=\"refresh()\"\n  >\n    <pry-settings\n      (click)=\"refresh()\"\n      (saveTriggered)=\"emitManifest()\"\n      (changeTitle)=\"changeWidgetTitle($event)\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      (triggerClick)=\"this.refresh()\"\n      class=\"o-settings\"\n    >\n      <div class=\"o-settings__popup__content__actions\">\n        <button type=\"button\" class=\"a-btn a-btn--icon-text -link-like\" (click)=\"addColumn()\">\n          <pry-icon iconSvg=\"post_add\"></pry-icon>\n          {{ '@pry.widget.table.addColumn' | i18n }}\n        </button>\n      </div>\n\n      <div\n        *ngFor=\"let columnDef of optionsCopy?.columns ?? []; let i = index\"\n        class=\"o-settings__popup__content__fields\"\n        (click)=\"refresh()\"\n      >\n        <div class=\"o-settings__popup__content__fields__head\">\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.columns?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_property\">{{ '@pry.widget.table.property' | i18n }}</label>\n            <pry-select\n              (click)=\"refresh()\"\n              (ngModelChange)=\"changePropertyName($event, columnDef)\"\n              [itemsAsOption]=\"true\"\n              [items]=\"properties$ | async\"\n              [ngModel]=\"columnDef.property\"\n              [class.ng-select-opened]=\"isOpen\"\n              bindLabel=\"label\"\n              bindValue=\"property\"\n              id=\"table_property\"\n              class=\"a-pry-select\"\n            ></pry-select>\n          </div>\n\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_label\">{{ '@pry.widget.table.label' | i18n }}</label>\n            <input\n              id=\"table_label\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeLabel($event, columnDef)\"\n              [value]=\"columnDef.label\"\n            />\n          </div>\n        </div>\n        <button\n          (click)=\"deleteColumn(i)\"\n          aria-label=\"delete\"\n          type=\"button\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.table.deleteColumn' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"a-table-wrapper\">\n    <div class=\"a-table-loading\" *ngIf=\"isLoading$ | async; else noLoading\">\n      <span class=\"a-table-loading__loader\"></span>\n    </div>\n    <ng-template #noLoading>\n      <ng-container *ngIf=\"pagination$ | async as pagination\">\n        <ng-container *ngIf=\"pagination?.items ?? [] as allObjects\">\n          <div\n            class=\"no-result\"\n            *ngIf=\"pagination.noFillersItems === 0\"\n            [style.height.%]=\"pagination.totalPages > 0 ? 80 : 100\"\n          >\n            <img\n              class=\"no-result__search\"\n              src=\"../../../assets/svgs/pry_recherche_pas_de_resultat.svg\"\n              alt=\"{{ '@pry.widget.table.empty' | i18n }}\"\n              aria-hidden=\"true\"\n            />\n            <span class=\"no-result__text\">{{ '@pry.widget.table.empty' | i18n }}</span>\n          </div>\n\n          <ng-container *ngIf=\"pagination.noFillersItems > 0\">\n            <ng-container *ngIf=\"(selectedIds$ | async) ?? [] as selectedIds\">\n              <ng-container *ngIf=\"(columns$ | async) ?? [] as columns\">\n                <table class=\"a-table\" [attr.aria-label]=\"'@pry.widget.table.description' | i18n\">\n                  <thead>\n                    <tr>\n                      <th *ngIf=\"allObjects?.length ?? 0 > 0\">\n                        <pry-checkbox [ngModel]=\"areAllSelected\" (ngModelChange)=\"selectAll($event)\"></pry-checkbox>\n                      </th>\n                      <th *ngFor=\"let column of columns; let i = index\" resizable (click)=\"setOrder(column)\">\n                        <span>{{ column.label }}</span>\n                        <ng-container *ngIf=\"quickOrder$ | async as quickOrder\">\n                          <ng-container *ngIf=\"quickOrder.attribute === column.attributeId\">\n                            <pry-icon\n                              [iconSvg]=\"quickOrder.asc ? 'chevron_top' : 'chevron_bottom'\"\n                              [height]=\"12\"\n                              [width]=\"12\"\n                            ></pry-icon>\n                          </ng-container>\n                        </ng-container>\n                      </th>\n                    </tr>\n                  </thead>\n                  <tbody>\n                    <tr\n                      *ngFor=\"let item of allObjects\"\n                      [class.is-selected]=\"selectedIds.includes(item.id)\"\n                      [class.context-menu-selected]=\"contextMenuClickedId === item.id && (isContextMenuOpened$ | async)\"\n                      (contextmenu)=\"contextMenu($event, item)\"\n                      detachRow\n                      (selectedValue)=\"selection($event, item)\"\n                      [class.filler]=\"item.metadata!['__widget-table-filler']\"\n                    >\n                      <td class=\"checkbox-wrapper\">\n                        <pry-checkbox [ngModel]=\"selectedIds.includes(item.id)\"></pry-checkbox>\n                      </td>\n                      <td *ngFor=\"let column of columns\" class=\"u-ellipsis\">\n                        <ng-container *ngIf=\"column.property === 'metadata'\">\n                          <pry-metadata [item]=\"item\"></pry-metadata>\n                        </ng-container>\n                        <ng-container *ngIf=\"column.property === 'oClass'\">\n                          <p class=\"content-img\">\n                            <img\n                              [height]=\"25\"\n                              [width]=\"25\"\n                              [src]=\"item | translateItemToSymbol | async\"\n                              [alt]=\"item.oClass | translateId : { type: 'class', output: 'name' } | async\"\n                            />\n                          </p>\n                        </ng-container>\n                        <ng-container *ngIf=\"!['metadata', 'oClass'].includes(column.property)\">\n                          <pry-expand-value [value]=\"item | getValue : column.property | async\"></pry-expand-value>\n                        </ng-container>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </ng-container>\n            </ng-container>\n          </ng-container>\n\n          <div class=\"a-table-pagination\" *ngIf=\"pagination.totalPages > 0\">\n            <div class=\"a-table-pagination__spacing\">\n              <div>\n                <button (click)=\"goToPage(0)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"skip-left-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button (click)=\"goToPage(pagination.page - 1)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"arrow-left-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                <p>{{ pagination.page + 1 }} / {{ pagination.loadedPages }}</p>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.page + 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"arrow-right-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.loadedPages - 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"skip-right-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                ({{\n                  '@pry.widget.table.remaining' | i18n : { remaining: pagination.totalPages - pagination.loadedPages }\n                }})\n              </div>\n            </div>\n          </div>\n        </ng-container>\n      </ng-container>\n    </ng-template>\n  </div>\n</div>\n" }]
         }], ctorParameters: function () { return [{ type: i1.Store }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-table.component.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/widgets/widget-table/component/widget-table.component.ts","../../../../../../../projects/provoly/dashboard/widgets/widget-table/component/widget-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, ElementRef } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport {\n  baseItemProperties,\n  Class,\n  ClassActions,\n  ClassSelectors,\n  ColumnDefinition,\n  ConfigSelectors,\n  ContextMenuActions,\n  ContextMenuSelectors,\n  DashboardActions,\n  DashboardSelectors,\n  DataWidgetComponent,\n  Field,\n  FieldSelectors,\n  FieldType,\n  Item,\n  ItemUtils,\n  OrderValue,\n  ResultOrder,\n  SearchSelectors,\n  TableWidgetOptions,\n  WIDGET_HEADER_HEIGHT\n} from '@provoly/dashboard';\nimport equal from 'fast-deep-equal/es6';\nimport { auditTime, BehaviorSubject, combineLatest, Observable, take } from 'rxjs';\nimport { filter, map, tap, withLatestFrom } from 'rxjs/operators';\n\nexport interface Pagination {\n  totalPages: number;\n  page: number;\n  rows: number;\n  items: Item[];\n  loaded: number;\n  loadedPages: number;\n  noFillersItems: number;\n}\n\n@Component({\n  selector: 'pry-widget-table',\n  templateUrl: './widget-table.component.html'\n})\nexport class WidgetTableComponent extends DataWidgetComponent {\n  options$: Observable<TableWidgetOptions>;\n  columns$: Observable<ColumnDefinition[]>;\n  optionsCopy?: TableWidgetOptions;\n  fields$: Observable<Field[]>;\n  selectedIds$: Observable<string[]>;\n  Array = Array;\n  currentClasses: string[] = [];\n  selectedIds: string[] = [];\n  WIDGET_HEADER_HEIGHT = WIDGET_HEADER_HEIGHT;\n  private classes$: Observable<Class[]>;\n  properties$: Observable<{ label: string; property: string }[]>;\n  isLoading$: Observable<boolean>;\n  allSelected$: Observable<boolean>;\n  areAllSelected: boolean = false;\n  allIds: string[] = [];\n  contextMenuClickedId: string = '';\n  isContextMenuOpened$: Observable<boolean>;\n  quickOrder$: Observable<ResultOrder | undefined>;\n  private _refresh$ = new BehaviorSubject<void>(undefined);\n  actualPage$ = new BehaviorSubject<number>(0);\n  pagination$: Observable<Pagination>;\n\n  constructor(store: Store<any>, el: ElementRef, private cdr: ChangeDetectorRef) {\n    super(store, el);\n\n    this.classes$ = this.store.select(ClassSelectors.classes);\n\n    this.fields$ = combineLatest([this.resultSet$, this.classes$, this.store.select(FieldSelectors.fields)]).pipe(\n      map(\n        ([resultSet, classes, fields]) =>\n          [\n            ...ItemUtils.getFieldsFromAvailabilityInResultSet(resultSet, classes, fields),\n            ...baseItemProperties.map((p) => ({ name: p, id: p } as Field))\n          ] as Field[]\n      ),\n      map((fields) => fields.filter((field) => field.type !== FieldType.RAW))\n    );\n\n    this.options$ = combineLatest([\n      this.manifest$.pipe(map((manifest) => manifest.options as TableWidgetOptions)),\n      this.resultSet$,\n      this.classes$,\n      this.fields$,\n      this.store.select(ConfigSelectors.tableDefaultAttributesDefinitions)\n    ]).pipe(\n      map(([options, resultSet, classes, fields, defs]) => {\n        if (!options.columns || options.columns.length === 0) {\n          const attributes = ItemUtils.getAttributesFromRs(resultSet, classes, fields, defs);\n          const uniqueProps = [...new Set(attributes.map((attr) => attr.name))];\n\n          options.columns = uniqueProps.map((property) => ({\n            property: property,\n            label: property,\n            attributeId: attributes.find((attr) => attr.name === property)?.id\n          })) as ColumnDefinition[];\n        }\n        return options;\n      })\n    );\n\n    this.subscriptions.add(\n      this.options$.pipe(filter((opt) => !!opt)).subscribe((options) => {\n        this.optionsCopy = { ...(JSON.parse(JSON.stringify(options)) as TableWidgetOptions) };\n        this.refresh();\n      })\n    );\n\n    this.subscriptions.add(this.allItems$.subscribe((allObjects) => (this.allIds = allObjects.map((obj) => obj.id))));\n\n    this.isLoading$ = combineLatest([store.select(SearchSelectors.searchLoading), this.datasourceIds$]).pipe(\n      map(([searchLoading, datasourceIds]) => {\n        return (searchLoading ?? []).filter((id) => (datasourceIds ?? []).includes(id))?.length > 0;\n      })\n    );\n\n    const HEADER_SIZE = 60;\n    const PAGINATION_SIZE = 35;\n    const LINE_SIZE = 45;\n\n    this.pagination$ = combineLatest([\n      this.allItems$,\n      this.actualPage$,\n      this.widgetSize$,\n      this.resultSet$,\n      this.displayHeader$\n    ]).pipe(\n      map(([items, actualPage, size, rs, headerPresent]) => {\n        const rows = Math.max(\n          1,\n          Math.floor(\n            (size.height - HEADER_SIZE - PAGINATION_SIZE - (headerPresent ? WIDGET_HEADER_HEIGHT : 0)) / LINE_SIZE\n          )\n        );\n        const total = Object.values(rs.count ?? {}).reduce((p, c) => c.count + p, 0);\n        const loadedPages = Math.ceil(items.length / rows);\n        const page = actualPage <= loadedPages ? actualPage : Math.max(0, loadedPages - 1);\n        const filtered = items.filter((_, idx) => idx >= rows * page && idx < rows * (page + 1));\n        const filteredWithFillers =\n          filtered.length === rows\n            ? filtered\n            : filtered.concat(\n                new Array(rows - filtered.length).fill({\n                  metadata: { '__widget-table-filler': true }\n                } as unknown as Item)\n              );\n        return {\n          rows,\n          page,\n          items: filteredWithFillers,\n          noFillersItems: filtered.length,\n          total,\n          totalPages: Math.ceil(total / rows),\n          loaded: items.length,\n          loadedPages\n        };\n      })\n    );\n\n    this.subscriptions.add(this.pagination$.subscribe(() => this.refresh()));\n\n    this.columns$ = this.options$.pipe(\n      map((options) => options?.columns ?? []),\n      tap(() => setTimeout(() => this.refresh(), 500))\n    );\n\n    this.isContextMenuOpened$ = this.store.select(ContextMenuSelectors.opened);\n\n    this.subscriptions.add(\n      this.resultSet$\n        .pipe(\n          filter((rs) => !!rs),\n          map((rs) => Object.keys(rs.items))\n        )\n        .subscribe((classes) => {\n          if (this.currentClasses.length > 0 && !equal(this.currentClasses, classes)) {\n            if (!this.optionsCopy) {\n              this.optionsCopy = {};\n            }\n            delete this.optionsCopy.columns;\n            this.emitManifest();\n          }\n          this.currentClasses = classes;\n        })\n    );\n\n    this.selectedIds$ = this.store.select(DashboardSelectors.selectedItemIds);\n\n    this.subscriptions.add(this.selectedIds$.subscribe((selectedIds) => this.selectedIds === selectedIds));\n\n    this.store.dispatch(ClassActions.load());\n\n    this.properties$ = this.resultSet$.pipe(\n      map((rs) => [...ItemUtils.getAttributesFromAvailabilityInResultSet(rs)]),\n      map((props) => {\n        const sortedProps = [...props];\n        sortedProps.sort((pA, pB) => pA.toLocaleLowerCase().localeCompare(pB.toLocaleLowerCase()));\n        return sortedProps;\n      }),\n      map((props) => props.map((prop) => ({ label: prop, property: prop }))),\n      tap(() => setTimeout(() => this.refresh(), 500))\n    );\n\n    this.allSelected$ = combineLatest([this.selectedIds$, this.allItems$]).pipe(\n      map(([selectedIds, allObjects]) => {\n        const allIds = allObjects.map((object) => object.id);\n        return !allIds.find((id) => !selectedIds.includes(id));\n      }),\n      tap((allSelected) => (this.areAllSelected = allSelected))\n    );\n\n    this.quickOrder$ = combineLatest([this.store.select(DashboardSelectors.quickOrder), this.datasourceIds$]).pipe(\n      map(([order, nqs]) => (nqs.length === 1 ? order[nqs[0]] : undefined))\n    );\n\n    this.subscriptions.add(this._refresh$.pipe(auditTime(200)).subscribe(() => this.cdr.detectChanges()));\n  }\n\n  refresh() {\n    this._refresh$.next();\n  }\n\n  emitManifest() {\n    this.manifestModified.emit({\n      widgetIndex: this.widgetIndex,\n      manifest: { ...this.manifest, options: this.optionsCopy }\n    });\n  }\n\n  addColumn() {\n    if (!this.optionsCopy?.columns) {\n      this.optionsCopy = { columns: [] };\n    }\n    this.optionsCopy.columns?.push({ label: '', property: '' });\n    this.refresh();\n  }\n\n  changePropertyName($event: any, columnDef: ColumnDefinition) {\n    columnDef.property = $event;\n    this.refresh();\n  }\n\n  changeLabel($event: Event, columnDef: ColumnDefinition) {\n    // @ts-ignore\n    const newLabel = $event.currentTarget.value;\n    if (columnDef.label !== newLabel) {\n      columnDef.label = newLabel;\n      this.refresh();\n    }\n  }\n\n  deleteColumn(i: number) {\n    this.optionsCopy?.columns?.splice(i, 1);\n    this.refresh();\n  }\n\n  selection($event: MouseEvent, item: Item) {\n    this.store.dispatch(DashboardActions.select({ id: item.id, cumulative: !$event.shiftKey }));\n    $event.preventDefault();\n    $event.stopPropagation();\n  }\n\n  contextMenu($event: MouseEvent, item: Item) {\n    if (this.manifest.contextMenu !== false) {\n      $event.stopPropagation();\n      $event.preventDefault();\n      this.store.dispatch(\n        ContextMenuActions.open({\n          itemId: item.id,\n          clientX: $event.clientX,\n          clientY: $event.clientY,\n          resultSet: Array.isArray(this.manifest.datasource) ? this.manifest.datasource[0] : this.manifest.datasource,\n          from: 'table',\n          allowObjectCreation: false\n        })\n      );\n      this.contextMenuClickedId = item.id;\n    }\n  }\n\n  invertLayers(idx: number, idxWith: number) {\n    if (!!this.optionsCopy && !!this.optionsCopy.columns) {\n      const tmp = this.optionsCopy.columns[idxWith];\n      this.optionsCopy.columns[idxWith] = this.optionsCopy.columns[idx];\n      this.optionsCopy.columns[idx] = tmp;\n      this.refresh();\n    }\n  }\n\n  selectAll($event: any) {\n    if ($event) {\n      this.store.dispatch(DashboardActions.selectMany({ ids: this.allIds }));\n    } else {\n      this.store.dispatch(DashboardActions.selectMany({ ids: [] }));\n    }\n  }\n\n  setOrder(column: ColumnDefinition) {\n    this.datasourceIds$\n      .pipe(\n        take(1),\n        filter((nqs) => nqs.length === 1),\n        withLatestFrom(this.quickOrder$)\n      )\n      .subscribe(([nqs, actualOrder]) => {\n        this.store.dispatch(\n          DashboardActions.quickOrder({\n            datasourceId: nqs[0],\n            attribute: column.attributeId ?? '',\n            asc: this.nextOrder(column, actualOrder)\n          })\n        );\n      });\n  }\n\n  private nextOrder(column: ColumnDefinition, actualOrder: ResultOrder | undefined): OrderValue {\n    if (!actualOrder || actualOrder.attribute !== column.attributeId) {\n      return 'asc';\n    }\n    return actualOrder.asc === 'asc' ? 'desc' : actualOrder.asc === 'desc' ? undefined : 'asc';\n  }\n\n  trackObjects(index: number, item: Item) {\n    return item.id;\n  }\n\n  goToPage(number: number) {\n    this.actualPage$.next(number);\n  }\n}\n","<pry-widget-table-css></pry-widget-table-css>\n<div class=\"o-widget o-widget--table\">\n  <pry-widget-header\n    [datasourceIds]=\"(datasourceIds$ | async) ?? []\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    #header\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n  >\n    <pry-settings\n      (saveTriggered)=\"emitManifest()\"\n      (changeTitle)=\"changeWidgetTitle($event)\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      class=\"o-settings\"\n    >\n      <div class=\"o-settings__popup__content__actions\">\n        <button type=\"button\" class=\"a-btn a-btn--icon-text -link-like\" (click)=\"addColumn()\">\n          <pry-icon iconSvg=\"post_add\"></pry-icon>\n          {{ '@pry.widget.table.addColumn' | i18n }}\n        </button>\n      </div>\n\n      <div\n        *ngFor=\"let columnDef of optionsCopy?.columns ?? []; let i = index\"\n        class=\"o-settings__popup__content__fields\"\n      >\n        <div class=\"o-settings__popup__content__fields__head\">\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.columns?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_property\">{{ '@pry.widget.table.property' | i18n }}</label>\n            <pry-select\n              (ngModelChange)=\"changePropertyName($event, columnDef)\"\n              [itemsAsOption]=\"true\"\n              [items]=\"properties$ | async\"\n              [ngModel]=\"columnDef.property\"\n              bindLabel=\"label\"\n              bindValue=\"property\"\n              id=\"table_property\"\n              class=\"a-pry-select\"\n            ></pry-select>\n          </div>\n\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_label\">{{ '@pry.widget.table.label' | i18n }}</label>\n            <input\n              id=\"table_label\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeLabel($event, columnDef)\"\n              [value]=\"columnDef.label\"\n            />\n          </div>\n        </div>\n        <button\n          (click)=\"deleteColumn(i)\"\n          aria-label=\"delete\"\n          type=\"button\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.table.deleteColumn' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"a-table-wrapper\">\n    <div class=\"a-table-loading\" *ngIf=\"isLoading$ | async; else noLoading\">\n      <span class=\"a-table-loading__loader\"></span>\n    </div>\n    <ng-template #noLoading>\n      <ng-container *ngIf=\"pagination$ | async as pagination\">\n        <ng-container *ngIf=\"pagination?.items ?? [] as allObjects\">\n          <div\n            class=\"no-result\"\n            *ngIf=\"pagination.noFillersItems === 0\"\n            [style.height.%]=\"pagination.totalPages > 0 ? 80 : 100\"\n          >\n            <img\n              class=\"no-result__search\"\n              src=\"../../../assets/svgs/pry_recherche_pas_de_resultat.svg\"\n              alt=\"{{ '@pry.widget.table.empty' | i18n }}\"\n              aria-hidden=\"true\"\n            />\n            <span class=\"no-result__text\">{{ '@pry.widget.table.empty' | i18n }}</span>\n          </div>\n\n          <ng-container *ngIf=\"pagination.noFillersItems > 0\">\n            <ng-container *ngIf=\"(selectedIds$ | async) ?? [] as selectedIds\">\n              <ng-container *ngIf=\"(columns$ | async) ?? [] as columns\">\n                <table class=\"a-table\" [attr.aria-label]=\"'@pry.widget.table.description' | i18n\">\n                  <thead>\n                    <tr>\n                      <th *ngIf=\"allObjects?.length ?? 0 > 0\">\n                        <pry-checkbox [ngModel]=\"areAllSelected\" (ngModelChange)=\"selectAll($event)\"></pry-checkbox>\n                      </th>\n                      <th *ngFor=\"let column of columns; let i = index\" resizable (click)=\"setOrder(column)\">\n                        <span>{{ column.label }}</span>\n                        <ng-container *ngIf=\"quickOrder$ | async as quickOrder\">\n                          <ng-container *ngIf=\"quickOrder.attribute === column.attributeId\">\n                            <pry-icon\n                              [iconSvg]=\"quickOrder.asc ? 'chevron_top' : 'chevron_bottom'\"\n                              [height]=\"12\"\n                              [width]=\"12\"\n                            ></pry-icon>\n                          </ng-container>\n                        </ng-container>\n                      </th>\n                    </tr>\n                  </thead>\n                  <tbody>\n                    <tr\n                      *ngFor=\"let item of allObjects\"\n                      [class.is-selected]=\"selectedIds.includes(item.id)\"\n                      [class.context-menu-selected]=\"contextMenuClickedId === item.id && (isContextMenuOpened$ | async)\"\n                      (contextmenu)=\"contextMenu($event, item)\"\n                      detachRow\n                      (selectedValue)=\"selection($event, item)\"\n                      [class.filler]=\"item.metadata!['__widget-table-filler']\"\n                    >\n                      <td class=\"checkbox-wrapper\">\n                        <pry-checkbox [ngModel]=\"selectedIds.includes(item.id)\"></pry-checkbox>\n                      </td>\n                      <td *ngFor=\"let column of columns\" class=\"u-ellipsis\">\n                        <ng-container *ngIf=\"column.property === 'metadata'\">\n                          <pry-metadata [item]=\"item\"></pry-metadata>\n                        </ng-container>\n                        <ng-container *ngIf=\"column.property === 'oClass'\">\n                          <p class=\"content-img\">\n                            <img\n                              [height]=\"25\"\n                              [width]=\"25\"\n                              [src]=\"item | translateItemToSymbol | async\"\n                              [alt]=\"item.oClass | translateId : { type: 'class', output: 'name' } | async\"\n                            />\n                          </p>\n                        </ng-container>\n                        <ng-container *ngIf=\"!['metadata', 'oClass'].includes(column.property)\">\n                          <pry-expand-value [value]=\"item | getValue : column.property | async\"></pry-expand-value>\n                        </ng-container>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </ng-container>\n            </ng-container>\n          </ng-container>\n\n          <div class=\"a-table-pagination\" *ngIf=\"pagination.totalPages > 0\">\n            <div class=\"a-table-pagination__spacing\">\n              <div>\n                <button (click)=\"goToPage(0)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"skip-left-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button (click)=\"goToPage(pagination.page - 1)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"arrow-left-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                <p>{{ pagination.page + 1 }} / {{ pagination.loadedPages }}</p>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.page + 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"arrow-right-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.loadedPages - 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"skip-right-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                ({{\n                  '@pry.widget.table.remaining' | i18n : { remaining: pagination.totalPages - pagination.loadedPages }\n                }})\n              </div>\n            </div>\n          </div>\n        </ng-container>\n      </ng-container>\n    </ng-template>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-table.component.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/widgets/widget-table/component/widget-table.component.ts","../../../../../../../projects/provoly/dashboard/widgets/widget-table/component/widget-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, ElementRef } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport {\n  baseItemProperties,\n  Class,\n  ClassActions,\n  ClassSelectors,\n  ColumnDefinition,\n  ConfigSelectors,\n  ContextMenuActions,\n  ContextMenuSelectors,\n  DashboardActions,\n  DashboardSelectors,\n  DataWidgetComponent,\n  Field,\n  FieldSelectors,\n  FieldType,\n  Item,\n  ItemUtils,\n  OrderValue,\n  ResultOrder,\n  SearchSelectors,\n  TableWidgetOptions,\n  WIDGET_HEADER_HEIGHT\n} from '@provoly/dashboard';\nimport equal from 'fast-deep-equal/es6';\nimport { auditTime, BehaviorSubject, combineLatest, Observable, take } from 'rxjs';\nimport { delay, filter, map, tap, withLatestFrom } from 'rxjs/operators';\n\nexport interface Pagination {\n  totalPages: number;\n  page: number;\n  rows: number;\n  items: Item[];\n  loaded: number;\n  loadedPages: number;\n  noFillersItems: number;\n}\n\n@Component({\n  selector: 'pry-widget-table',\n  templateUrl: './widget-table.component.html'\n})\nexport class WidgetTableComponent extends DataWidgetComponent {\n  options$: Observable<TableWidgetOptions>;\n  columns$: Observable<ColumnDefinition[]>;\n  optionsCopy?: TableWidgetOptions;\n  fields$: Observable<Field[]>;\n  selectedIds$: Observable<string[]>;\n  Array = Array;\n  currentClasses: string[] = [];\n  selectedIds: string[] = [];\n  WIDGET_HEADER_HEIGHT = WIDGET_HEADER_HEIGHT;\n  private classes$: Observable<Class[]>;\n  properties$: Observable<{ label: string; property: string }[]>;\n  isLoading$: Observable<boolean>;\n  allSelected$: Observable<boolean>;\n  areAllSelected: boolean = false;\n  allIds: string[] = [];\n  contextMenuClickedId: string = '';\n  isContextMenuOpened$: Observable<boolean>;\n  quickOrder$: Observable<ResultOrder | undefined>;\n  private _refresh$ = new BehaviorSubject<void>(undefined);\n  actualPage$ = new BehaviorSubject<number>(0);\n  pagination$: Observable<Pagination>;\n  isOpen = false;\n\n  constructor(store: Store<any>, el: ElementRef, private cdr: ChangeDetectorRef) {\n    super(store, el);\n\n    this.classes$ = this.store.select(ClassSelectors.classes);\n\n    this.fields$ = combineLatest([this.resultSet$, this.classes$, this.store.select(FieldSelectors.fields)]).pipe(\n      map(\n        ([resultSet, classes, fields]) =>\n          [\n            ...ItemUtils.getFieldsFromAvailabilityInResultSet(resultSet, classes, fields),\n            ...baseItemProperties.map((p) => ({ name: p, id: p } as Field))\n          ] as Field[]\n      ),\n      map((fields) => fields.filter((field) => field.type !== FieldType.RAW))\n    );\n\n    this.options$ = combineLatest([\n      this.manifest$.pipe(map((manifest) => manifest.options as TableWidgetOptions)),\n      this.resultSet$,\n      this.classes$,\n      this.fields$,\n      this.store.select(ConfigSelectors.tableDefaultAttributesDefinitions)\n    ]).pipe(\n      map(([options, resultSet, classes, fields, defs]) => {\n        if (!options.columns || options.columns.length === 0) {\n          const attributes = ItemUtils.getAttributesFromRs(resultSet, classes, fields, defs);\n          const uniqueProps = [...new Set(attributes.map((attr) => attr.name))];\n\n          options.columns = uniqueProps.map((property) => ({\n            property: property,\n            label: property,\n            attributeId: attributes.find((attr) => attr.name === property)?.id\n          })) as ColumnDefinition[];\n        }\n        return options;\n      })\n    );\n\n    this.subscriptions.add(\n      this.options$.pipe(filter((opt) => !!opt)).subscribe((options) => {\n        this.optionsCopy = { ...(JSON.parse(JSON.stringify(options)) as TableWidgetOptions) };\n        this.refresh();\n      })\n    );\n\n    this.subscriptions.add(this.allItems$.subscribe((allObjects) => (this.allIds = allObjects.map((obj) => obj.id))));\n\n    this.isLoading$ = combineLatest([store.select(SearchSelectors.searchLoading), this.datasourceIds$]).pipe(\n      map(([searchLoading, datasourceIds]) => {\n        return (searchLoading ?? []).filter((id) => (datasourceIds ?? []).includes(id))?.length > 0;\n      })\n    );\n\n    const HEADER_SIZE = 60;\n    const PAGINATION_SIZE = 35;\n    const LINE_SIZE = 45;\n\n    this.pagination$ = combineLatest([\n      this.allItems$,\n      this.actualPage$,\n      this.widgetSize$,\n      this.resultSet$,\n      this.displayHeader$\n    ]).pipe(\n      map(([items, actualPage, size, rs, headerPresent]) => {\n        const rows = Math.max(\n          1,\n          Math.floor(\n            (size.height - HEADER_SIZE - PAGINATION_SIZE - (headerPresent ? WIDGET_HEADER_HEIGHT : 0)) / LINE_SIZE\n          )\n        );\n        const total = Object.values(rs.count ?? {}).reduce((p, c) => c.count + p, 0);\n        const loadedPages = Math.ceil(items.length / rows);\n        const page = actualPage <= loadedPages ? actualPage : Math.max(0, loadedPages - 1);\n        const filtered = items.filter((_, idx) => idx >= rows * page && idx < rows * (page + 1));\n        const filteredWithFillers =\n          filtered.length === rows\n            ? filtered\n            : filtered.concat(\n                new Array(rows - filtered.length).fill({\n                  metadata: { '__widget-table-filler': true }\n                } as unknown as Item)\n              );\n        return {\n          rows,\n          page,\n          items: filteredWithFillers,\n          noFillersItems: filtered.length,\n          total,\n          totalPages: Math.ceil(total / rows),\n          loaded: items.length,\n          loadedPages\n        };\n      })\n    );\n\n    this.subscriptions.add(this.pagination$.pipe(auditTime(200)).subscribe(() => this.refresh()));\n\n    this.columns$ = this.options$.pipe(\n      map((options) => options?.columns ?? []),\n      tap(() => setTimeout(() => this.refresh(), 500))\n    );\n\n    this.isContextMenuOpened$ = this.store.select(ContextMenuSelectors.opened);\n\n    this.subscriptions.add(\n      this.resultSet$\n        .pipe(\n          filter((rs) => !!rs),\n          map((rs) => Object.keys(rs.items))\n        )\n        .subscribe((classes) => {\n          if (this.currentClasses.length > 0 && !equal(this.currentClasses, classes)) {\n            if (!this.optionsCopy) {\n              this.optionsCopy = {};\n            }\n            delete this.optionsCopy.columns;\n            this.emitManifest();\n          }\n          this.currentClasses = classes;\n        })\n    );\n\n    this.selectedIds$ = this.store.select(DashboardSelectors.selectedItemIds);\n\n    this.subscriptions.add(this.selectedIds$.subscribe((selectedIds) => this.selectedIds === selectedIds));\n\n    this.store.dispatch(ClassActions.load());\n\n    this.properties$ = this.resultSet$.pipe(\n      map((rs) => [...ItemUtils.getAttributesFromAvailabilityInResultSet(rs)]),\n      map((props) => {\n        const sortedProps = [...props];\n        sortedProps.sort((pA, pB) => pA.toLocaleLowerCase().localeCompare(pB.toLocaleLowerCase()));\n        return sortedProps;\n      }),\n      map((props) => props.map((prop) => ({ label: prop, property: prop }))),\n      tap(() => setTimeout(() => this.refresh(), 500))\n    );\n\n    this.allSelected$ = combineLatest([this.selectedIds$, this.allItems$]).pipe(\n      map(([selectedIds, allObjects]) => {\n        const allIds = allObjects.map((object) => object.id);\n        return !allIds.find((id) => !selectedIds.includes(id));\n      }),\n      tap((allSelected) => (this.areAllSelected = allSelected))\n    );\n\n    this.quickOrder$ = combineLatest([this.store.select(DashboardSelectors.quickOrder), this.datasourceIds$]).pipe(\n      map(([order, nqs]) => (nqs.length === 1 ? order[nqs[0]] : undefined))\n    );\n\n    this.subscriptions.add(this._refresh$.pipe(delay(100)).subscribe(() => this.cdr.detectChanges()));\n  }\n\n  refresh() {\n    this._refresh$.next();\n    this.isOpen = !this.isOpen;\n  }\n\n  emitManifest() {\n    this.manifestModified.emit({\n      widgetIndex: this.widgetIndex,\n      manifest: { ...this.manifest, options: this.optionsCopy }\n    });\n  }\n\n  addColumn() {\n    if (!this.optionsCopy?.columns) {\n      this.optionsCopy = { columns: [] };\n    }\n    this.optionsCopy.columns?.push({ label: '', property: '' });\n    this.refresh();\n  }\n\n  changePropertyName($event: any, columnDef: ColumnDefinition) {\n    columnDef.property = $event;\n    this.refresh();\n  }\n\n  changeLabel($event: Event, columnDef: ColumnDefinition) {\n    // @ts-ignore\n    const newLabel = $event.currentTarget.value;\n    if (columnDef.label !== newLabel) {\n      columnDef.label = newLabel;\n      this.refresh();\n    }\n  }\n\n  deleteColumn(i: number) {\n    this.optionsCopy?.columns?.splice(i, 1);\n    this.refresh();\n  }\n\n  selection($event: MouseEvent, item: Item) {\n    this.store.dispatch(DashboardActions.select({ id: item.id, cumulative: !$event.shiftKey }));\n    $event.preventDefault();\n    $event.stopPropagation();\n  }\n\n  contextMenu($event: MouseEvent, item: Item) {\n    if (this.manifest.contextMenu !== false) {\n      $event.stopPropagation();\n      $event.preventDefault();\n      this.store.dispatch(\n        ContextMenuActions.open({\n          itemId: item.id,\n          clientX: $event.clientX,\n          clientY: $event.clientY,\n          resultSet: Array.isArray(this.manifest.datasource) ? this.manifest.datasource[0] : this.manifest.datasource,\n          from: 'table',\n          allowObjectCreation: false\n        })\n      );\n      this.contextMenuClickedId = item.id;\n    }\n  }\n\n  invertLayers(idx: number, idxWith: number) {\n    if (!!this.optionsCopy && !!this.optionsCopy.columns) {\n      const tmp = this.optionsCopy.columns[idxWith];\n      this.optionsCopy.columns[idxWith] = this.optionsCopy.columns[idx];\n      this.optionsCopy.columns[idx] = tmp;\n      this.refresh();\n    }\n  }\n\n  selectAll($event: any) {\n    if ($event) {\n      this.store.dispatch(DashboardActions.selectMany({ ids: this.allIds }));\n    } else {\n      this.store.dispatch(DashboardActions.selectMany({ ids: [] }));\n    }\n  }\n\n  setOrder(column: ColumnDefinition) {\n    this.datasourceIds$\n      .pipe(\n        take(1),\n        filter((nqs) => nqs.length === 1),\n        withLatestFrom(this.quickOrder$)\n      )\n      .subscribe(([nqs, actualOrder]) => {\n        this.store.dispatch(\n          DashboardActions.quickOrder({\n            datasourceId: nqs[0],\n            attribute: column.attributeId ?? '',\n            asc: this.nextOrder(column, actualOrder)\n          })\n        );\n      });\n  }\n\n  private nextOrder(column: ColumnDefinition, actualOrder: ResultOrder | undefined): OrderValue {\n    if (!actualOrder || actualOrder.attribute !== column.attributeId) {\n      return 'asc';\n    }\n    return actualOrder.asc === 'asc' ? 'desc' : actualOrder.asc === 'desc' ? undefined : 'asc';\n  }\n\n  trackObjects(index: number, item: Item) {\n    return item.id;\n  }\n\n  goToPage(number: number) {\n    this.actualPage$.next(number);\n  }\n}\n","<pry-widget-table-css></pry-widget-table-css>\n<div class=\"o-widget o-widget--table\">\n  <pry-widget-header\n    [datasourceIds]=\"(datasourceIds$ | async) ?? []\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    #header\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n    (click)=\"refresh()\"\n  >\n    <pry-settings\n      (click)=\"refresh()\"\n      (saveTriggered)=\"emitManifest()\"\n      (changeTitle)=\"changeWidgetTitle($event)\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      (triggerClick)=\"this.refresh()\"\n      class=\"o-settings\"\n    >\n      <div class=\"o-settings__popup__content__actions\">\n        <button type=\"button\" class=\"a-btn a-btn--icon-text -link-like\" (click)=\"addColumn()\">\n          <pry-icon iconSvg=\"post_add\"></pry-icon>\n          {{ '@pry.widget.table.addColumn' | i18n }}\n        </button>\n      </div>\n\n      <div\n        *ngFor=\"let columnDef of optionsCopy?.columns ?? []; let i = index\"\n        class=\"o-settings__popup__content__fields\"\n        (click)=\"refresh()\"\n      >\n        <div class=\"o-settings__popup__content__fields__head\">\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.columns?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_property\">{{ '@pry.widget.table.property' | i18n }}</label>\n            <pry-select\n              (click)=\"refresh()\"\n              (ngModelChange)=\"changePropertyName($event, columnDef)\"\n              [itemsAsOption]=\"true\"\n              [items]=\"properties$ | async\"\n              [ngModel]=\"columnDef.property\"\n              [class.ng-select-opened]=\"isOpen\"\n              bindLabel=\"label\"\n              bindValue=\"property\"\n              id=\"table_property\"\n              class=\"a-pry-select\"\n            ></pry-select>\n          </div>\n\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"table_label\">{{ '@pry.widget.table.label' | i18n }}</label>\n            <input\n              id=\"table_label\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeLabel($event, columnDef)\"\n              [value]=\"columnDef.label\"\n            />\n          </div>\n        </div>\n        <button\n          (click)=\"deleteColumn(i)\"\n          aria-label=\"delete\"\n          type=\"button\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.table.deleteColumn' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"a-table-wrapper\">\n    <div class=\"a-table-loading\" *ngIf=\"isLoading$ | async; else noLoading\">\n      <span class=\"a-table-loading__loader\"></span>\n    </div>\n    <ng-template #noLoading>\n      <ng-container *ngIf=\"pagination$ | async as pagination\">\n        <ng-container *ngIf=\"pagination?.items ?? [] as allObjects\">\n          <div\n            class=\"no-result\"\n            *ngIf=\"pagination.noFillersItems === 0\"\n            [style.height.%]=\"pagination.totalPages > 0 ? 80 : 100\"\n          >\n            <img\n              class=\"no-result__search\"\n              src=\"../../../assets/svgs/pry_recherche_pas_de_resultat.svg\"\n              alt=\"{{ '@pry.widget.table.empty' | i18n }}\"\n              aria-hidden=\"true\"\n            />\n            <span class=\"no-result__text\">{{ '@pry.widget.table.empty' | i18n }}</span>\n          </div>\n\n          <ng-container *ngIf=\"pagination.noFillersItems > 0\">\n            <ng-container *ngIf=\"(selectedIds$ | async) ?? [] as selectedIds\">\n              <ng-container *ngIf=\"(columns$ | async) ?? [] as columns\">\n                <table class=\"a-table\" [attr.aria-label]=\"'@pry.widget.table.description' | i18n\">\n                  <thead>\n                    <tr>\n                      <th *ngIf=\"allObjects?.length ?? 0 > 0\">\n                        <pry-checkbox [ngModel]=\"areAllSelected\" (ngModelChange)=\"selectAll($event)\"></pry-checkbox>\n                      </th>\n                      <th *ngFor=\"let column of columns; let i = index\" resizable (click)=\"setOrder(column)\">\n                        <span>{{ column.label }}</span>\n                        <ng-container *ngIf=\"quickOrder$ | async as quickOrder\">\n                          <ng-container *ngIf=\"quickOrder.attribute === column.attributeId\">\n                            <pry-icon\n                              [iconSvg]=\"quickOrder.asc ? 'chevron_top' : 'chevron_bottom'\"\n                              [height]=\"12\"\n                              [width]=\"12\"\n                            ></pry-icon>\n                          </ng-container>\n                        </ng-container>\n                      </th>\n                    </tr>\n                  </thead>\n                  <tbody>\n                    <tr\n                      *ngFor=\"let item of allObjects\"\n                      [class.is-selected]=\"selectedIds.includes(item.id)\"\n                      [class.context-menu-selected]=\"contextMenuClickedId === item.id && (isContextMenuOpened$ | async)\"\n                      (contextmenu)=\"contextMenu($event, item)\"\n                      detachRow\n                      (selectedValue)=\"selection($event, item)\"\n                      [class.filler]=\"item.metadata!['__widget-table-filler']\"\n                    >\n                      <td class=\"checkbox-wrapper\">\n                        <pry-checkbox [ngModel]=\"selectedIds.includes(item.id)\"></pry-checkbox>\n                      </td>\n                      <td *ngFor=\"let column of columns\" class=\"u-ellipsis\">\n                        <ng-container *ngIf=\"column.property === 'metadata'\">\n                          <pry-metadata [item]=\"item\"></pry-metadata>\n                        </ng-container>\n                        <ng-container *ngIf=\"column.property === 'oClass'\">\n                          <p class=\"content-img\">\n                            <img\n                              [height]=\"25\"\n                              [width]=\"25\"\n                              [src]=\"item | translateItemToSymbol | async\"\n                              [alt]=\"item.oClass | translateId : { type: 'class', output: 'name' } | async\"\n                            />\n                          </p>\n                        </ng-container>\n                        <ng-container *ngIf=\"!['metadata', 'oClass'].includes(column.property)\">\n                          <pry-expand-value [value]=\"item | getValue : column.property | async\"></pry-expand-value>\n                        </ng-container>\n                      </td>\n                    </tr>\n                  </tbody>\n                </table>\n              </ng-container>\n            </ng-container>\n          </ng-container>\n\n          <div class=\"a-table-pagination\" *ngIf=\"pagination.totalPages > 0\">\n            <div class=\"a-table-pagination__spacing\">\n              <div>\n                <button (click)=\"goToPage(0)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"skip-left-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button (click)=\"goToPage(pagination.page - 1)\" [disabled]=\"pagination.page <= 0\">\n                  <pry-icon iconSvg=\"arrow-left-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                <p>{{ pagination.page + 1 }} / {{ pagination.loadedPages }}</p>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.page + 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"arrow-right-s-fill\"></pry-icon>\n                </button>\n              </div>\n              <div>\n                <button\n                  (click)=\"goToPage(pagination.loadedPages - 1)\"\n                  [disabled]=\"pagination.page + 1 >= pagination.loadedPages\"\n                >\n                  <pry-icon iconSvg=\"skip-right-fill\"></pry-icon>\n                </button>\n              </div>\n              <div class=\"a-table-pagination__spacing__label\">\n                ({{\n                  '@pry.widget.table.remaining' | i18n : { remaining: pagination.totalPages - pagination.loadedPages }\n                }})\n              </div>\n            </div>\n          </div>\n        </ng-container>\n      </ng-container>\n    </ng-template>\n  </div>\n</div>\n"]}

package/esm2022/widgets/widget-tile/component/widget-tile.component.mjs

@@ -106,7 +106,7 @@ export class WidgetTileComponent extends DataWidgetComponent {
         return Object.keys(value?.metadata ?? {}).length > 0;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetTileComponent, deps: [{ token: i1.Store }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: WidgetTileComponent, selector: "pry-widget-tile", usesInheritance: true, ngImport: i0, template: "<pry-widget-tile-css></pry-widget-tile-css>\n<div class=\"o-widget o-widget--tile\">\n  <pry-widget-header\n    [datasourceIds]=\"(datasourceIds$ | async) ?? []\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n    #header\n  >\n    <pry-settings\n      (saveTriggered)=\"emitManifest()\"\n      (changeTitle)=\"changeWidgetTitle($event)\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      class=\"o-settings\"\n    >\n      <div class=\"m-form-label-field\">\n        <label class=\"a-label\" for=\"tile_classes\">{{ '@pry.widget.tile.classes' | i18n }}</label>\n        <pry-select\n          (ngModelChange)=\"changeClasses($event)\"\n          [itemsAsOption]=\"true\"\n          [items]=\"classes$ | async\"\n          [multiple]=\"true\"\n          [closeOnSelect]=\"false\"\n          [ngModel]=\"optionsCopy.classes\"\n          bindLabel=\"name\"\n          bindValue=\"id\"\n          class=\"a-pry-select\"\n          id=\"tile_classes\"\n        ></pry-select>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n  <div class=\"o-widget--tile-wrapper\" [style.top]=\"(displayHeader$ | async) ? WIDGET_HEADER_HEIGHT + 'px' : 0\">\n    <div class=\"no-result\" *ngIf=\"(items$ | async)?.length === 0\">\n      <img\n        class=\"no-result__search\"\n        src=\"../../../assets/svgs/pry_recherche_pas_de_resultat.svg\"\n        alt=\"{{ '@pry.widget.tile.empty' | i18n }}\"\n        aria-hidden=\"true\"\n      />\n      <span class=\"no-result__text\">{{ '@pry.widget.tile.empty' | i18n }}</span>\n    </div>\n    <ul class=\"o-widget--tile__list\">\n      <li\n        class=\"o-widget--tile__list__item\"\n        *ngFor=\"let item of items$ | async; let index = index\"\n        (contextmenu)=\"contextMenu($event, item)\"\n      >\n        <div class=\"o-widget--tile__list__item__header\">\n          <img\n            [height]=\"25\"\n            [width]=\"25\"\n            [src]=\"item | translateItemToSymbol | async\"\n            [alt]=\"item.oClass | translateId : { type: 'class', output: 'name' } | async\"\n          />\n          <h3 class=\"o-widget--tile__list__item__header__title\">\n            {{\n              item.oClass\n                | translateId\n                  : {\n                      type: 'class',\n                      output: 'name'\n                    }\n                | async\n            }}\n          </h3>\n          <pry-checkbox\n            [ngModel]=\"(selectedIds$ | async).includes(item.id)\"\n            (click)=\"select($event, item)\"\n          ></pry-checkbox>\n        </div>\n        <div class=\"o-properties\">\n          <ul class=\"o-properties__list\">\n            <ng-container *ngFor=\"let property of (propertiesToDisplay$ | async)![item.oClass]\">\n              <li\n                *ngFor=\"let value of getValue(item, property); let i = index; let c = count\"\n                class=\"o-properties__list__item\"\n              >\n                <p class=\"o-properties__list__item__label\" *ngIf=\"i === 0\">{{ property }}:</p>\n                <p class=\"o-properties__list__item__value\" *ngIf=\"!isRaw(property, item.oClass)\">{{ value?.value }}</p>\n                <p class=\"o-properties__list__item__raw\" *ngIf=\"isRaw(property, item.oClass)\">\n                  <pry-vizualize-raw [item]=\"item\" [propertyName]=\"property\"></pry-vizualize-raw>\n                </p>\n                <ng-container *ngIf=\"hasMetadata(value)\">\n                  <pry-metadata [item]=\"value\"></pry-metadata>\n                </ng-container>\n              </li>\n            </ng-container>\n          </ul>\n        </div>\n        <div (click)=\"toggleMap(index)\" class=\"o-widget--tile__list__item__footer\">\n          <button\n            type=\"button\"\n            class=\"a-btn a-btn--icon-text -link-like\"\n            aria-controls=\"tile-map-xxx\"\n            aria-expanded=\"false\"\n          >\n            {{ '@pry.widget.tile.map' | i18n }}\n          </button>\n        </div>\n        <div class=\"o-widget--tile__list__item__map\" *ngIf=\"maps[index]\" id=\"tile-map-xxx\">\n          <pry-widget-map [staticManifest]=\"mapManifest\" [staticResultSet]=\"resultSetWithItem(item)\"></pry-widget-map>\n        </div>\n      </li>\n    </ul>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.SettingsComponent, selector: "pry-settings", inputs: ["widgetIndex", "isDisable", "headerPresent", "open$", "header"], outputs: ["saveTriggered", "changeTitle"] }, { kind: "component", type: i4.MetadataComponent, selector: "pry-metadata", inputs: ["item"] }, { kind: "component", type: i4.PryWidgetHeaderComponent, selector: "pry-widget-header", inputs: ["manifest", "openData$", "additionalOptions", "headerOptions", "displayCount", "datasourceIds", "widgetIndex"], outputs: ["manifestModified"] }, { kind: "component", type: i4.VizualizeRawComponent, selector: "pry-vizualize-raw", inputs: ["item", "propertyName", "alt"] }, { kind: "component", type: i4.PrySelectComponent, selector: "pry-select", inputs: ["labelTranslate", "baseTranslate", "translationFn", "translationFnArgs", "clearable", "multiple", "multipleClearRight", "closeOnSelect", "placeholder", "isForm", "required", "name", "readonly", "items", "itemsAsOption", "bindData", "bindValue", "bindLabel", "bindIcon", "iconSize", "templateLabel", "templateOption", "autocomplete"] }, { kind: "component", type: i5.PryCheckboxComponent, selector: "pry-checkbox", inputs: ["circle"] }, { kind: "component", type: i6.WidgetMapComponent, selector: "pry-widget-map" }, { kind: "component", type: i7.PryWidgetTileCssComponent, selector: "pry-widget-tile-css" }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TranslateIdPipe, name: "translateId" }, { kind: "pipe", type: i4.TranslateItemToSymbolPipe, name: "translateItemToSymbol" }, { kind: "pipe", type: i4.I18nPipe, name: "i18n" }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: WidgetTileComponent, selector: "pry-widget-tile", usesInheritance: true, ngImport: i0, template: "<pry-widget-tile-css></pry-widget-tile-css>\n<div class=\"o-widget o-widget--tile\">\n  <pry-widget-header\n    [datasourceIds]=\"(datasourceIds$ | async) ?? []\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n    #header\n  >\n    <pry-settings\n      (saveTriggered)=\"emitManifest()\"\n      (changeTitle)=\"changeWidgetTitle($event)\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      class=\"o-settings\"\n    >\n      <div class=\"m-form-label-field\">\n        <label class=\"a-label\" for=\"tile_classes\">{{ '@pry.widget.tile.classes' | i18n }}</label>\n        <pry-select\n          (ngModelChange)=\"changeClasses($event)\"\n          [itemsAsOption]=\"true\"\n          [items]=\"classes$ | async\"\n          [multiple]=\"true\"\n          [closeOnSelect]=\"false\"\n          [ngModel]=\"optionsCopy.classes\"\n          bindLabel=\"name\"\n          bindValue=\"id\"\n          class=\"a-pry-select\"\n          id=\"tile_classes\"\n        ></pry-select>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n  <div class=\"o-widget--tile-wrapper\" [style.top]=\"(displayHeader$ | async) ? WIDGET_HEADER_HEIGHT + 'px' : 0\">\n    <div class=\"no-result\" *ngIf=\"(items$ | async)?.length === 0\">\n      <img\n        class=\"no-result__search\"\n        src=\"../../../assets/svgs/pry_recherche_pas_de_resultat.svg\"\n        alt=\"{{ '@pry.widget.tile.empty' | i18n }}\"\n        aria-hidden=\"true\"\n      />\n      <span class=\"no-result__text\">{{ '@pry.widget.tile.empty' | i18n }}</span>\n    </div>\n    <ul class=\"o-widget--tile__list\">\n      <li\n        class=\"o-widget--tile__list__item\"\n        *ngFor=\"let item of items$ | async; let index = index\"\n        (contextmenu)=\"contextMenu($event, item)\"\n      >\n        <div class=\"o-widget--tile__list__item__header\">\n          <img\n            [height]=\"25\"\n            [width]=\"25\"\n            [src]=\"item | translateItemToSymbol | async\"\n            [alt]=\"item.oClass | translateId : { type: 'class', output: 'name' } | async\"\n          />\n          <h3 class=\"o-widget--tile__list__item__header__title\">\n            {{\n              item.oClass\n                | translateId\n                  : {\n                      type: 'class',\n                      output: 'name'\n                    }\n                | async\n            }}\n          </h3>\n          <pry-checkbox\n            [ngModel]=\"(selectedIds$ | async).includes(item.id)\"\n            (click)=\"select($event, item)\"\n          ></pry-checkbox>\n        </div>\n        <div class=\"o-properties\">\n          <ul class=\"o-properties__list\">\n            <ng-container *ngFor=\"let property of (propertiesToDisplay$ | async)![item.oClass]\">\n              <li\n                *ngFor=\"let value of getValue(item, property); let i = index; let c = count\"\n                class=\"o-properties__list__item\"\n              >\n                <p class=\"o-properties__list__item__label\" *ngIf=\"i === 0\">{{ property }}:</p>\n                <p class=\"o-properties__list__item__value\" *ngIf=\"!isRaw(property, item.oClass)\">{{ value?.value }}</p>\n                <p class=\"o-properties__list__item__raw\" *ngIf=\"isRaw(property, item.oClass)\">\n                  <pry-vizualize-raw [item]=\"item\" [propertyName]=\"property\"></pry-vizualize-raw>\n                </p>\n                <ng-container *ngIf=\"hasMetadata(value)\">\n                  <pry-metadata [item]=\"value\"></pry-metadata>\n                </ng-container>\n              </li>\n            </ng-container>\n          </ul>\n        </div>\n        <div (click)=\"toggleMap(index)\" class=\"o-widget--tile__list__item__footer\">\n          <button\n            type=\"button\"\n            class=\"a-btn a-btn--icon-text -link-like\"\n            aria-controls=\"tile-map-xxx\"\n            aria-expanded=\"false\"\n          >\n            {{ '@pry.widget.tile.map' | i18n }}\n          </button>\n        </div>\n        <div class=\"o-widget--tile__list__item__map\" *ngIf=\"maps[index]\" id=\"tile-map-xxx\">\n          <pry-widget-map [staticManifest]=\"mapManifest\" [staticResultSet]=\"resultSetWithItem(item)\"></pry-widget-map>\n        </div>\n      </li>\n    </ul>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.SettingsComponent, selector: "pry-settings", inputs: ["widgetIndex", "isDisable", "headerPresent", "open$", "header"], outputs: ["triggerClick", "saveTriggered", "changeTitle"] }, { kind: "component", type: i4.MetadataComponent, selector: "pry-metadata", inputs: ["item"] }, { kind: "component", type: i4.PryWidgetHeaderComponent, selector: "pry-widget-header", inputs: ["manifest", "openData$", "additionalOptions", "headerOptions", "displayCount", "datasourceIds", "widgetIndex"], outputs: ["manifestModified"] }, { kind: "component", type: i4.VizualizeRawComponent, selector: "pry-vizualize-raw", inputs: ["item", "propertyName", "alt"] }, { kind: "component", type: i4.PrySelectComponent, selector: "pry-select", inputs: ["labelTranslate", "baseTranslate", "translationFn", "translationFnArgs", "clearable", "multiple", "multipleClearRight", "closeOnSelect", "placeholder", "isForm", "required", "name", "readonly", "items", "itemsAsOption", "bindData", "bindValue", "bindLabel", "bindIcon", "iconSize", "templateLabel", "templateOption", "autocomplete"] }, { kind: "component", type: i5.PryCheckboxComponent, selector: "pry-checkbox", inputs: ["circle"] }, { kind: "component", type: i6.WidgetMapComponent, selector: "pry-widget-map" }, { kind: "component", type: i7.PryWidgetTileCssComponent, selector: "pry-widget-tile-css" }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TranslateIdPipe, name: "translateId" }, { kind: "pipe", type: i4.TranslateItemToSymbolPipe, name: "translateItemToSymbol" }, { kind: "pipe", type: i4.I18nPipe, name: "i18n" }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetTileComponent, decorators: [{
             type: Component,