raain-app 1.6.21 → 1.6.24

package/CHANGELOG.md

@@ -7,7 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [1.6.20] - 2025-12-14
+## [1.6.23] - 2026-01-19
+
+### Added
+
+- New `CumulativeSelectorComponent` for selecting and creating cumulative periods
+    - Lists available cumulative periods with window duration display
+    - Validates base cumulative coverage before allowing new period creation
+    - Polls for computation completion with progress feedback
+- ProfileService: `getCumulativePeriods()` to list available cumulative periods
+- ProfileService: `createCumulativePeriod()` to trigger cumulative computation
+
+### Changed
+
+- Cumulative toggle now shows selector popup when enabling (instead of direct toggle)
+- RaainDetails: cumulative period selection flow with `onCumulativePeriodSelected()`
+
+## [1.6.22] - 2025-12-16
 
 ### Added
 

package/cumulative-selector/cumulative-selector.component.d.ts

@@ -0,0 +1,45 @@
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { ProfileService } from '../profile.service';
+import { CumulativePeriod } from 'raain-model';
+import * as i0 from "@angular/core";
+export interface CumulativeSelection {
+    periodBegin: Date;
+    periodEnd: Date;
+    windowInMinutes: number;
+}
+export declare class CumulativeSelectorComponent implements OnInit {
+    private profileService;
+    private cdr;
+    rainId: string;
+    currentPeriodBegin: Date;
+    currentPeriodEnd: Date;
+    provider: string;
+    timeStepInMinutes: number;
+    isAdmin: boolean;
+    periodSelected: EventEmitter<CumulativeSelection>;
+    cancelled: EventEmitter<void>;
+    availablePeriods: CumulativePeriod[];
+    baseCumulatives: CumulativePeriod;
+    loading: boolean;
+    creating: boolean;
+    creationProgress: string;
+    errorMessage: string;
+    coveragePercent: number;
+    canCreateNew: boolean;
+    currentWindowMinutes: number;
+    private readonly POLL_TIMEOUT_MS;
+    private readonly POLL_INTERVAL_MS;
+    constructor(profileService: ProfileService, cdr: ChangeDetectorRef);
+    ngOnInit(): Promise<void>;
+    loadAvailablePeriods(): Promise<void>;
+    calculateCoverage(): void;
+    selectPeriod(period: CumulativePeriod): void;
+    createNewPeriod(): Promise<void>;
+    private pollForCompletion;
+    private sleep;
+    cancel(): void;
+    formatPeriod(period: CumulativePeriod): string;
+    formatWindow(minutes: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CumulativeSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CumulativeSelectorComponent, "cumulative-selector", never, { "rainId": "rainId"; "currentPeriodBegin": "currentPeriodBegin"; "currentPeriodEnd": "currentPeriodEnd"; "provider": "provider"; "timeStepInMinutes": "timeStepInMinutes"; "isAdmin": "isAdmin"; }, { "periodSelected": "periodSelected"; "cancelled": "cancelled"; }, never, never, false, never>;
+}

package/esm2020/cumulative-selector/cumulative-selector.component.mjs

@@ -0,0 +1,199 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../profile.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@ionic/angular";
+export class CumulativeSelectorComponent {
+    constructor(profileService, cdr) {
+        this.profileService = profileService;
+        this.cdr = cdr;
+        this.timeStepInMinutes = 5;
+        this.isAdmin = false;
+        this.periodSelected = new EventEmitter();
+        this.cancelled = new EventEmitter();
+        this.availablePeriods = [];
+        this.baseCumulatives = null;
+        this.loading = true;
+        this.creating = false;
+        this.creationProgress = '';
+        this.errorMessage = '';
+        this.coveragePercent = 0;
+        this.canCreateNew = false;
+        this.currentWindowMinutes = 0;
+        this.POLL_TIMEOUT_MS = 900000; // 900 seconds
+        this.POLL_INTERVAL_MS = 3000;
+    }
+    async ngOnInit() {
+        this.currentWindowMinutes = Math.round((this.currentPeriodEnd.getTime() - this.currentPeriodBegin.getTime()) / 60000);
+        await this.loadAvailablePeriods();
+    }
+    async loadAvailablePeriods() {
+        this.loading = true;
+        this.errorMessage = '';
+        this.cdr.markForCheck();
+        try {
+            // Fetch all cumulative periods (admin sees all, non-admin sees only customer-launched)
+            const response = await this.profileService.getCumulativePeriods(this.rainId, {
+                provider: this.provider,
+                forced: this.isAdmin,
+            });
+            // Filter for existing custom cumulatives (window > 0)
+            this.availablePeriods = response.periods.filter((p) => p.windowInMinutes > 0);
+            // Get base cumulatives (window = 0) to check coverage
+            this.baseCumulatives = response.periods.find((p) => p.windowInMinutes === 0);
+            this.calculateCoverage();
+        }
+        catch (e) {
+            this.errorMessage = 'Failed to load cumulative periods';
+            console.error('Error loading cumulative periods:', e);
+        }
+        this.loading = false;
+        this.cdr.markForCheck();
+    }
+    calculateCoverage() {
+        if (!this.baseCumulatives) {
+            this.coveragePercent = 0;
+            this.canCreateNew = false;
+            return;
+        }
+        const baseBegin = new Date(this.baseCumulatives.periodBegin);
+        const baseEnd = new Date(this.baseCumulatives.periodEnd);
+        // Check if current period is within base coverage
+        const currentInRange = this.currentPeriodBegin >= baseBegin && this.currentPeriodEnd <= baseEnd;
+        if (!currentInRange) {
+            this.coveragePercent = 0;
+            this.canCreateNew = false;
+            return;
+        }
+        // Calculate expected number of base cumulatives needed
+        const expectedCount = Math.ceil(this.currentWindowMinutes / this.timeStepInMinutes);
+        // Check if enough base cumulatives exist
+        // We assume coverage is complete if count >= expected (simplified check)
+        if (this.baseCumulatives.count >= expectedCount) {
+            this.coveragePercent = 100;
+            this.canCreateNew = true;
+        }
+        else {
+            this.coveragePercent = Math.round((this.baseCumulatives.count / expectedCount) * 100);
+            this.canCreateNew = this.coveragePercent >= 100;
+        }
+    }
+    selectPeriod(period) {
+        this.periodSelected.emit({
+            periodBegin: new Date(period.periodBegin),
+            periodEnd: new Date(period.periodEnd),
+            windowInMinutes: period.windowInMinutes,
+        });
+    }
+    async createNewPeriod() {
+        if (!this.canCreateNew || this.creating) {
+            return;
+        }
+        this.creating = true;
+        this.creationProgress = 'Starting cumulative computation...';
+        this.errorMessage = '';
+        this.cdr.markForCheck();
+        try {
+            // Trigger cumulative creation
+            const result = await this.profileService.createCumulativePeriod(this.rainId, {
+                periodBegin: this.currentPeriodBegin,
+                periodEnd: this.currentPeriodEnd,
+                provider: this.provider,
+                timeStepInMinutes: this.timeStepInMinutes,
+            });
+            if (!result) {
+                throw new Error('Failed to trigger cumulative computation');
+            }
+            this.creationProgress = `Jobs queued. Polling for completion...`;
+            this.cdr.markForCheck();
+            // Poll for completion
+            const success = await this.pollForCompletion();
+            if (success) {
+                this.periodSelected.emit({
+                    periodBegin: this.currentPeriodBegin,
+                    periodEnd: this.currentPeriodEnd,
+                    windowInMinutes: this.currentWindowMinutes,
+                });
+            }
+            else {
+                this.errorMessage = 'Timeout waiting for cumulative computation';
+            }
+        }
+        catch (e) {
+            this.errorMessage = `Error: ${e.message || 'Unknown error'}`;
+            console.error('Error creating cumulative:', e);
+        }
+        this.creating = false;
+        this.cdr.markForCheck();
+    }
+    async pollForCompletion() {
+        const startTime = Date.now();
+        while (Date.now() - startTime < this.POLL_TIMEOUT_MS) {
+            try {
+                const progress = await this.profileService.getRainProgress(this.rainId);
+                if (progress === 0) {
+                    // Queue is empty, check if cumulative exists (admin sees all cumulatives)
+                    const response = await this.profileService.getCumulativePeriods(this.rainId, {
+                        provider: this.provider,
+                        windowInMinutes: this.currentWindowMinutes,
+                        forced: this.isAdmin,
+                    });
+                    const found = response.periods.find((p) => p.windowInMinutes === this.currentWindowMinutes);
+                    if (found) {
+                        return true;
+                    }
+                }
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                this.creationProgress = `Computing... (${elapsed}s, queue: ${progress})`;
+                this.cdr.markForCheck();
+                await this.sleep(this.POLL_INTERVAL_MS);
+            }
+            catch (e) {
+                console.warn('Poll error:', e);
+                await this.sleep(this.POLL_INTERVAL_MS);
+            }
+        }
+        return false;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    cancel() {
+        this.cancelled.emit();
+    }
+    formatPeriod(period) {
+        const begin = new Date(period.periodBegin);
+        const end = new Date(period.periodEnd);
+        return `${begin.toLocaleString()} → ${end.toLocaleString()}`;
+    }
+    formatWindow(minutes) {
+        if (minutes < 60) {
+            return `${minutes} min`;
+        }
+        const hours = minutes / 60;
+        return hours === 1 ? '1 hour' : `${hours} hours`;
+    }
+}
+CumulativeSelectorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CumulativeSelectorComponent, deps: [{ token: i1.ProfileService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+CumulativeSelectorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: CumulativeSelectorComponent, selector: "cumulative-selector", inputs: { rainId: "rainId", currentPeriodBegin: "currentPeriodBegin", currentPeriodEnd: "currentPeriodEnd", provider: "provider", timeStepInMinutes: "timeStepInMinutes", isAdmin: "isAdmin" }, outputs: { periodSelected: "periodSelected", cancelled: "cancelled" }, ngImport: i0, template: "<div class=\"cumulative-selector-overlay\">\n    <div class=\"cumulative-selector-modal\">\n        <div class=\"modal-header\">\n            <h2>Select Cumulative Period</h2>\n            <ion-button fill=\"clear\" (click)=\"cancel()\">\n                <ion-icon name=\"close\"></ion-icon>\n            </ion-button>\n        </div>\n\n        <div class=\"modal-content\">\n            <!-- Loading state -->\n            <div *ngIf=\"loading\" class=\"loading-state\">\n                <ion-spinner name=\"crescent\"></ion-spinner>\n                <p>Loading available periods...</p>\n            </div>\n\n            <!-- Error message -->\n            <div *ngIf=\"errorMessage\" class=\"error-message\">\n                <ion-icon name=\"warning-outline\"></ion-icon>\n                <span>{{ errorMessage }}</span>\n            </div>\n\n            <!-- Available periods list -->\n            <div *ngIf=\"!loading && availablePeriods.length > 0\" class=\"periods-section\">\n                <h3>Available Cumulative Periods</h3>\n                <ion-list>\n                    <ion-item *ngFor=\"let period of availablePeriods\"\n                              button\n                              (click)=\"selectPeriod(period)\"\n                              [disabled]=\"creating\">\n                        <ion-icon name=\"layers-outline\" slot=\"start\"></ion-icon>\n                        <ion-label>\n                            <h2>{{ formatWindow(period.windowInMinutes) }}</h2>\n                            <p>{{ formatPeriod(period) }}</p>\n                            <p class=\"count-info\">{{ period.count }} cumulative(s)</p>\n                        </ion-label>\n                        <ion-icon name=\"chevron-forward\" slot=\"end\"></ion-icon>\n                    </ion-item>\n                </ion-list>\n            </div>\n\n            <!-- No periods available -->\n            <div *ngIf=\"!loading && availablePeriods.length === 0\" class=\"no-periods\">\n                <ion-icon name=\"information-circle-outline\"></ion-icon>\n                <p>No cumulative periods available yet.</p>\n            </div>\n\n            <!-- Create new section (admin only) -->\n            <div *ngIf=\"!loading && isAdmin\" class=\"create-section\">\n                <h3>Create New Cumulative</h3>\n                <div class=\"create-info\">\n                    <p>\n                        <strong>Period:</strong>\n                        {{ currentPeriodBegin?.toLocaleString() }} \u2192 {{ currentPeriodEnd?.toLocaleString() }}\n                    </p>\n                    <p>\n                        <strong>Window:</strong> {{ formatWindow(currentWindowMinutes) }}\n                    </p>\n                    <p *ngIf=\"baseCumulatives\" class=\"coverage-info\"\n                       [class.coverage-ok]=\"coveragePercent >= 100\"\n                       [class.coverage-warn]=\"coveragePercent > 0 && coveragePercent < 100\"\n                       [class.coverage-error]=\"coveragePercent === 0\">\n                        <ion-icon [name]=\"coveragePercent >= 100 ? 'checkmark-circle' : 'alert-circle'\"></ion-icon>\n                        Base data coverage: {{ coveragePercent }}%\n                    </p>\n                    <p *ngIf=\"!baseCumulatives\" class=\"coverage-error\">\n                        <ion-icon name=\"alert-circle\"></ion-icon>\n                        No base cumulatives available\n                    </p>\n                </div>\n\n                <!-- Creation progress -->\n                <div *ngIf=\"creating\" class=\"creation-progress\">\n                    <ion-spinner name=\"crescent\"></ion-spinner>\n                    <span>{{ creationProgress }}</span>\n                </div>\n\n                <ion-button [disabled]=\"!canCreateNew || creating\"\n                            expand=\"block\"\n                            (click)=\"createNewPeriod()\">\n                    <ion-icon name=\"add-circle-outline\" slot=\"start\"></ion-icon>\n                    Create {{ formatWindow(currentWindowMinutes) }} Cumulative\n                </ion-button>\n\n                <p *ngIf=\"!canCreateNew && !creating\" class=\"create-hint\">\n                    Create is disabled because base 5-min cumulatives don't fully cover the selected period.\n                </p>\n            </div>\n        </div>\n\n        <div class=\"modal-footer\">\n            <ion-button fill=\"outline\" (click)=\"cancel()\" [disabled]=\"creating\">\n                Cancel\n            </ion-button>\n        </div>\n    </div>\n</div>\n", styles: [".cumulative-selector-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,.5);display:flex;align-items:center;justify-content:center;z-index:1000}.cumulative-selector-modal{background:var(--ion-background-color, #fff);border-radius:12px;max-width:500px;width:90%;max-height:80vh;display:flex;flex-direction:column;box-shadow:0 4px 20px #0000004d}.modal-header{display:flex;justify-content:space-between;align-items:center;padding:16px 20px;border-bottom:1px solid var(--ion-border-color, #ddd)}.modal-header h2{margin:0;font-size:1.25rem;font-weight:600}.modal-header ion-button{--padding-start: 8px;--padding-end: 8px}.modal-content{flex:1;overflow-y:auto;padding:16px 20px}.loading-state{display:flex;flex-direction:column;align-items:center;padding:40px 0}.loading-state ion-spinner{margin-bottom:16px}.loading-state p{color:var(--ion-color-medium)}.error-message{display:flex;align-items:center;gap:8px;padding:12px;background:var(--ion-color-danger-tint);color:var(--ion-color-danger);border-radius:8px;margin-bottom:16px}.error-message ion-icon{font-size:1.25rem}.periods-section{margin-bottom:24px}.periods-section h3{font-size:1rem;font-weight:600;margin-bottom:12px;color:var(--ion-color-dark)}.periods-section ion-list{border-radius:8px;overflow:hidden}.periods-section ion-item{--padding-start: 12px;--padding-end: 12px}.periods-section ion-item ion-label h2{font-weight:500}.periods-section ion-item ion-label p{font-size:.85rem;color:var(--ion-color-medium)}.periods-section ion-item ion-label .count-info{font-size:.75rem;color:var(--ion-color-primary)}.no-periods{display:flex;flex-direction:column;align-items:center;padding:24px;text-align:center;color:var(--ion-color-medium)}.no-periods ion-icon{font-size:2rem;margin-bottom:8px}.create-section{border-top:1px solid var(--ion-border-color, #ddd);padding-top:16px}.create-section h3{font-size:1rem;font-weight:600;margin-bottom:12px;color:var(--ion-color-dark)}.create-section .create-info{background:var(--ion-color-light);padding:12px;border-radius:8px;margin-bottom:16px}.create-section .create-info p{margin:4px 0;font-size:.9rem}.create-section .coverage-info{display:flex;align-items:center;gap:6px}.create-section .coverage-info ion-icon{font-size:1.1rem}.create-section .coverage-ok{color:var(--ion-color-success)}.create-section .coverage-warn{color:var(--ion-color-warning)}.create-section .coverage-error{color:var(--ion-color-danger)}.create-section .creation-progress{display:flex;align-items:center;gap:12px;padding:16px;background:var(--ion-color-primary-tint);border-radius:8px;margin-bottom:16px}.create-section .creation-progress ion-spinner{--color: var(--ion-color-primary)}.create-section .creation-progress span{color:var(--ion-color-primary);font-size:.9rem}.create-section .create-hint{font-size:.8rem;color:var(--ion-color-medium);text-align:center;margin-top:8px}.modal-footer{padding:16px 20px;border-top:1px solid var(--ion-border-color, #ddd);display:flex;justify-content:flex-end}\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: "component", type: i3.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: i3.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: i3.IonItem, selector: "ion-item", inputs: ["button", "color", "counter", "counterFormatter", "detail", "detailIcon", "disabled", "download", "fill", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "shape", "target", "type"] }, { kind: "component", type: i3.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { kind: "component", type: i3.IonList, selector: "ion-list", inputs: ["inset", "lines", "mode"] }, { kind: "component", type: i3.IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CumulativeSelectorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cumulative-selector', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"cumulative-selector-overlay\">\n    <div class=\"cumulative-selector-modal\">\n        <div class=\"modal-header\">\n            <h2>Select Cumulative Period</h2>\n            <ion-button fill=\"clear\" (click)=\"cancel()\">\n                <ion-icon name=\"close\"></ion-icon>\n            </ion-button>\n        </div>\n\n        <div class=\"modal-content\">\n            <!-- Loading state -->\n            <div *ngIf=\"loading\" class=\"loading-state\">\n                <ion-spinner name=\"crescent\"></ion-spinner>\n                <p>Loading available periods...</p>\n            </div>\n\n            <!-- Error message -->\n            <div *ngIf=\"errorMessage\" class=\"error-message\">\n                <ion-icon name=\"warning-outline\"></ion-icon>\n                <span>{{ errorMessage }}</span>\n            </div>\n\n            <!-- Available periods list -->\n            <div *ngIf=\"!loading && availablePeriods.length > 0\" class=\"periods-section\">\n                <h3>Available Cumulative Periods</h3>\n                <ion-list>\n                    <ion-item *ngFor=\"let period of availablePeriods\"\n                              button\n                              (click)=\"selectPeriod(period)\"\n                              [disabled]=\"creating\">\n                        <ion-icon name=\"layers-outline\" slot=\"start\"></ion-icon>\n                        <ion-label>\n                            <h2>{{ formatWindow(period.windowInMinutes) }}</h2>\n                            <p>{{ formatPeriod(period) }}</p>\n                            <p class=\"count-info\">{{ period.count }} cumulative(s)</p>\n                        </ion-label>\n                        <ion-icon name=\"chevron-forward\" slot=\"end\"></ion-icon>\n                    </ion-item>\n                </ion-list>\n            </div>\n\n            <!-- No periods available -->\n            <div *ngIf=\"!loading && availablePeriods.length === 0\" class=\"no-periods\">\n                <ion-icon name=\"information-circle-outline\"></ion-icon>\n                <p>No cumulative periods available yet.</p>\n            </div>\n\n            <!-- Create new section (admin only) -->\n            <div *ngIf=\"!loading && isAdmin\" class=\"create-section\">\n                <h3>Create New Cumulative</h3>\n                <div class=\"create-info\">\n                    <p>\n                        <strong>Period:</strong>\n                        {{ currentPeriodBegin?.toLocaleString() }} \u2192 {{ currentPeriodEnd?.toLocaleString() }}\n                    </p>\n                    <p>\n                        <strong>Window:</strong> {{ formatWindow(currentWindowMinutes) }}\n                    </p>\n                    <p *ngIf=\"baseCumulatives\" class=\"coverage-info\"\n                       [class.coverage-ok]=\"coveragePercent >= 100\"\n                       [class.coverage-warn]=\"coveragePercent > 0 && coveragePercent < 100\"\n                       [class.coverage-error]=\"coveragePercent === 0\">\n                        <ion-icon [name]=\"coveragePercent >= 100 ? 'checkmark-circle' : 'alert-circle'\"></ion-icon>\n                        Base data coverage: {{ coveragePercent }}%\n                    </p>\n                    <p *ngIf=\"!baseCumulatives\" class=\"coverage-error\">\n                        <ion-icon name=\"alert-circle\"></ion-icon>\n                        No base cumulatives available\n                    </p>\n                </div>\n\n                <!-- Creation progress -->\n                <div *ngIf=\"creating\" class=\"creation-progress\">\n                    <ion-spinner name=\"crescent\"></ion-spinner>\n                    <span>{{ creationProgress }}</span>\n                </div>\n\n                <ion-button [disabled]=\"!canCreateNew || creating\"\n                            expand=\"block\"\n                            (click)=\"createNewPeriod()\">\n                    <ion-icon name=\"add-circle-outline\" slot=\"start\"></ion-icon>\n                    Create {{ formatWindow(currentWindowMinutes) }} Cumulative\n                </ion-button>\n\n                <p *ngIf=\"!canCreateNew && !creating\" class=\"create-hint\">\n                    Create is disabled because base 5-min cumulatives don't fully cover the selected period.\n                </p>\n            </div>\n        </div>\n\n        <div class=\"modal-footer\">\n            <ion-button fill=\"outline\" (click)=\"cancel()\" [disabled]=\"creating\">\n                Cancel\n            </ion-button>\n        </div>\n    </div>\n</div>\n", styles: [".cumulative-selector-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,.5);display:flex;align-items:center;justify-content:center;z-index:1000}.cumulative-selector-modal{background:var(--ion-background-color, #fff);border-radius:12px;max-width:500px;width:90%;max-height:80vh;display:flex;flex-direction:column;box-shadow:0 4px 20px #0000004d}.modal-header{display:flex;justify-content:space-between;align-items:center;padding:16px 20px;border-bottom:1px solid var(--ion-border-color, #ddd)}.modal-header h2{margin:0;font-size:1.25rem;font-weight:600}.modal-header ion-button{--padding-start: 8px;--padding-end: 8px}.modal-content{flex:1;overflow-y:auto;padding:16px 20px}.loading-state{display:flex;flex-direction:column;align-items:center;padding:40px 0}.loading-state ion-spinner{margin-bottom:16px}.loading-state p{color:var(--ion-color-medium)}.error-message{display:flex;align-items:center;gap:8px;padding:12px;background:var(--ion-color-danger-tint);color:var(--ion-color-danger);border-radius:8px;margin-bottom:16px}.error-message ion-icon{font-size:1.25rem}.periods-section{margin-bottom:24px}.periods-section h3{font-size:1rem;font-weight:600;margin-bottom:12px;color:var(--ion-color-dark)}.periods-section ion-list{border-radius:8px;overflow:hidden}.periods-section ion-item{--padding-start: 12px;--padding-end: 12px}.periods-section ion-item ion-label h2{font-weight:500}.periods-section ion-item ion-label p{font-size:.85rem;color:var(--ion-color-medium)}.periods-section ion-item ion-label .count-info{font-size:.75rem;color:var(--ion-color-primary)}.no-periods{display:flex;flex-direction:column;align-items:center;padding:24px;text-align:center;color:var(--ion-color-medium)}.no-periods ion-icon{font-size:2rem;margin-bottom:8px}.create-section{border-top:1px solid var(--ion-border-color, #ddd);padding-top:16px}.create-section h3{font-size:1rem;font-weight:600;margin-bottom:12px;color:var(--ion-color-dark)}.create-section .create-info{background:var(--ion-color-light);padding:12px;border-radius:8px;margin-bottom:16px}.create-section .create-info p{margin:4px 0;font-size:.9rem}.create-section .coverage-info{display:flex;align-items:center;gap:6px}.create-section .coverage-info ion-icon{font-size:1.1rem}.create-section .coverage-ok{color:var(--ion-color-success)}.create-section .coverage-warn{color:var(--ion-color-warning)}.create-section .coverage-error{color:var(--ion-color-danger)}.create-section .creation-progress{display:flex;align-items:center;gap:12px;padding:16px;background:var(--ion-color-primary-tint);border-radius:8px;margin-bottom:16px}.create-section .creation-progress ion-spinner{--color: var(--ion-color-primary)}.create-section .creation-progress span{color:var(--ion-color-primary);font-size:.9rem}.create-section .create-hint{font-size:.8rem;color:var(--ion-color-medium);text-align:center;margin-top:8px}.modal-footer{padding:16px 20px;border-top:1px solid var(--ion-border-color, #ddd);display:flex;justify-content:flex-end}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ProfileService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { rainId: [{
+                type: Input
+            }], currentPeriodBegin: [{
+                type: Input
+            }], currentPeriodEnd: [{
+                type: Input
+            }], provider: [{
+                type: Input
+            }], timeStepInMinutes: [{
+                type: Input
+            }], isAdmin: [{
+                type: Input
+            }], periodSelected: [{
+                type: Output
+            }], cancelled: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cumulative-selector.component.js","sourceRoot":"","sources":["../../../src/core/shared/cumulative-selector/cumulative-selector.component.ts","../../../src/core/shared/cumulative-selector/cumulative-selector.component.html"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EAEvB,SAAS,EACT,YAAY,EACZ,KAAK,EAEL,MAAM,GACT,MAAM,eAAe,CAAC;;;;;AAgBvB,MAAM,OAAO,2BAA2B;IAyBpC,YACY,cAA8B,EAC9B,GAAsB;QADtB,mBAAc,GAAd,cAAc,CAAgB;QAC9B,QAAG,GAAH,GAAG,CAAmB;QAtBzB,sBAAiB,GAAW,CAAC,CAAC;QAC9B,YAAO,GAAY,KAAK,CAAC;QAExB,mBAAc,GAAG,IAAI,YAAY,EAAuB,CAAC;QACzD,cAAS,GAAG,IAAI,YAAY,EAAQ,CAAC;QAE/C,qBAAgB,GAAuB,EAAE,CAAC;QAC1C,oBAAe,GAAqB,IAAI,CAAC;QACzC,YAAO,GAAG,IAAI,CAAC;QACf,aAAQ,GAAG,KAAK,CAAC;QACjB,qBAAgB,GAAG,EAAE,CAAC;QACtB,iBAAY,GAAG,EAAE,CAAC;QAElB,oBAAe,GAAG,CAAC,CAAC;QACpB,iBAAY,GAAG,KAAK,CAAC;QACrB,yBAAoB,GAAG,CAAC,CAAC;QAER,oBAAe,GAAG,MAAM,CAAC,CAAC,cAAc;QACxC,qBAAgB,GAAG,IAAI,CAAC;IAKtC,CAAC;IAEJ,KAAK,CAAC,QAAQ;QACV,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAClC,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,CAChF,CAAC;QACF,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,oBAAoB;QACtB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAExB,IAAI;YACA,uFAAuF;YACvF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,EAAE;gBACzE,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,MAAM,EAAE,IAAI,CAAC,OAAO;aACvB,CAAC,CAAC;YAEH,sDAAsD;YACtD,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,GAAG,CAAC,CAAC,CAAC;YAE9E,sDAAsD;YACtD,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,KAAK,CAAC,CAAC,CAAC;YAE7E,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC5B;QAAC,OAAO,CAAC,EAAE;YACR,IAAI,CAAC,YAAY,GAAG,mCAAmC,CAAC;YACxD,OAAO,CAAC,KAAK,CAAC,mCAAmC,EAAE,CAAC,CAAC,CAAC;SACzD;QAED,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC5B,CAAC;IAED,iBAAiB;QACb,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACvB,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC;YACzB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAC1B,OAAO;SACV;QAED,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;QAC7D,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAEzD,kDAAkD;QAClD,MAAM,cAAc,GAChB,IAAI,CAAC,kBAAkB,IAAI,SAAS,IAAI,IAAI,CAAC,gBAAgB,IAAI,OAAO,CAAC;QAE7E,IAAI,CAAC,cAAc,EAAE;YACjB,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC;YACzB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAC1B,OAAO;SACV;QAED,uDAAuD;QACvD,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAEpF,yCAAyC;QACzC,yEAAyE;QACzE,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK,IAAI,aAAa,EAAE;YAC7C,IAAI,CAAC,eAAe,GAAG,GAAG,CAAC;YAC3B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;SAC5B;aAAM;YACH,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,GAAG,aAAa,CAAC,GAAG,GAAG,CAAC,CAAC;YACtF,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,IAAI,GAAG,CAAC;SACnD;IACL,CAAC;IAED,YAAY,CAAC,MAAwB;QACjC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;YACrB,WAAW,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;YACzC,SAAS,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;YACrC,eAAe,EAAE,MAAM,CAAC,eAAe;SAC1C,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,eAAe;QACjB,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,QAAQ,EAAE;YACrC,OAAO;SACV;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,gBAAgB,GAAG,oCAAoC,CAAC;QAC7D,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAExB,IAAI;YACA,8BAA8B;YAC9B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,sBAAsB,CAAC,IAAI,CAAC,MAAM,EAAE;gBACzE,WAAW,EAAE,IAAI,CAAC,kBAAkB;gBACpC,SAAS,EAAE,IAAI,CAAC,gBAAgB;gBAChC,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;aAC5C,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,EAAE;gBACT,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;aAC/D;YAED,IAAI,CAAC,gBAAgB,GAAG,wCAAwC,CAAC;YACjE,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;YAExB,sBAAsB;YACtB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAE/C,IAAI,OAAO,EAAE;gBACT,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;oBACrB,WAAW,EAAE,IAAI,CAAC,kBAAkB;oBACpC,SAAS,EAAE,IAAI,CAAC,gBAAgB;oBAChC,eAAe,EAAE,IAAI,CAAC,oBAAoB;iBAC7C,CAAC,CAAC;aACN;iBAAM;gBACH,IAAI,CAAC,YAAY,GAAG,4CAA4C,CAAC;aACpE;SACJ;QAAC,OAAO,CAAC,EAAE;YACR,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,CAAC,OAAO,IAAI,eAAe,EAAE,CAAC;YAC7D,OAAO,CAAC,KAAK,CAAC,4BAA4B,EAAE,CAAC,CAAC,CAAC;SAClD;QAED,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC5B,CAAC;IAEO,KAAK,CAAC,iBAAiB;QAC3B,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,IAAI,CAAC,eAAe,EAAE;YAClD,IAAI;gBACA,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAExE,IAAI,QAAQ,KAAK,CAAC,EAAE;oBAChB,0EAA0E;oBAC1E,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,EAAE;wBACzE,QAAQ,EAAE,IAAI,CAAC,QAAQ;wBACvB,eAAe,EAAE,IAAI,CAAC,oBAAoB;wBAC1C,MAAM,EAAE,IAAI,CAAC,OAAO;qBACvB,CAAC,CAAC;oBAEH,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAC/B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,KAAK,IAAI,CAAC,oBAAoB,CACzD,CAAC;oBAEF,IAAI,KAAK,EAAE;wBACP,OAAO,IAAI,CAAC;qBACf;iBACJ;gBAED,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,CAAC;gBAC5D,IAAI,CAAC,gBAAgB,GAAG,iBAAiB,OAAO,aAAa,QAAQ,GAAG,CAAC;gBACzE,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;gBAExB,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;aAC3C;YAAC,OAAO,CAAC,EAAE;gBACR,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;gBAC/B,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;aAC3C;SACJ;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;IAEO,KAAK,CAAC,EAAU;QACpB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED,MAAM;QACF,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IAED,YAAY,CAAC,MAAwB;QACjC,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC3C,MAAM,GAAG,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACvC,OAAO,GAAG,KAAK,CAAC,cAAc,EAAE,MAAM,GAAG,CAAC,cAAc,EAAE,EAAE,CAAC;IACjE,CAAC;IAED,YAAY,CAAC,OAAe;QACxB,IAAI,OAAO,GAAG,EAAE,EAAE;YACd,OAAO,GAAG,OAAO,MAAM,CAAC;SAC3B;QACD,MAAM,KAAK,GAAG,OAAO,GAAG,EAAE,CAAC;QAC3B,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,QAAQ,CAAC;IACrD,CAAC;;yHApNQ,2BAA2B;6GAA3B,2BAA2B,kUCxBxC,ghJAiGA;4FDzEa,2BAA2B;kBANvC,SAAS;+BACI,qBAAqB,mBAGd,uBAAuB,CAAC,MAAM;qIAGtC,MAAM;sBAAd,KAAK;gBACG,kBAAkB;sBAA1B,KAAK;gBACG,gBAAgB;sBAAxB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,iBAAiB;sBAAzB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBAEI,cAAc;sBAAvB,MAAM;gBACG,SAAS;sBAAlB,MAAM","sourcesContent":["import {\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    EventEmitter,\n    Input,\n    OnInit,\n    Output,\n} from '@angular/core';\nimport {ProfileService} from '../profile.service';\nimport {CumulativePeriod} from 'raain-model';\n\nexport interface CumulativeSelection {\n    periodBegin: Date;\n    periodEnd: Date;\n    windowInMinutes: number;\n}\n\n@Component({\n    selector: 'cumulative-selector',\n    templateUrl: './cumulative-selector.component.html',\n    styleUrls: ['./cumulative-selector.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CumulativeSelectorComponent implements OnInit {\n    @Input() rainId: string;\n    @Input() currentPeriodBegin: Date;\n    @Input() currentPeriodEnd: Date;\n    @Input() provider: string;\n    @Input() timeStepInMinutes: number = 5;\n    @Input() isAdmin: boolean = false;\n\n    @Output() periodSelected = new EventEmitter<CumulativeSelection>();\n    @Output() cancelled = new EventEmitter<void>();\n\n    availablePeriods: CumulativePeriod[] = [];\n    baseCumulatives: CumulativePeriod = null;\n    loading = true;\n    creating = false;\n    creationProgress = '';\n    errorMessage = '';\n\n    coveragePercent = 0;\n    canCreateNew = false;\n    currentWindowMinutes = 0;\n\n    private readonly POLL_TIMEOUT_MS = 900000; // 900 seconds\n    private readonly POLL_INTERVAL_MS = 3000;\n\n    constructor(\n        private profileService: ProfileService,\n        private cdr: ChangeDetectorRef\n    ) {}\n\n    async ngOnInit() {\n        this.currentWindowMinutes = Math.round(\n            (this.currentPeriodEnd.getTime() - this.currentPeriodBegin.getTime()) / 60000\n        );\n        await this.loadAvailablePeriods();\n    }\n\n    async loadAvailablePeriods() {\n        this.loading = true;\n        this.errorMessage = '';\n        this.cdr.markForCheck();\n\n        try {\n            // Fetch all cumulative periods (admin sees all, non-admin sees only customer-launched)\n            const response = await this.profileService.getCumulativePeriods(this.rainId, {\n                provider: this.provider,\n                forced: this.isAdmin,\n            });\n\n            // Filter for existing custom cumulatives (window > 0)\n            this.availablePeriods = response.periods.filter((p) => p.windowInMinutes > 0);\n\n            // Get base cumulatives (window = 0) to check coverage\n            this.baseCumulatives = response.periods.find((p) => p.windowInMinutes === 0);\n\n            this.calculateCoverage();\n        } catch (e) {\n            this.errorMessage = 'Failed to load cumulative periods';\n            console.error('Error loading cumulative periods:', e);\n        }\n\n        this.loading = false;\n        this.cdr.markForCheck();\n    }\n\n    calculateCoverage() {\n        if (!this.baseCumulatives) {\n            this.coveragePercent = 0;\n            this.canCreateNew = false;\n            return;\n        }\n\n        const baseBegin = new Date(this.baseCumulatives.periodBegin);\n        const baseEnd = new Date(this.baseCumulatives.periodEnd);\n\n        // Check if current period is within base coverage\n        const currentInRange =\n            this.currentPeriodBegin >= baseBegin && this.currentPeriodEnd <= baseEnd;\n\n        if (!currentInRange) {\n            this.coveragePercent = 0;\n            this.canCreateNew = false;\n            return;\n        }\n\n        // Calculate expected number of base cumulatives needed\n        const expectedCount = Math.ceil(this.currentWindowMinutes / this.timeStepInMinutes);\n\n        // Check if enough base cumulatives exist\n        // We assume coverage is complete if count >= expected (simplified check)\n        if (this.baseCumulatives.count >= expectedCount) {\n            this.coveragePercent = 100;\n            this.canCreateNew = true;\n        } else {\n            this.coveragePercent = Math.round((this.baseCumulatives.count / expectedCount) * 100);\n            this.canCreateNew = this.coveragePercent >= 100;\n        }\n    }\n\n    selectPeriod(period: CumulativePeriod) {\n        this.periodSelected.emit({\n            periodBegin: new Date(period.periodBegin),\n            periodEnd: new Date(period.periodEnd),\n            windowInMinutes: period.windowInMinutes,\n        });\n    }\n\n    async createNewPeriod() {\n        if (!this.canCreateNew || this.creating) {\n            return;\n        }\n\n        this.creating = true;\n        this.creationProgress = 'Starting cumulative computation...';\n        this.errorMessage = '';\n        this.cdr.markForCheck();\n\n        try {\n            // Trigger cumulative creation\n            const result = await this.profileService.createCumulativePeriod(this.rainId, {\n                periodBegin: this.currentPeriodBegin,\n                periodEnd: this.currentPeriodEnd,\n                provider: this.provider,\n                timeStepInMinutes: this.timeStepInMinutes,\n            });\n\n            if (!result) {\n                throw new Error('Failed to trigger cumulative computation');\n            }\n\n            this.creationProgress = `Jobs queued. Polling for completion...`;\n            this.cdr.markForCheck();\n\n            // Poll for completion\n            const success = await this.pollForCompletion();\n\n            if (success) {\n                this.periodSelected.emit({\n                    periodBegin: this.currentPeriodBegin,\n                    periodEnd: this.currentPeriodEnd,\n                    windowInMinutes: this.currentWindowMinutes,\n                });\n            } else {\n                this.errorMessage = 'Timeout waiting for cumulative computation';\n            }\n        } catch (e) {\n            this.errorMessage = `Error: ${e.message || 'Unknown error'}`;\n            console.error('Error creating cumulative:', e);\n        }\n\n        this.creating = false;\n        this.cdr.markForCheck();\n    }\n\n    private async pollForCompletion(): Promise<boolean> {\n        const startTime = Date.now();\n\n        while (Date.now() - startTime < this.POLL_TIMEOUT_MS) {\n            try {\n                const progress = await this.profileService.getRainProgress(this.rainId);\n\n                if (progress === 0) {\n                    // Queue is empty, check if cumulative exists (admin sees all cumulatives)\n                    const response = await this.profileService.getCumulativePeriods(this.rainId, {\n                        provider: this.provider,\n                        windowInMinutes: this.currentWindowMinutes,\n                        forced: this.isAdmin,\n                    });\n\n                    const found = response.periods.find(\n                        (p) => p.windowInMinutes === this.currentWindowMinutes\n                    );\n\n                    if (found) {\n                        return true;\n                    }\n                }\n\n                const elapsed = Math.round((Date.now() - startTime) / 1000);\n                this.creationProgress = `Computing... (${elapsed}s, queue: ${progress})`;\n                this.cdr.markForCheck();\n\n                await this.sleep(this.POLL_INTERVAL_MS);\n            } catch (e) {\n                console.warn('Poll error:', e);\n                await this.sleep(this.POLL_INTERVAL_MS);\n            }\n        }\n\n        return false;\n    }\n\n    private sleep(ms: number): Promise<void> {\n        return new Promise((resolve) => setTimeout(resolve, ms));\n    }\n\n    cancel() {\n        this.cancelled.emit();\n    }\n\n    formatPeriod(period: CumulativePeriod): string {\n        const begin = new Date(period.periodBegin);\n        const end = new Date(period.periodEnd);\n        return `${begin.toLocaleString()} → ${end.toLocaleString()}`;\n    }\n\n    formatWindow(minutes: number): string {\n        if (minutes < 60) {\n            return `${minutes} min`;\n        }\n        const hours = minutes / 60;\n        return hours === 1 ? '1 hour' : `${hours} hours`;\n    }\n}\n","<div class=\"cumulative-selector-overlay\">\n    <div class=\"cumulative-selector-modal\">\n        <div class=\"modal-header\">\n            <h2>Select Cumulative Period</h2>\n            <ion-button fill=\"clear\" (click)=\"cancel()\">\n                <ion-icon name=\"close\"></ion-icon>\n            </ion-button>\n        </div>\n\n        <div class=\"modal-content\">\n            <!-- Loading state -->\n            <div *ngIf=\"loading\" class=\"loading-state\">\n                <ion-spinner name=\"crescent\"></ion-spinner>\n                <p>Loading available periods...</p>\n            </div>\n\n            <!-- Error message -->\n            <div *ngIf=\"errorMessage\" class=\"error-message\">\n                <ion-icon name=\"warning-outline\"></ion-icon>\n                <span>{{ errorMessage }}</span>\n            </div>\n\n            <!-- Available periods list -->\n            <div *ngIf=\"!loading && availablePeriods.length > 0\" class=\"periods-section\">\n                <h3>Available Cumulative Periods</h3>\n                <ion-list>\n                    <ion-item *ngFor=\"let period of availablePeriods\"\n                              button\n                              (click)=\"selectPeriod(period)\"\n                              [disabled]=\"creating\">\n                        <ion-icon name=\"layers-outline\" slot=\"start\"></ion-icon>\n                        <ion-label>\n                            <h2>{{ formatWindow(period.windowInMinutes) }}</h2>\n                            <p>{{ formatPeriod(period) }}</p>\n                            <p class=\"count-info\">{{ period.count }} cumulative(s)</p>\n                        </ion-label>\n                        <ion-icon name=\"chevron-forward\" slot=\"end\"></ion-icon>\n                    </ion-item>\n                </ion-list>\n            </div>\n\n            <!-- No periods available -->\n            <div *ngIf=\"!loading && availablePeriods.length === 0\" class=\"no-periods\">\n                <ion-icon name=\"information-circle-outline\"></ion-icon>\n                <p>No cumulative periods available yet.</p>\n            </div>\n\n            <!-- Create new section (admin only) -->\n            <div *ngIf=\"!loading && isAdmin\" class=\"create-section\">\n                <h3>Create New Cumulative</h3>\n                <div class=\"create-info\">\n                    <p>\n                        <strong>Period:</strong>\n                        {{ currentPeriodBegin?.toLocaleString() }} → {{ currentPeriodEnd?.toLocaleString() }}\n                    </p>\n                    <p>\n                        <strong>Window:</strong> {{ formatWindow(currentWindowMinutes) }}\n                    </p>\n                    <p *ngIf=\"baseCumulatives\" class=\"coverage-info\"\n                       [class.coverage-ok]=\"coveragePercent >= 100\"\n                       [class.coverage-warn]=\"coveragePercent > 0 && coveragePercent < 100\"\n                       [class.coverage-error]=\"coveragePercent === 0\">\n                        <ion-icon [name]=\"coveragePercent >= 100 ? 'checkmark-circle' : 'alert-circle'\"></ion-icon>\n                        Base data coverage: {{ coveragePercent }}%\n                    </p>\n                    <p *ngIf=\"!baseCumulatives\" class=\"coverage-error\">\n                        <ion-icon name=\"alert-circle\"></ion-icon>\n                        No base cumulatives available\n                    </p>\n                </div>\n\n                <!-- Creation progress -->\n                <div *ngIf=\"creating\" class=\"creation-progress\">\n                    <ion-spinner name=\"crescent\"></ion-spinner>\n                    <span>{{ creationProgress }}</span>\n                </div>\n\n                <ion-button [disabled]=\"!canCreateNew || creating\"\n                            expand=\"block\"\n                            (click)=\"createNewPeriod()\">\n                    <ion-icon name=\"add-circle-outline\" slot=\"start\"></ion-icon>\n                    Create {{ formatWindow(currentWindowMinutes) }} Cumulative\n                </ion-button>\n\n                <p *ngIf=\"!canCreateNew && !creating\" class=\"create-hint\">\n                    Create is disabled because base 5-min cumulatives don't fully cover the selected period.\n                </p>\n            </div>\n        </div>\n\n        <div class=\"modal-footer\">\n            <ion-button fill=\"outline\" (click)=\"cancel()\" [disabled]=\"creating\">\n                Cancel\n            </ion-button>\n        </div>\n    </div>\n</div>\n"]}

package/esm2020/index.mjs

@@ -7,6 +7,7 @@ export * from './raain-speed/raain-speed.component';
 export * from './raain-compare-stack/raain-compare-stack.component';
 export * from './raain-globe/raain-globe.component';
 export * from './raain-details/raain-details.component';
+export * from './cumulative-selector/cumulative-selector.component';
 export * from './tools';
 export * from './cache.service';
 export * from './fidj-storage.model';
@@ -19,4 +20,4 @@ export * from './storage.service';
 export * from './xytype';
 export * from './profile-icon.directive';
 export * from './pipes.module';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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