@oneteme/jquery-table 0.0.1 → 0.0.2

package/esm2022/lib/component/export.manager.mjs

@@ -0,0 +1,45 @@
+/**
+ * ExportManager
+ *
+ * Encapsule l'export CSV : construction du fichier BOM/UTF-8, échappement et déclenchement du téléchargement.
+ * Aucune dépendance Angular — indépendant du cycle de vie du composant.
+ */
+export class ExportManager {
+    constructor(getRows, getColumns, getConfig, resolveCellValue) {
+        this.getRows = getRows;
+        this.getColumns = getColumns;
+        this.getConfig = getConfig;
+        this.resolveCellValue = resolveCellValue;
+    }
+    export() {
+        const cfg = this.getConfig();
+        if (!cfg?.enabled)
+            return;
+        const rows = this.getRows();
+        const columns = this.getColumns();
+        const filename = (cfg.filename || 'export') + '.csv';
+        const header = columns.map(c => this._csvEscape(c.header || c.key)).join(',');
+        const lines = rows.map((row, idx) => {
+            if (cfg.transform) {
+                const t = cfg.transform(row);
+                return columns.map(c => this._csvEscape(String(t[c.key] ?? ''))).join(',');
+            }
+            return columns.map(c => this._csvEscape(String(this.resolveCellValue(c, row, idx) ?? ''))).join(',');
+        });
+        // BOM UTF-8 pour une ouverture correcte sous Excel
+        const blob = new Blob(['\uFEFF' + [header, ...lines].join('\n')], { type: 'text/csv;charset=utf-8' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename.endsWith('.csv') ? filename : filename + '.csv';
+        a.click();
+        URL.revokeObjectURL(url);
+    }
+    _csvEscape(value) {
+        if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+            return '"' + value.replace(/"/g, '""') + '"';
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,99 @@
+/**
+ * GroupByManager
+ *
+ * Encapsule tout l'état et la logique liés au mode Group By :
+ * - état collapsed / expanded des groupes
+ * - pagination interne par groupe
+ * - tri des groupes (asc / desc)
+ * - scroll vers un groupe
+ *
+ * Le composant TableComponent l'instancie et lui passe deux callbacks :
+ *   - `onNeedProjection` : demande une reprojection légère de la page courante
+ *   - `onNeedRender`     : demande un rebuild complet (tri changé etc.)
+ */
+export class GroupByManager {
+    constructor(onNeedProjection, onNeedRender) {
+        this.onNeedProjection = onNeedProjection;
+        this.onNeedRender = onNeedRender;
+        /** Groupes actuellement ouverts (mode default-collapsed) ou fermés (mode default-expanded). */
+        this._collapsedGroups = new Set();
+        /** Page courante par clé de groupe. */
+        this._groupPages = new Map();
+        /** Taille de page pour la pagination interne des groupes. */
+        this.groupPageSize = 5;
+        /** Ordre de tri des groupes ('asc' | 'desc'). */
+        this.groupSortOrder = 'asc';
+        /**
+         * Quand `true`, tous les groupes sont collapsés par défaut.
+         * `_collapsedGroups` contient alors le seul groupe ouvert.
+         */
+        this._defaultGroupCollapsed = false;
+    }
+    // ── API publique
+    /** Initialise le mode par défaut selon qu'un groupBy vient d'être activé. */
+    setDefaultCollapsed(collapsed) {
+        this._defaultGroupCollapsed = collapsed;
+    }
+    /** Réinitialise l'état (à appeler quand le groupBy change de colonne). */
+    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();
+    }
+    /** Retourne le groupe actuellement ouvert (seulement en mode default-collapsed avec exactement 1 ouvert). */
+    getSingleOpenGroup() {
+        return this._defaultGroupCollapsed && this._collapsedGroups.size === 1
+            ? [...this._collapsedGroups][0]
+            : null;
+    }
+    // ── Pagination par groupe
+    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,{"version":3,"file":"group-by.manager.js","sourceRoot":"","sources":["../../../../../../projects/oneteme/jquery-table/src/lib/component/group-by.manager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GroupByManager\n *\n * Encapsule tout l'état et la logique liés au mode Group By :\n * - état collapsed / expanded des groupes\n * - pagination interne par groupe\n * - tri des groupes (asc / desc)\n * - scroll vers un groupe\n *\n * Le composant TableComponent l'instancie et lui passe deux callbacks :\n *   - `onNeedProjection` : demande une reprojection légère de la page courante\n *   - `onNeedRender`     : demande un rebuild complet (tri changé etc.)\n */\nexport class GroupByManager {\n  /** Groupes actuellement ouverts (mode default-collapsed) ou fermés (mode default-expanded). */\n  private readonly _collapsedGroups = new Set<string>();\n\n  /** Page courante par clé de groupe. */\n  private readonly _groupPages = new Map<string, number>();\n\n  /** Taille de page pour la pagination interne des groupes. */\n  groupPageSize = 5;\n\n  /** Ordre de tri des groupes ('asc' | 'desc'). */\n  groupSortOrder: 'asc' | 'desc' = 'asc';\n\n  /**\n   * Quand `true`, tous les groupes sont collapsés par défaut.\n   * `_collapsedGroups` contient alors le seul groupe ouvert.\n   */\n  private _defaultGroupCollapsed = false;\n\n  constructor(\n    private readonly onNeedProjection: () => void,\n    private readonly onNeedRender: () => void,\n  ) {}\n\n  // ── API publique\n\n  /** Initialise le mode par défaut selon qu'un groupBy vient d'être activé. */\n  setDefaultCollapsed(collapsed: boolean): void {\n    this._defaultGroupCollapsed = collapsed;\n  }\n\n  /** Réinitialise l'état (à appeler quand le groupBy change de colonne). */\n  reset(): void {\n    this._collapsedGroups.clear();\n    this._groupPages.clear();\n  }\n\n  isGroupCollapsed(groupKey: string): boolean {\n    return this._defaultGroupCollapsed\n      ? !this._collapsedGroups.has(groupKey)\n      : this._collapsedGroups.has(groupKey);\n  }\n\n  toggleGroupCollapse(groupKey: string, scrollTo: (key: string) => void): void {\n    if (this._collapsedGroups.has(groupKey)) {\n      this._collapsedGroups.delete(groupKey);\n    } else {\n      this._collapsedGroups.clear();\n      this._collapsedGroups.add(groupKey);\n      scrollTo(groupKey);\n    }\n    this.onNeedProjection();\n  }\n\n  /** Retourne le groupe actuellement ouvert (seulement en mode default-collapsed avec exactement 1 ouvert). */\n  getSingleOpenGroup(): string | null {\n    return this._defaultGroupCollapsed && this._collapsedGroups.size === 1\n      ? [...this._collapsedGroups][0]\n      : null;\n  }\n\n  // ── Pagination par groupe\n\n  getPage(groupKey: string): number {\n    return this._groupPages.get(groupKey) ?? 0;\n  }\n\n  groupPageBack(groupKey: string): void {\n    const current = this._groupPages.get(groupKey) ?? 0;\n    if (current > 0) {\n      this._groupPages.set(groupKey, current - 1);\n      this.onNeedProjection();\n    }\n  }\n\n  groupPageForward(groupKey: string, totalCount: number): void {\n    const maxPage = Math.ceil(totalCount / this.groupPageSize) - 1;\n    const current = this._groupPages.get(groupKey) ?? 0;\n    if (current < maxPage) {\n      this._groupPages.set(groupKey, current + 1);\n      this.onNeedProjection();\n    }\n  }\n\n  onGroupPageSizeChange(size: number): void {\n    this.groupPageSize = size;\n    this._groupPages.clear();\n    this.onNeedRender();\n  }\n\n  onGroupSortToggle(dir: 'asc' | 'desc', scrollTo: (key: string) => void): void {\n    if (this.groupSortOrder === dir) return;\n    this.groupSortOrder = dir;\n    this._groupPages.clear();\n    this.onNeedRender();\n    const openGroup = this.getSingleOpenGroup();\n    if (openGroup) scrollTo(openGroup);\n  }\n}\n"]}

package/esm2022/lib/component/lazy-column-manager.mjs

@@ -0,0 +1,99 @@
+import { Subject, take, takeUntil } from 'rxjs';
+import { LAZY_LOADING_VALUE, LAZY_ERROR_VALUE } from './table.constants';
+/**
+ * Gère le cycle de vie des colonnes à chargement différé (lazy) :
+ * statuts, données, annulation des requêtes en cours.
+ *
+ * Pas de dépendance Angular/DOM — peut être instancié manuellement dans le composant.
+ */
+export class LazyColumnManager {
+    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_LOADING_VALUE)
+            return 'loading';
+        if (rowValue === LAZY_ERROR_VALUE)
+            return 'error';
+        return 'value';
+    }
+    /** Annule tous les fetches en cours et réinitialise l'état (appeler lors d'un changement de données). */
+    cancelAll() {
+        this._cancels.forEach(s => { s.next(); s.complete(); });
+        this._cancels.clear();
+        this._status = new Map();
+        this._data = new Map();
+    }
+    /** Réinitialise une colonne et relance son fetch. */
+    retry(column, resolvedData, callbacks) {
+        const k = column.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(column, resolvedData, callbacks);
+    }
+    /** Lance le chargement différé d'une colonne. No-op si déjà en cours. */
+    fetch(column, resolvedData, callbacks) {
+        if (!column.lazy)
+            return;
+        const k = column.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();
+        column.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-column-manager.js","sourceRoot":"","sources":["../../../../../../projects/oneteme/jquery-table/src/lib/component/lazy-column-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject, take, takeUntil } from 'rxjs';\nimport { TableColumnProvider } from '../jquery-table.model';\nimport { LAZY_LOADING_VALUE, LAZY_ERROR_VALUE } from './table.constants';\n\nexport interface LazyCallbacks {\n  onRefresh(): void;\n  onMarkForCheck(): void;\n}\n\n/**\n * Gère le cycle de vie des colonnes à chargement différé (lazy) :\n * statuts, données, annulation des requêtes en cours.\n *\n * Pas de dépendance Angular/DOM — peut être instancié manuellement dans le composant.\n */\nexport class LazyColumnManager<T = any> {\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_LOADING_VALUE) return 'loading';\n    if (rowValue === LAZY_ERROR_VALUE) return 'error';\n    return 'value';\n  }\n\n  /** Annule tous les fetches en cours et réinitialise l'état (appeler lors d'un changement de données). */\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  /** Réinitialise une colonne et relance son fetch. */\n  retry(column: TableColumnProvider<T>, resolvedData: T[], callbacks: LazyCallbacks): void {\n    const k = column.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(column, resolvedData, callbacks);\n  }\n\n  /** Lance le chargement différé d'une colonne. No-op si déjà en cours. */\n  fetch(column: TableColumnProvider<T>, resolvedData: T[], callbacks: LazyCallbacks): void {\n    if (!column.lazy) return;\n    const k = column.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    column.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"]}