@oneteme/jquery-organizer 0.0.1

package/README.md

@@ -0,0 +1,441 @@
+# @oneteme/jquery-organizer
+
+Bibliothèque Angular autonome pour la gestion décentralisée des configurations de graphiques et tableaux. Elle fournit :
+
+- **OrganizerButtonComponent** — Bouton configurable pour sélectionner indicateurs, regroupements et filtres
+- **SlicePanelComponent** — Panneau latéral collapsible pour le filtrage par catégories
+- **Adapters** — Fonctions de conversion ChartConfig ↔ OrganizerConfig avec auto-détection d'unités
+- **Facade** — Gestion centralisée d'état pour les champs visibles, regroupements, filtres
+
+**v0.0.43+**: Support complet pour **UnitConfig avec auto-scaling intelligent** des unités Y (ms → µs → s, etc.)
+
+---
+
+## Quick Start
+
+### Import
+
+```typescript
+import { OrganizerButtonModule } from '@oneteme/jquery-organizer';
+import { OrganizerConfig, OrganizerState, OrganizerButtonEvent } from '@oneteme/jquery-organizer';
+
+@NgModule({
+  imports: [OrganizerButtonModule]
+})
+export class MyModule {}
+```
+
+### Template
+
+```html
+<organizer-button 
+  [config]="organizerConfig"
+  [state]="organizerState"
+  (viewChange)="onOrganizerChange($event)"
+  (sliceStateChange)="onSliceStateChange($event)">
+</organizer-button>
+
+<slice-panel
+  *ngIf="sliceState"
+  [sliceConfigs]="sliceState.sliceConfigs"
+  [data]="sliceState.tasks"
+  (filterChange)="onFilterChange($event)">
+</slice-panel>
+```
+
+---
+
+## Sommaire
+
+- [Architecture](#architecture)
+- [Dépendances](#dépendances)
+- [OrganizerButtonComponent](#organizerbuttoncomponent)
+  - [Inputs / Outputs](#inputs--outputs)
+  - [OrganizerConfig](#organizerconfig)
+  - [OrganizerState et OrganizerEvent](#organizerstate-et-organizerevent)
+- [SlicePanelComponent](#slicepanelcomponent)
+- [Système d'Unités avec Auto-Scaling](#système-dunités-avec-auto-scaling)
+- [Chart Adapter](#chart-adapter)
+- [Intégration avec jquery-echarts](#intégration-avec-jquery-echarts)
+- [Intégration avec jquery-table](#intégration-avec-jquery-table)
+
+---
+
+## Architecture
+
+Structure des fichiers et dépendances :
+
+```
+@oneteme/jquery-organizer
+├── organizer-button/
+│   ├── organizer-button.component.ts    (standalone)
+│   └── organizer-button.module.ts
+├── slice-panel/
+│   ├── slice-panel.component.ts         (standalone)
+│   └── slice-panel.model.ts
+├── models/
+│   ├── organizer-config.interface.ts    (OrganizerConfig, OrganizerState, OrganizerEvent)
+│   ├── organizer-chart-adapter.ts       (chartConfigToOrganizer, resolveYUnit, etc.)
+│   ├── organizer-utils.ts               (buildYFields, resolveYKey)
+│   └── organizer-menu.model.ts
+├── organizer-facade/
+│   └── organizer-facade.ts              (Gestion centralisée d'état)
+└── public-api.ts                        (Exports publics)
+```
+
+---
+
+## Dépendances
+
+Version minimale requise :
+
+| Dépendance | Version | Rôle |
+|---|---|---|
+| `@angular/core` | >= 16.1.0 | Framework Angular |
+| `@angular/material` | ^16.1.0 | MatMenu, MatIcon (optionnel) |
+| `@oneteme/jquery-core` | ^0.0.32+ | UnitConfig, ScaleConfig, DataProvider |
+
+---
+
+## OrganizerButtonComponent
+
+Composant standalone qui affiche un bouton ouvrant un menu Material. Le menu expose les options de configuration et gère le lazy-loading des données.
+
+### Inputs / Outputs
+
+| Prop | Type | Description |
+|---|---|---|
+| `[config]` | `OrganizerConfig` | Configuration du bouton et menu |
+| `[state]` | `OrganizerState` | État courant des sélections |
+| `(viewChange)` | `EventEmitter<OrganizerEvent>` | Émis à chaque interaction utilisateur |
+| `(sliceStateChange)` | `EventEmitter<OrganizerSliceState \| null>` | Données de filtre après fetch |
+
+### OrganizerConfig
+
+```typescript
+export interface OrganizerConfig {
+  // Champs/Indicateurs/Groupements disponibles
+  xFields?: OrganizerXField[];           // Dimensions (ex: date, host)
+  yFields?: OrganizerYField[];           // Indicateurs (ex: count, elapsed_avg)
+  groups?: OrganizerViewGroup[];         // Options de regroupement
+  slices?: OrganizerViewSlice[];         // Options de filtre
+
+  // Callbacks
+  onFetchFieldData?: (fieldId: string) => Promise<any[]>;
+  onFetchSliceData?: (filterKey: string) => Observable<any[]> | Promise<any[]>;
+  onSliceClick?: () => void;
+
+  // Export & Préférences
+  showExport?: boolean;
+  onExport?: () => void;
+  showPreferences?: boolean;
+  onPreferencesEdit?: () => void;
+  onPreferencesSave?: () => void;
+  onPreferencesClear?: () => void;
+
+  // UI
+  showReset?: boolean;                   // Défaut: true
+  buttonLabel?: string;
+  buttonIcon?: string;                   // Icône Material
+  showButtonIcon?: boolean;
+  menuPosition?: 'above' | 'below';
+  menuClass?: string;
+
+  switchView?: {
+    currentView: 'chart' | 'table';
+    onSwitch: (newView: 'chart' | 'table') => void;
+  };
+}
+```
+
+### OrganizerState et OrganizerEvent
+
+```typescript
+export interface OrganizerState {
+  viewMode?: 'chart' | 'table';
+  visibleFields?: string[];             // Champs visibles en table
+  selectedX?: string;                   // Dimension X (ex: 'date')
+  selectedY?: string;                   // Indicateur Y (ex: 'count')
+  selectedYAggregate?: string;           // Agrégat si applicable
+  selectedGroupBy?: string;              // Regroupement actif
+  selectedSlices?: string[];             // Filtres actifs
+}
+
+export interface OrganizerButtonEvent {
+  type: 'fieldToggled' | 'xSelected' | 'ySelected' | 'groupBySelected' 
+      | 'sliceSelected' | 'reset' | 'viewSwitched';
+  state: OrganizerState;                 // État complet après action
+  source?: 'user' | 'api';
+  resolvedYUnit?: string | UnitConfig;   // Unité auto-détectée (voir Auto-Scaling)
+}
+```
+
+---
+
+## SlicePanelComponent
+
+Panneau latéral collapsible pour filtrer les données par catégories.
+
+### Inputs / Outputs
+
+| Prop | Type | Défaut | Description |
+|---|---|---|---|
+| `[sliceConfigs]` | `SliceConfig<T>[]` | `[]` | Définition des groupes de filtres |
+| `[data]` | `T[]` | `[]` | Données brutes à filtrer |
+| `[showCounts]` | `boolean` | `true` | Affiche comptage par catégorie |
+| `[showToggle]` | `boolean` | `true` | Affiche bouton replier/déplier |
+| `[alwaysShow]` | `boolean` | `false` | Affiche même sans données |
+| `(filterChange)` | `EventEmitter<(row: T) => boolean>` | — | Prédicat de filtre |
+| `(collapsedChange)` | `EventEmitter<boolean>` | — | État replié |
+
+---
+
+## Système d'Unités avec Auto-Scaling
+
+Formatage intelligent et conversion dynamique des unités Y
+
+### UnitConfig — Configuration Intelligente
+
+Au lieu d'une simple string `unit: 'ms'`, `UnitConfig` permet l'auto-détection du meilleur format selon l'ordre de grandeur des données :
+
+```typescript
+interface UnitConfig {
+  baseUnit: string;              // Unité source ('s', 'o', etc.)
+  scales: ScaleConfig[];         // Formats disponibles (µs, ms, s)
+  precision?: number;
+  formatter?: (v: number, selectedUnit: string) => string;
+}
+
+interface ScaleConfig {
+  unit: string;                  // Unité affichée ('µs', 'ms', 's')
+  scale: number;                 // Facteur de conversion (1000 pour s→ms)
+  threshold?: number;            // Utiliser si max(données) > threshold
+}
+```
+
+### Exemple: Latence avec Auto-Scaling
+
+```typescript
+{
+  key: 'avg',
+  selected: true,
+  unit: {
+    baseUnit: 's',
+    scales: [
+      { unit: 'µs', scale: 1000000, threshold: 0.001 },  // < 1ms
+      { unit: 'ms', scale: 1000,    threshold: 1 },      // < 1s  (DEFAULT)
+      { unit: 's',  scale: 1,       threshold: Infinity } // >= 1s
+    ]
+  }
+}
+```
+
+**Résultat :**
+- Données `[0.0001, 0.0005]` → Affiche en **µs** (`100 µs`, `500 µs`)
+- Données `[0.05, 0.2, 0.8]` → Affiche en **ms** (`50 ms`, `200 ms`, `800 ms`)
+- Données `[1.5, 3.2, 5.1]` → Affiche en **s** (`1,5 s`, `3,2 s`, `5,1 s`)
+
+### Affichage Adaptatif de la Précision
+
+Les nombres sont formatés avec une précision qui s'ajuste à l'ordre de grandeur :
+
+```
+Valeur        Format         Raison
+0.000123   → "0,000123"     6 décimales (très petit)
+0.05       → "0,05"        2 décimales
+1234       → "1 234"       0 décimale (entier avec séparateur)
+50000      → "50 000"      0 décimale
+```
+
+---
+
+## Chart Adapter
+
+Les fonctions `organizer-chart-adapter.ts` convertissent entre `ChartConfig` (métier) et `OrganizerConfig` (UI) :
+
+```typescript
+// ChartConfig → OrganizerConfig
+export function chartConfigToOrganizer(
+  chartConfig: any,
+  options?: OrganizerChartBridgeOptions
+): OrganizerConfig
+
+// ChartConfig → OrganizerState
+export function chartConfigToState(chartConfig: any): OrganizerState
+
+// ChartConfig → Événement + État unifié
+export function chartConfigToUnifiedState(
+  chartConfig: any,
+  viewMode?: 'chart' | 'table'
+): OrganizerUnifiedState
+
+// Applique un OrganizerEvent à ChartConfig
+export function applyOrganizerEventToChart(
+  event: OrganizerButtonEvent,
+  chartConfig: any
+): void
+
+// Résout l'unité Y pour l'événement
+export function resolveYUnit(
+  chartConfig: any,
+  selectedY?: string,
+  selectedYAggregate?: string
+): string | UnitConfig | undefined
+```
+
+---
+
+## Intégration avec jquery-echarts
+
+### Pattern 3-étapes
+
+1. **Initialisation** : Construire OrganizerConfig depuis ChartConfig
+2. **Réaction aux événements** : Appliquer OrganizerEvent à ChartConfig
+3. **Refetch** : Recharger les données avec la nouvelle config
+
+### Exemple Complet
+
+```typescript
+import { OrganizerButtonEvent, OrganizerSliceState } from '@oneteme/jquery-organizer';
+import { chartConfigToOrganizer, chartConfigToState, applyOrganizerEventToChart } from '@oneteme/jquery-organizer';
+
+@Component({
+  selector: 'app-kpi',
+  template: `
+    <organizer-button
+      [config]="$latency.config"
+      [state]="$latency.state"
+      (viewChange)="onLatencyViewChange($event)"
+      (sliceStateChange)="onLatencySliceChange($event)">
+    </organizer-button>
+    <chart [config]="$latency.chartProvider" [data]="$latency.data"></chart>
+  `
+})
+export class KpiComponent {
+  $latency = {
+    config: {},
+    state: {},
+    chartConfig: REST_LATENCY_CHART_CONFIG('day'),
+    chartProvider: {},
+    data: []
+  };
+
+  ngOnInit() {
+    // Initialisation
+    this.$latency.config = chartConfigToOrganizer(this.$latency.chartConfig);
+    this.$latency.state = chartConfigToState(this.$latency.chartConfig);
+    this._fetchLatency();
+  }
+
+  onLatencyViewChange(event: OrganizerButtonEvent): void {
+    // Appliquer l'événement → met à jour ChartConfig
+    applyOrganizerEventToChart(event, this.$latency.chartConfig);
+    
+    // Mettre à jour la UI du button
+    this.$latency.state = event.state;
+    
+    // Refetch
+    this._fetchLatency();
+  }
+
+  private _fetchLatency(): void {
+    const cfg = this.$latency.chartConfig;
+    const ind = cfg.indicators.items.find(i => i.selected);
+    
+    this._httpService.getLatency({ indicator: ind, ... }).subscribe(data => {
+      const series = buildSeries(cfg.series.items, ind, cfg.groups.items[0], null, data);
+      
+      // Injection de l'unité (simple string ou UnitConfig)
+      this.$latency.chartProvider = {
+        ...this.BASE_CHART_PROVIDER,
+        series,
+        yUnit: ind?.unit  // ← string | UnitConfig
+      };
+      
+      this.$latency.data = data;
+    });
+  }
+}
+```
+
+---
+
+## Intégration avec jquery-table
+
+```typescript
+import { TableComponent } from '@oneteme/jquery-table';
+import { OrganizerButtonModule } from '@oneteme/jquery-organizer';
+
+@Component({
+  imports: [TableComponent, OrganizerButtonModule]
+})
+export class TableWithOrganizerComponent {
+  @ViewChild(TableComponent) table: TableComponent;
+
+  onOrganizerViewChange(event: OrganizerButtonEvent): void {
+    // Le tableau gère automatiquement les colonnes visibles
+    if (event.type === 'fieldToggled') {
+      this.table.applyVisibleColumns(event.state.visibleFields);
+    }
+    if (event.type === 'groupBySelected') {
+      this.table.applyGroupBy(event.state.selectedGroupBy);
+    }
+  }
+}
+```
+
+---
+
+## API Exports
+
+Exports publics de la bibliothèque :
+
+```typescript
+// Composants
+export { OrganizerButtonComponent } from './organizer-button.component';
+export { OrganizerButtonModule } from './organizer-button.module';
+export { SlicePanelComponent } from './slice-panel.component';
+
+// Interfaces
+export { OrganizerConfig, OrganizerState, OrganizerButtonEvent, OrganizerSliceState } from './organizer-config.interface';
+export { SliceConfig, SliceColumnDef, SliceCategory } from './slice-panel.model';
+
+// Adapters
+export {
+  chartConfigToOrganizer,
+  chartConfigToState,
+  chartConfigToUnifiedState,
+  applyOrganizerEventToChart,
+  resolveYUnit
+} from './organizer-chart-adapter';
+
+// Utilitaires
+export { buildYFields, resolveYKey } from './organizer-utils';
+
+// Facade
+export { OrganizerFacade } from './organizer-facade/organizer-facade';
+```
+
+---
+
+## Changelog
+
+### v0.0.43+ (2026-07-03)
+- Ajout du support **UnitConfig** avec auto-scaling intelligent
+- Exports des adapters (chartConfigToOrganizer, resolveYUnit, etc.)
+- Renommage des propriétés OrganizerFacade (Column → Field) dans jquery-table
+- Support des `ScaleConfig` pour conversion dynamique d'unités
+- Formatage adaptatif de la précision (smartFormatY) en chart-utils
+- Intégration complète avec REST_LATENCY_CHART_CONFIG
+
+### v0.0.42
+- Refactoring des exports publics
+- Consolidation de SlicePanelComponent
+
+---
+
+## Support
+
+Pour des questions ou des bugs, ouvrir une issue dans le repository jquery-charts.
+
+License: Voir LICENSE in the root.

package/esm2022/lib/group-by-manager/group-by-manager.mjs

@@ -0,0 +1,73 @@
+export class GroupByManager {
+    constructor(onNeedProjection, onNeedRender) {
+        this.onNeedProjection = onNeedProjection;
+        this.onNeedRender = onNeedRender;
+        this._collapsedGroups = new Set();
+        this._groupPages = new Map();
+        this.groupPageSize = 5;
+        this.groupSortOrder = 'asc';
+        this._defaultGroupCollapsed = false;
+    }
+    setDefaultCollapsed(collapsed) {
+        this._defaultGroupCollapsed = collapsed;
+    }
+    reset() {
+        this._collapsedGroups.clear();
+        this._groupPages.clear();
+    }
+    isGroupCollapsed(groupKey) {
+        return this._defaultGroupCollapsed
+            ? !this._collapsedGroups.has(groupKey)
+            : this._collapsedGroups.has(groupKey);
+    }
+    toggleGroupCollapse(groupKey, scrollTo) {
+        if (this._collapsedGroups.has(groupKey)) {
+            this._collapsedGroups.delete(groupKey);
+        }
+        else {
+            this._collapsedGroups.clear();
+            this._collapsedGroups.add(groupKey);
+            scrollTo(groupKey);
+        }
+        this.onNeedProjection();
+    }
+    getSingleOpenGroup() {
+        return this._defaultGroupCollapsed && this._collapsedGroups.size === 1
+            ? [...this._collapsedGroups][0]
+            : null;
+    }
+    getPage(groupKey) {
+        return this._groupPages.get(groupKey) ?? 0;
+    }
+    groupPageBack(groupKey) {
+        const current = this._groupPages.get(groupKey) ?? 0;
+        if (current > 0) {
+            this._groupPages.set(groupKey, current - 1);
+            this.onNeedProjection();
+        }
+    }
+    groupPageForward(groupKey, totalCount) {
+        const maxPage = Math.ceil(totalCount / this.groupPageSize) - 1;
+        const current = this._groupPages.get(groupKey) ?? 0;
+        if (current < maxPage) {
+            this._groupPages.set(groupKey, current + 1);
+            this.onNeedProjection();
+        }
+    }
+    onGroupPageSizeChange(size) {
+        this.groupPageSize = size;
+        this._groupPages.clear();
+        this.onNeedRender();
+    }
+    onGroupSortToggle(dir, scrollTo) {
+        if (this.groupSortOrder === dir)
+            return;
+        this.groupSortOrder = dir;
+        this._groupPages.clear();
+        this.onNeedRender();
+        const openGroup = this.getSingleOpenGroup();
+        if (openGroup)
+            scrollTo(openGroup);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/lazy-field-manager/lazy-field-manager.mjs

@@ -0,0 +1,91 @@
+import { Subject, take, takeUntil } from 'rxjs';
+export const LAZY_FIELD_LOADING_VALUE = '__lazy_loading__';
+export const LAZY_FIELD_ERROR_VALUE = '__lazy_error__';
+export class LazyFieldManager {
+    constructor() {
+        this._status = new Map();
+        this._data = new Map();
+        this._cancels = new Map();
+    }
+    get status() {
+        return this._status;
+    }
+    get data() {
+        return this._data;
+    }
+    getStatus(key) {
+        return this._status.get(key) ?? 'idle';
+    }
+    getRenderType(rowValue) {
+        if (rowValue === LAZY_FIELD_LOADING_VALUE)
+            return 'loading';
+        if (rowValue === LAZY_FIELD_ERROR_VALUE)
+            return 'error';
+        return 'value';
+    }
+    cancelAll() {
+        this._cancels.forEach(s => { s.next(); s.complete(); });
+        this._cancels.clear();
+        this._status = new Map();
+        this._data = new Map();
+    }
+    retry(field, resolvedData, callbacks) {
+        const k = field.key;
+        const prev = this._cancels.get(k);
+        if (prev) {
+            prev.next();
+            prev.complete();
+        }
+        this._cancels.delete(k);
+        const newStatus = new Map(this._status);
+        newStatus.delete(k);
+        this._status = newStatus;
+        const newData = new Map(this._data);
+        newData.delete(k);
+        this._data = newData;
+        this.fetch(field, resolvedData, callbacks);
+    }
+    fetch(field, resolvedData, callbacks) {
+        if (!field.lazy)
+            return;
+        const k = field.key;
+        if (this._status.get(k) === 'loading')
+            return;
+        const prev = this._cancels.get(k);
+        if (prev) {
+            prev.next();
+            prev.complete();
+        }
+        const cancel$ = new Subject();
+        this._cancels.set(k, cancel$);
+        const newStatus = new Map(this._status);
+        newStatus.set(k, 'loading');
+        this._status = newStatus;
+        callbacks.onRefresh();
+        field.lazy.fetchFn().pipe(take(1), takeUntil(cancel$)).subscribe({
+            next: (values) => {
+                const rowMap = new Map();
+                values.forEach((value, i) => {
+                    if (i < resolvedData.length)
+                        rowMap.set(resolvedData[i], value);
+                });
+                const newData = new Map(this._data);
+                newData.set(k, rowMap);
+                this._data = newData;
+                const newStatus2 = new Map(this._status);
+                newStatus2.set(k, 'loaded');
+                this._status = newStatus2;
+                callbacks.onRefresh();
+                callbacks.onMarkForCheck();
+            },
+            error: () => {
+                const newStatusErr = new Map(this._status);
+                newStatusErr.set(k, 'error');
+                this._status = newStatusErr;
+                callbacks.onRefresh();
+                callbacks.onMarkForCheck();
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-field-manager.js","sourceRoot":"","sources":["../../../../../../projects/oneteme/jquery-organizer/src/lib/lazy-field-manager/lazy-field-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject, take, takeUntil } from 'rxjs';\n\nexport interface LazyFieldDef {\n  key: string;\n  lazy?: {\n    fetchFn: () => Observable<any[]>;\n  };\n}\nexport interface LazyFieldCallbacks {\n  onRefresh(): void;\n  onMarkForCheck(): void;\n}\n\nexport const LAZY_FIELD_LOADING_VALUE = '__lazy_loading__';\nexport const LAZY_FIELD_ERROR_VALUE = '__lazy_error__';\n\nexport class LazyFieldManager<TField extends LazyFieldDef = LazyFieldDef> {\n\n  private _status = new Map<string, 'idle' | 'loading' | 'loaded' | 'error'>();\n  private _data = new Map<string, Map<any, any>>();\n  private _cancels = new Map<string, Subject<void>>();\n\n  get status(): Map<string, 'idle' | 'loading' | 'loaded' | 'error'> {\n    return this._status;\n  }\n\n  get data(): Map<string, Map<any, any>> {\n    return this._data;\n  }\n\n  getStatus(key: string): 'idle' | 'loading' | 'loaded' | 'error' {\n    return this._status.get(key) ?? 'idle';\n  }\n\n  getRenderType(rowValue: any): 'loading' | 'error' | 'value' {\n    if (rowValue === LAZY_FIELD_LOADING_VALUE) return 'loading';\n    if (rowValue === LAZY_FIELD_ERROR_VALUE) return 'error';\n    return 'value';\n  }\n\n  cancelAll(): void {\n    this._cancels.forEach(s => { s.next(); s.complete(); });\n    this._cancels.clear();\n    this._status = new Map();\n    this._data = new Map();\n  }\n\n  retry<TRow>(field: TField, resolvedData: TRow[], callbacks: LazyFieldCallbacks): void {\n    const k = field.key;\n    const prev = this._cancels.get(k);\n    if (prev) { prev.next(); prev.complete(); }\n    this._cancels.delete(k);\n\n    const newStatus = new Map(this._status);\n    newStatus.delete(k);\n    this._status = newStatus;\n\n    const newData = new Map(this._data);\n    newData.delete(k);\n    this._data = newData;\n\n    this.fetch(field, resolvedData, callbacks);\n  }\n\n  fetch<TRow>(field: TField, resolvedData: TRow[], callbacks: LazyFieldCallbacks): void {\n    if (!field.lazy) return;\n    const k = field.key;\n    if (this._status.get(k) === 'loading') return;\n\n    const prev = this._cancels.get(k);\n    if (prev) { prev.next(); prev.complete(); }\n    const cancel$ = new Subject<void>();\n    this._cancels.set(k, cancel$);\n\n    const newStatus = new Map(this._status);\n    newStatus.set(k, 'loading');\n    this._status = newStatus;\n    callbacks.onRefresh();\n\n    field.lazy.fetchFn().pipe(\n      take(1),\n      takeUntil(cancel$),\n    ).subscribe({\n      next: (values: any[]) => {\n        const rowMap = new Map<any, any>();\n        values.forEach((value, i) => {\n          if (i < resolvedData.length) rowMap.set(resolvedData[i], value);\n        });\n        const newData = new Map(this._data);\n        newData.set(k, rowMap);\n        this._data = newData;\n\n        const newStatus2 = new Map(this._status);\n        newStatus2.set(k, 'loaded');\n        this._status = newStatus2;\n\n        callbacks.onRefresh();\n        callbacks.onMarkForCheck();\n      },\n      error: () => {\n        const newStatusErr = new Map(this._status);\n        newStatusErr.set(k, 'error');\n        this._status = newStatusErr;\n\n        callbacks.onRefresh();\n        callbacks.onMarkForCheck();\n      },\n    });\n  }\n}\n"]}

package/esm2022/lib/models/index.mjs

@@ -0,0 +1,3 @@
+export * from './organizer-config.interface';
+export * from './organizer-menu.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vbmV0ZW1lL2pxdWVyeS1vcmdhbml6ZXIvc3JjL2xpYi9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9vcmdhbml6ZXItY29uZmlnLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL29yZ2FuaXplci1tZW51Lm1vZGVsJztcbiJdfQ==