@algoux/standard-ranklist-renderer-component-angular 0.6.0 → 0.6.1

package/dist/esm2022/lib/modal/modal.component.mjs

@@ -0,0 +1,263 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { MODAL_ANIMATION_DURATION_MS, SRK_ANIMATED_MODAL_ROOT_CLASS, ensureModalInteractionTracker, lockModalBodyScroll, registerModalFocusScope, resolveModalTransformOrigin, unlockModalBodyScroll, unregisterModalFocusScope, } from './modal-interactions';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class ModalComponent {
+    open = false;
+    title;
+    width;
+    rootClassName;
+    wrapClassName;
+    destroyOnClose = true;
+    closeOnEsc = true;
+    closeOnMaskClick = true;
+    panelStyle = {};
+    openChange = new EventEmitter();
+    close = new EventEmitter();
+    dialogRef;
+    isMounted = this.open || !this.destroyOnClose;
+    animationState = this.open ? 'pre-open' : 'closing';
+    transformOrigin = { x: 0, y: 0 };
+    closeTimer = null;
+    openTimer = null;
+    bodyScrollLocked = false;
+    focusScopeId = null;
+    constructor() {
+        if (typeof document !== 'undefined') {
+            ensureModalInteractionTracker();
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['open'] || changes['destroyOnClose']) {
+            this.syncOpenState();
+        }
+    }
+    ngAfterViewChecked() {
+        if (this.open) {
+            this.registerFocusScope();
+        }
+    }
+    ngOnDestroy() {
+        this.clearTimers();
+        this.releaseFocusScope();
+        if (this.bodyScrollLocked) {
+            unlockModalBodyScroll();
+            this.bodyScrollLocked = false;
+        }
+    }
+    handleEscape(event) {
+        if (this.open && this.closeOnEsc) {
+            this.requestClose('escape');
+        }
+    }
+    handleMaskMouseDown(event) {
+        if (this.closeOnMaskClick && event.target === event.currentTarget) {
+            this.requestClose('mask');
+        }
+    }
+    requestClose(reason) {
+        this.openChange.emit(false);
+        this.close.emit(reason);
+    }
+    shouldRender() {
+        return this.isMounted || !this.destroyOnClose;
+    }
+    rootClasses() {
+        return [SRK_ANIMATED_MODAL_ROOT_CLASS, this.rootClassName].filter(Boolean);
+    }
+    dialogStyle() {
+        return {
+            ...this.panelStyle,
+            width: this.width ? `${this.width}px` : this.panelStyle?.['width'],
+            '--srk-modal-origin-x': `${this.transformOrigin.x}px`,
+            '--srk-modal-origin-y': `${this.transformOrigin.y}px`,
+            '--srk-modal-max-width': this.width
+                ? `${this.width}px`
+                : typeof this.panelStyle?.['width'] === 'string'
+                    ? this.panelStyle['width']
+                    : undefined,
+        };
+    }
+    clearTimers() {
+        if (this.closeTimer !== null) {
+            window.clearTimeout(this.closeTimer);
+            this.closeTimer = null;
+        }
+        if (this.openTimer !== null) {
+            window.clearTimeout(this.openTimer);
+            this.openTimer = null;
+        }
+    }
+    syncOpenState() {
+        this.clearTimers();
+        if (this.open) {
+            this.isMounted = true;
+            this.transformOrigin = { x: 0, y: 0 };
+            this.animationState = 'pre-open';
+            if (typeof window !== 'undefined') {
+                this.openTimer = window.setTimeout(() => {
+                    this.registerFocusScope();
+                    const resolution = resolveModalTransformOrigin(this.dialogRef?.nativeElement || null);
+                    this.transformOrigin = resolution.origin;
+                    this.animationState = 'opening';
+                    this.openTimer = null;
+                }, 0);
+            }
+        }
+        else {
+            this.releaseFocusScope();
+            this.animationState = 'closing';
+            if (!this.destroyOnClose) {
+                this.isMounted = true;
+            }
+            else if (this.isMounted && typeof window !== 'undefined') {
+                this.closeTimer = window.setTimeout(() => {
+                    this.isMounted = false;
+                    this.updateBodyScrollLock();
+                    this.closeTimer = null;
+                }, MODAL_ANIMATION_DURATION_MS);
+            }
+        }
+        this.updateBodyScrollLock();
+    }
+    updateBodyScrollLock() {
+        const shouldLock = this.open || (this.destroyOnClose && this.isMounted);
+        if (shouldLock && !this.bodyScrollLocked) {
+            lockModalBodyScroll();
+            this.bodyScrollLocked = true;
+            return;
+        }
+        if (!shouldLock && this.bodyScrollLocked) {
+            unlockModalBodyScroll();
+            this.bodyScrollLocked = false;
+        }
+    }
+    registerFocusScope() {
+        const nextFocusScopeId = registerModalFocusScope(this.dialogRef?.nativeElement || null, {
+            onEscape: this.closeOnEsc ? (event) => this.handleEscape(event) : undefined,
+        });
+        if (this.focusScopeId === null) {
+            this.focusScopeId = nextFocusScopeId;
+        }
+    }
+    releaseFocusScope() {
+        if (this.focusScopeId !== null) {
+            unregisterModalFocusScope(this.focusScopeId);
+            this.focusScopeId = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ModalComponent, isStandalone: true, selector: "srk-modal", inputs: { open: "open", title: "title", width: "width", rootClassName: "rootClassName", wrapClassName: "wrapClassName", destroyOnClose: "destroyOnClose", closeOnEsc: "closeOnEsc", closeOnMaskClick: "closeOnMaskClick", panelStyle: "panelStyle" }, outputs: { openChange: "openChange", close: "close" }, viewQueries: [{ propertyName: "dialogRef", first: true, predicate: ["dialog"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div *ngIf="shouldRender()" class="srk-modal-root" [ngClass]="rootClasses()" [attr.data-srk-modal-state]="animationState">
+      <div class="srk-modal-mask"></div>
+      <div
+        class="srk-modal-wrap"
+        [ngClass]="wrapClassName"
+        tabindex="-1"
+        (mousedown)="handleMaskMouseDown($event)"
+      >
+        <div
+          #dialog
+          class="srk-modal"
+          role="dialog"
+          aria-modal="true"
+          [attr.aria-label]="title || undefined"
+          data-srk-modal-panel="true"
+          tabindex="-1"
+          [ngStyle]="dialogStyle()"
+        >
+          <div class="srk-modal-content">
+            <button
+              aria-label="Close"
+              class="srk-modal-close"
+              type="button"
+              (click)="requestClose('close-button')"
+            >
+              <span class="srk-modal-close-x"></span>
+            </button>
+            <div *ngIf="title !== undefined" class="srk-modal-header">
+              <div class="srk-modal-title">{{ title }}</div>
+            </div>
+            <div class="srk-modal-body">
+              <ng-content />
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'srk-modal',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <div *ngIf="shouldRender()" class="srk-modal-root" [ngClass]="rootClasses()" [attr.data-srk-modal-state]="animationState">
+      <div class="srk-modal-mask"></div>
+      <div
+        class="srk-modal-wrap"
+        [ngClass]="wrapClassName"
+        tabindex="-1"
+        (mousedown)="handleMaskMouseDown($event)"
+      >
+        <div
+          #dialog
+          class="srk-modal"
+          role="dialog"
+          aria-modal="true"
+          [attr.aria-label]="title || undefined"
+          data-srk-modal-panel="true"
+          tabindex="-1"
+          [ngStyle]="dialogStyle()"
+        >
+          <div class="srk-modal-content">
+            <button
+              aria-label="Close"
+              class="srk-modal-close"
+              type="button"
+              (click)="requestClose('close-button')"
+            >
+              <span class="srk-modal-close-x"></span>
+            </button>
+            <div *ngIf="title !== undefined" class="srk-modal-header">
+              <div class="srk-modal-title">{{ title }}</div>
+            </div>
+            <div class="srk-modal-body">
+              <ng-content />
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  `,
+                }]
+        }], ctorParameters: () => [], propDecorators: { open: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], rootClassName: [{
+                type: Input
+            }], wrapClassName: [{
+                type: Input
+            }], destroyOnClose: [{
+                type: Input
+            }], closeOnEsc: [{
+                type: Input
+            }], closeOnMaskClick: [{
+                type: Input
+            }], panelStyle: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }], close: [{
+                type: Output
+            }], dialogRef: [{
+                type: ViewChild,
+                args: ['dialog']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.component.js","sourceRoot":"","sources":["../../../../src/lib/modal/modal.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAEL,SAAS,EAET,YAAY,EACZ,KAAK,EAGL,MAAM,EAEN,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,2BAA2B,EAC3B,6BAA6B,EAC7B,6BAA6B,EAC7B,mBAAmB,EACnB,uBAAuB,EACvB,2BAA2B,EAC3B,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;;;AAgD9B,MAAM,OAAO,cAAc;IAChB,IAAI,GAAG,KAAK,CAAC;IACb,KAAK,CAAU;IACf,KAAK,CAAU;IACf,aAAa,CAAU;IACvB,aAAa,CAAU;IACvB,cAAc,GAAG,IAAI,CAAC;IACtB,UAAU,GAAG,IAAI,CAAC;IAClB,gBAAgB,GAAG,IAAI,CAAC;IACxB,UAAU,GAAoC,EAAE,CAAC;IAEhD,UAAU,GAAG,IAAI,YAAY,EAAW,CAAC;IACzC,KAAK,GAAG,IAAI,YAAY,EAAoB,CAAC;IAElC,SAAS,CAA8B;IAE5D,SAAS,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC;IAC9C,cAAc,GAAuC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;IACxF,eAAe,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;IACzB,UAAU,GAAkB,IAAI,CAAC;IACjC,SAAS,GAAkB,IAAI,CAAC;IAChC,gBAAgB,GAAG,KAAK,CAAC;IACzB,YAAY,GAAkB,IAAI,CAAC;IAE3C;QACE,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;YACpC,6BAA6B,EAAE,CAAC;QAClC,CAAC;IACH,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;YACjD,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,CAAC;IACH,CAAC;IAED,kBAAkB;QAChB,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,qBAAqB,EAAE,CAAC;YACxB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAChC,CAAC;IACH,CAAC;IAED,YAAY,CAAC,KAAqB;QAChC,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACjC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,mBAAmB,CAAC,KAAiB;QACnC,IAAI,IAAI,CAAC,gBAAgB,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,aAAa,EAAE,CAAC;YAClE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,YAAY,CAAC,MAAwB;QACnC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC;IAChD,CAAC;IAED,WAAW;QACT,OAAO,CAAC,6BAA6B,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7E,CAAC;IAED,WAAW;QACT,OAAO;YACL,GAAG,IAAI,CAAC,UAAU;YAClB,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC;YAClE,sBAAsB,EAAE,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,IAAI;YACrD,sBAAsB,EAAE,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,IAAI;YACrD,uBAAuB,EAAE,IAAI,CAAC,KAAK;gBACjC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,IAAI;gBACnB,CAAC,CAAC,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ;oBAC9C,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;oBAC1B,CAAC,CAAC,SAAS;SAChB,CAAC;IACJ,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAC7B,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACrC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACzB,CAAC;QACD,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;YAC5B,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACpC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC;IACH,CAAC;IAEO,aAAa;QACnB,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;YACtC,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC;YACjC,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;gBAClC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;oBACtC,IAAI,CAAC,kBAAkB,EAAE,CAAC;oBAC1B,MAAM,UAAU,GAAG,2BAA2B,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,IAAI,IAAI,CAAC,CAAC;oBACtF,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC,MAAM,CAAC;oBACzC,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;oBAChC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;gBACxB,CAAC,EAAE,CAAC,CAAC,CAAC;YACR,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;YAChC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;gBACzB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACxB,CAAC;iBAAM,IAAI,IAAI,CAAC,SAAS,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;gBAC3D,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;oBACvC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;oBACvB,IAAI,CAAC,oBAAoB,EAAE,CAAC;oBAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACzB,CAAC,EAAE,2BAA2B,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;QAED,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAEO,oBAAoB;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;QACxE,IAAI,UAAU,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACzC,mBAAmB,EAAE,CAAC;YACtB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAC7B,OAAO;QACT,CAAC;QACD,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACzC,qBAAqB,EAAE,CAAC;YACxB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAChC,CAAC;IACH,CAAC;IAEO,kBAAkB;QACxB,MAAM,gBAAgB,GAAG,uBAAuB,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,IAAI,IAAI,EAAE;YACtF,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS;SAC5E,CAAC,CAAC;QACH,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;YAC/B,IAAI,CAAC,YAAY,GAAG,gBAAgB,CAAC;QACvC,CAAC;IACH,CAAC;IAEO,iBAAiB;QACvB,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;YAC/B,yBAAyB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC7C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC3B,CAAC;IACH,CAAC;wGAjKU,cAAc;4FAAd,cAAc,4eAxCf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCT,2DAvCS,YAAY;;4FAyCX,cAAc;kBA5C1B,SAAS;mBAAC;oBACT,QAAQ,EAAE,WAAW;oBACrB,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,YAAY,CAAC;oBACvB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCT;iBACF;wDAEU,IAAI;sBAAZ,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,gBAAgB;sBAAxB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBAEI,UAAU;sBAAnB,MAAM;gBACG,KAAK;sBAAd,MAAM;gBAEc,SAAS;sBAA7B,SAAS;uBAAC,QAAQ","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  AfterViewChecked,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport {\n  MODAL_ANIMATION_DURATION_MS,\n  SRK_ANIMATED_MODAL_ROOT_CLASS,\n  ensureModalInteractionTracker,\n  lockModalBodyScroll,\n  registerModalFocusScope,\n  resolveModalTransformOrigin,\n  unlockModalBodyScroll,\n  unregisterModalFocusScope,\n} from './modal-interactions';\n\nexport type ModalCloseReason = 'mask' | 'close-button' | 'escape';\n\n@Component({\n  selector: 'srk-modal',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div *ngIf=\"shouldRender()\" class=\"srk-modal-root\" [ngClass]=\"rootClasses()\" [attr.data-srk-modal-state]=\"animationState\">\n      <div class=\"srk-modal-mask\"></div>\n      <div\n        class=\"srk-modal-wrap\"\n        [ngClass]=\"wrapClassName\"\n        tabindex=\"-1\"\n        (mousedown)=\"handleMaskMouseDown($event)\"\n      >\n        <div\n          #dialog\n          class=\"srk-modal\"\n          role=\"dialog\"\n          aria-modal=\"true\"\n          [attr.aria-label]=\"title || undefined\"\n          data-srk-modal-panel=\"true\"\n          tabindex=\"-1\"\n          [ngStyle]=\"dialogStyle()\"\n        >\n          <div class=\"srk-modal-content\">\n            <button\n              aria-label=\"Close\"\n              class=\"srk-modal-close\"\n              type=\"button\"\n              (click)=\"requestClose('close-button')\"\n            >\n              <span class=\"srk-modal-close-x\"></span>\n            </button>\n            <div *ngIf=\"title !== undefined\" class=\"srk-modal-header\">\n              <div class=\"srk-modal-title\">{{ title }}</div>\n            </div>\n            <div class=\"srk-modal-body\">\n              <ng-content />\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n  `,\n})\nexport class ModalComponent implements AfterViewChecked, OnChanges, OnDestroy {\n  @Input() open = false;\n  @Input() title?: string;\n  @Input() width?: number;\n  @Input() rootClassName?: string;\n  @Input() wrapClassName?: string;\n  @Input() destroyOnClose = true;\n  @Input() closeOnEsc = true;\n  @Input() closeOnMaskClick = true;\n  @Input() panelStyle: Record<string, string | number> = {};\n\n  @Output() openChange = new EventEmitter<boolean>();\n  @Output() close = new EventEmitter<ModalCloseReason>();\n\n  @ViewChild('dialog') dialogRef?: ElementRef<HTMLDivElement>;\n\n  isMounted = this.open || !this.destroyOnClose;\n  animationState: 'pre-open' | 'opening' | 'closing' = this.open ? 'pre-open' : 'closing';\n  transformOrigin = { x: 0, y: 0 };\n  private closeTimer: number | null = null;\n  private openTimer: number | null = null;\n  private bodyScrollLocked = false;\n  private focusScopeId: number | null = null;\n\n  constructor() {\n    if (typeof document !== 'undefined') {\n      ensureModalInteractionTracker();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['open'] || changes['destroyOnClose']) {\n      this.syncOpenState();\n    }\n  }\n\n  ngAfterViewChecked() {\n    if (this.open) {\n      this.registerFocusScope();\n    }\n  }\n\n  ngOnDestroy() {\n    this.clearTimers();\n    this.releaseFocusScope();\n    if (this.bodyScrollLocked) {\n      unlockModalBodyScroll();\n      this.bodyScrollLocked = false;\n    }\n  }\n\n  handleEscape(event?: KeyboardEvent) {\n    if (this.open && this.closeOnEsc) {\n      this.requestClose('escape');\n    }\n  }\n\n  handleMaskMouseDown(event: MouseEvent) {\n    if (this.closeOnMaskClick && event.target === event.currentTarget) {\n      this.requestClose('mask');\n    }\n  }\n\n  requestClose(reason: ModalCloseReason) {\n    this.openChange.emit(false);\n    this.close.emit(reason);\n  }\n\n  shouldRender() {\n    return this.isMounted || !this.destroyOnClose;\n  }\n\n  rootClasses() {\n    return [SRK_ANIMATED_MODAL_ROOT_CLASS, this.rootClassName].filter(Boolean);\n  }\n\n  dialogStyle() {\n    return {\n      ...this.panelStyle,\n      width: this.width ? `${this.width}px` : this.panelStyle?.['width'],\n      '--srk-modal-origin-x': `${this.transformOrigin.x}px`,\n      '--srk-modal-origin-y': `${this.transformOrigin.y}px`,\n      '--srk-modal-max-width': this.width\n        ? `${this.width}px`\n        : typeof this.panelStyle?.['width'] === 'string'\n          ? this.panelStyle['width']\n          : undefined,\n    };\n  }\n\n  private clearTimers() {\n    if (this.closeTimer !== null) {\n      window.clearTimeout(this.closeTimer);\n      this.closeTimer = null;\n    }\n    if (this.openTimer !== null) {\n      window.clearTimeout(this.openTimer);\n      this.openTimer = null;\n    }\n  }\n\n  private syncOpenState() {\n    this.clearTimers();\n\n    if (this.open) {\n      this.isMounted = true;\n      this.transformOrigin = { x: 0, y: 0 };\n      this.animationState = 'pre-open';\n      if (typeof window !== 'undefined') {\n        this.openTimer = window.setTimeout(() => {\n          this.registerFocusScope();\n          const resolution = resolveModalTransformOrigin(this.dialogRef?.nativeElement || null);\n          this.transformOrigin = resolution.origin;\n          this.animationState = 'opening';\n          this.openTimer = null;\n        }, 0);\n      }\n    } else {\n      this.releaseFocusScope();\n      this.animationState = 'closing';\n      if (!this.destroyOnClose) {\n        this.isMounted = true;\n      } else if (this.isMounted && typeof window !== 'undefined') {\n        this.closeTimer = window.setTimeout(() => {\n          this.isMounted = false;\n          this.updateBodyScrollLock();\n          this.closeTimer = null;\n        }, MODAL_ANIMATION_DURATION_MS);\n      }\n    }\n\n    this.updateBodyScrollLock();\n  }\n\n  private updateBodyScrollLock() {\n    const shouldLock = this.open || (this.destroyOnClose && this.isMounted);\n    if (shouldLock && !this.bodyScrollLocked) {\n      lockModalBodyScroll();\n      this.bodyScrollLocked = true;\n      return;\n    }\n    if (!shouldLock && this.bodyScrollLocked) {\n      unlockModalBodyScroll();\n      this.bodyScrollLocked = false;\n    }\n  }\n\n  private registerFocusScope() {\n    const nextFocusScopeId = registerModalFocusScope(this.dialogRef?.nativeElement || null, {\n      onEscape: this.closeOnEsc ? (event) => this.handleEscape(event) : undefined,\n    });\n    if (this.focusScopeId === null) {\n      this.focusScopeId = nextFocusScopeId;\n    }\n  }\n\n  private releaseFocusScope() {\n    if (this.focusScopeId !== null) {\n      unregisterModalFocusScope(this.focusScopeId);\n      this.focusScopeId = null;\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/progress/progress-bar.component.mjs

@@ -0,0 +1,247 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, Input, Output, } from '@angular/core';
+import { secToTimeStr } from '@algoux/standard-ranklist-utils';
+import { getProgressDurationMinutes, getProgressMaxAvailableMinutes, getProgressMetrics, isProgressEnded, } from './progress-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class ProgressBarComponent {
+    data;
+    enableTimeTravel = false;
+    live = false;
+    td = 0;
+    timeTravel = new EventEmitter();
+    localTime = Date.now();
+    inTimeMachine = false;
+    timeTravelIsChanging = false;
+    timeTravelCurrentValue = 0;
+    timeTravelValue = null;
+    liveInterval;
+    ngOnInit() {
+        this.timeTravelCurrentValue = this.maxAvailableMinutes();
+        if (this.live) {
+            this.liveInterval = window.setInterval(() => this.handleProgressTimer(), 1000);
+        }
+    }
+    ngOnDestroy() {
+        if (this.liveInterval) {
+            window.clearInterval(this.liveInterval);
+        }
+    }
+    secToTimeStr(seconds) {
+        return secToTimeStr(Math.round(seconds));
+    }
+    timeLabel(minutes) {
+        return secToTimeStr(minutes * 60);
+    }
+    durationMinutes() {
+        return getProgressDurationMinutes(this.data.contest);
+    }
+    maxAvailableMinutes() {
+        return getProgressMaxAvailableMinutes(this.data.contest, this.localTime, this.td);
+    }
+    isEnded() {
+        return isProgressEnded(this.data.contest, this.localTime, this.td);
+    }
+    progressMetrics() {
+        return getProgressMetrics(this.data, this.localTime, this.td, this.timeTravelCurrentValue, this.inTimeMachine);
+    }
+    beginTimeTravel() {
+        this.timeTravelIsChanging = true;
+        this.inTimeMachine = true;
+    }
+    updateTimeTravelValue(event) {
+        this.timeTravelCurrentValue = Number(event.target.value);
+    }
+    commitTimeTravel() {
+        if (this.timeTravelIsChanging) {
+            this.handleTimeTravelChange(this.timeTravelCurrentValue);
+        }
+    }
+    handleProgressTimer() {
+        this.localTime = Date.now();
+        if (this.isEnded() && this.liveInterval) {
+            window.clearInterval(this.liveInterval);
+        }
+        if (!this.timeTravelIsChanging && this.timeTravelValue === null) {
+            this.timeTravelCurrentValue = this.maxAvailableMinutes();
+        }
+    }
+    handleTimeTravelChange(value) {
+        const exited = value >= this.durationMinutes() || value >= this.maxAvailableMinutes();
+        this.timeTravel.emit(exited ? null : value * 60 * 1000);
+        this.inTimeMachine = !exited;
+        this.timeTravelValue = exited ? null : value * 60 * 1000;
+        this.timeTravelIsChanging = false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProgressBarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ProgressBarComponent, isStandalone: true, selector: "srk-progress-bar", inputs: { data: "data", enableTimeTravel: "enableTimeTravel", live: "live", td: "td" }, outputs: { timeTravel: "timeTravel" }, ngImport: i0, template: `
+    <div class="srk-progress-bar-container">
+      <div class="srk-progress-bar">
+        <div class="srk-progress-bar-body">
+          <div
+            class="srk-progress-bar-segment srk-progress-bar-normal"
+            [style.width.%]="progressMetrics().frozenBreakpoint * 100"
+          >
+            <div class="srk-progress-bar-fill" [style.width.%]="progressMetrics().normalInnerPercent"></div>
+          </div>
+          <div
+            class="srk-progress-bar-segment srk-progress-bar-frozen"
+            [style.width.%]="(1 - progressMetrics().frozenBreakpoint) * 100"
+          >
+            <div class="srk-progress-bar-fill" [style.width.%]="progressMetrics().frozenInnerPercent"></div>
+          </div>
+        </div>
+        <div
+          *ngIf="enableTimeTravel && progressMetrics().supportRegen"
+          class="srk-progress-slider-layer"
+        >
+          <div
+            *ngIf="timeTravelIsChanging"
+            class="srk-progress-slider-tooltip"
+            [style.left.%]="durationMinutes() ? (timeTravelCurrentValue / durationMinutes()) * 100 : 0"
+          >
+            {{ timeLabel(timeTravelCurrentValue) }}
+          </div>
+          <input
+            aria-label="Time Travel"
+            class="srk-progress-slider"
+            min="0"
+            step="1"
+            type="range"
+            [max]="durationMinutes()"
+            [title]="timeLabel(timeTravelCurrentValue)"
+            [value]="timeTravelCurrentValue"
+            (blur)="commitTimeTravel()"
+            (input)="updateTimeTravelValue($event)"
+            (keydown)="beginTimeTravel()"
+            (keyup)="commitTimeTravel()"
+            (mousedown)="beginTimeTravel()"
+            (mouseup)="commitTimeTravel()"
+            (touchend)="commitTimeTravel()"
+            (touchstart)="beginTimeTravel()"
+          />
+        </div>
+      </div>
+      <div class="srk-progress-secondary-area">
+        <div
+          class="srk-progress-secondary-area-left"
+          [style.display]="live || inTimeMachine ? '' : 'none'"
+        >
+          Elapsed: {{ secToTimeStr(progressMetrics().elapsed / 1000) }}
+        </div>
+        <div class="srk-progress-secondary-area-center">
+          <div *ngIf="inTimeMachine" class="srk-progress-time-machine-status">
+            <div class="srk-progress-time-machine-text">Time Travel Mode</div>
+          </div>
+          <div *ngIf="!inTimeMachine && live && !isEnded()" class="srk-progress-live-text">
+            Live
+          </div>
+          <div *ngIf="!inTimeMachine && (!live || isEnded())" style="visibility: hidden">
+            SRK
+          </div>
+        </div>
+        <div
+          class="srk-progress-secondary-area-right"
+          [style.display]="live || inTimeMachine ? '' : 'none'"
+        >
+          Remaining: {{ secToTimeStr(progressMetrics().remaining / 1000) }}
+        </div>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProgressBarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'srk-progress-bar',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <div class="srk-progress-bar-container">
+      <div class="srk-progress-bar">
+        <div class="srk-progress-bar-body">
+          <div
+            class="srk-progress-bar-segment srk-progress-bar-normal"
+            [style.width.%]="progressMetrics().frozenBreakpoint * 100"
+          >
+            <div class="srk-progress-bar-fill" [style.width.%]="progressMetrics().normalInnerPercent"></div>
+          </div>
+          <div
+            class="srk-progress-bar-segment srk-progress-bar-frozen"
+            [style.width.%]="(1 - progressMetrics().frozenBreakpoint) * 100"
+          >
+            <div class="srk-progress-bar-fill" [style.width.%]="progressMetrics().frozenInnerPercent"></div>
+          </div>
+        </div>
+        <div
+          *ngIf="enableTimeTravel && progressMetrics().supportRegen"
+          class="srk-progress-slider-layer"
+        >
+          <div
+            *ngIf="timeTravelIsChanging"
+            class="srk-progress-slider-tooltip"
+            [style.left.%]="durationMinutes() ? (timeTravelCurrentValue / durationMinutes()) * 100 : 0"
+          >
+            {{ timeLabel(timeTravelCurrentValue) }}
+          </div>
+          <input
+            aria-label="Time Travel"
+            class="srk-progress-slider"
+            min="0"
+            step="1"
+            type="range"
+            [max]="durationMinutes()"
+            [title]="timeLabel(timeTravelCurrentValue)"
+            [value]="timeTravelCurrentValue"
+            (blur)="commitTimeTravel()"
+            (input)="updateTimeTravelValue($event)"
+            (keydown)="beginTimeTravel()"
+            (keyup)="commitTimeTravel()"
+            (mousedown)="beginTimeTravel()"
+            (mouseup)="commitTimeTravel()"
+            (touchend)="commitTimeTravel()"
+            (touchstart)="beginTimeTravel()"
+          />
+        </div>
+      </div>
+      <div class="srk-progress-secondary-area">
+        <div
+          class="srk-progress-secondary-area-left"
+          [style.display]="live || inTimeMachine ? '' : 'none'"
+        >
+          Elapsed: {{ secToTimeStr(progressMetrics().elapsed / 1000) }}
+        </div>
+        <div class="srk-progress-secondary-area-center">
+          <div *ngIf="inTimeMachine" class="srk-progress-time-machine-status">
+            <div class="srk-progress-time-machine-text">Time Travel Mode</div>
+          </div>
+          <div *ngIf="!inTimeMachine && live && !isEnded()" class="srk-progress-live-text">
+            Live
+          </div>
+          <div *ngIf="!inTimeMachine && (!live || isEnded())" style="visibility: hidden">
+            SRK
+          </div>
+        </div>
+        <div
+          class="srk-progress-secondary-area-right"
+          [style.display]="live || inTimeMachine ? '' : 'none'"
+        >
+          Remaining: {{ secToTimeStr(progressMetrics().remaining / 1000) }}
+        </div>
+      </div>
+    </div>
+  `,
+                }]
+        }], propDecorators: { data: [{
+                type: Input,
+                args: [{ required: true }]
+            }], enableTimeTravel: [{
+                type: Input
+            }], live: [{
+                type: Input
+            }], td: [{
+                type: Input
+            }], timeTravel: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progress-bar.component.js","sourceRoot":"","sources":["../../../../src/lib/progress/progress-bar.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as srk from '@algoux/standard-ranklist';\nimport { CommonModule } from '@angular/common';\nimport {\n  Component,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n} from '@angular/core';\nimport { secToTimeStr } from '@algoux/standard-ranklist-utils';\nimport {\n  getProgressDurationMinutes,\n  getProgressMaxAvailableMinutes,\n  getProgressMetrics,\n  isProgressEnded,\n} from './progress-utils';\n\n@Component({\n  selector: 'srk-progress-bar',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div class=\"srk-progress-bar-container\">\n      <div class=\"srk-progress-bar\">\n        <div class=\"srk-progress-bar-body\">\n          <div\n            class=\"srk-progress-bar-segment srk-progress-bar-normal\"\n            [style.width.%]=\"progressMetrics().frozenBreakpoint * 100\"\n          >\n            <div class=\"srk-progress-bar-fill\" [style.width.%]=\"progressMetrics().normalInnerPercent\"></div>\n          </div>\n          <div\n            class=\"srk-progress-bar-segment srk-progress-bar-frozen\"\n            [style.width.%]=\"(1 - progressMetrics().frozenBreakpoint) * 100\"\n          >\n            <div class=\"srk-progress-bar-fill\" [style.width.%]=\"progressMetrics().frozenInnerPercent\"></div>\n          </div>\n        </div>\n        <div\n          *ngIf=\"enableTimeTravel && progressMetrics().supportRegen\"\n          class=\"srk-progress-slider-layer\"\n        >\n          <div\n            *ngIf=\"timeTravelIsChanging\"\n            class=\"srk-progress-slider-tooltip\"\n            [style.left.%]=\"durationMinutes() ? (timeTravelCurrentValue / durationMinutes()) * 100 : 0\"\n          >\n            {{ timeLabel(timeTravelCurrentValue) }}\n          </div>\n          <input\n            aria-label=\"Time Travel\"\n            class=\"srk-progress-slider\"\n            min=\"0\"\n            step=\"1\"\n            type=\"range\"\n            [max]=\"durationMinutes()\"\n            [title]=\"timeLabel(timeTravelCurrentValue)\"\n            [value]=\"timeTravelCurrentValue\"\n            (blur)=\"commitTimeTravel()\"\n            (input)=\"updateTimeTravelValue($event)\"\n            (keydown)=\"beginTimeTravel()\"\n            (keyup)=\"commitTimeTravel()\"\n            (mousedown)=\"beginTimeTravel()\"\n            (mouseup)=\"commitTimeTravel()\"\n            (touchend)=\"commitTimeTravel()\"\n            (touchstart)=\"beginTimeTravel()\"\n          />\n        </div>\n      </div>\n      <div class=\"srk-progress-secondary-area\">\n        <div\n          class=\"srk-progress-secondary-area-left\"\n          [style.display]=\"live || inTimeMachine ? '' : 'none'\"\n        >\n          Elapsed: {{ secToTimeStr(progressMetrics().elapsed / 1000) }}\n        </div>\n        <div class=\"srk-progress-secondary-area-center\">\n          <div *ngIf=\"inTimeMachine\" class=\"srk-progress-time-machine-status\">\n            <div class=\"srk-progress-time-machine-text\">Time Travel Mode</div>\n          </div>\n          <div *ngIf=\"!inTimeMachine && live && !isEnded()\" class=\"srk-progress-live-text\">\n            Live\n          </div>\n          <div *ngIf=\"!inTimeMachine && (!live || isEnded())\" style=\"visibility: hidden\">\n            SRK\n          </div>\n        </div>\n        <div\n          class=\"srk-progress-secondary-area-right\"\n          [style.display]=\"live || inTimeMachine ? '' : 'none'\"\n        >\n          Remaining: {{ secToTimeStr(progressMetrics().remaining / 1000) }}\n        </div>\n      </div>\n    </div>\n  `,\n})\nexport class ProgressBarComponent implements OnInit, OnDestroy {\n  @Input({ required: true }) data!: srk.Ranklist;\n  @Input() enableTimeTravel = false;\n  @Input() live = false;\n  @Input() td = 0;\n\n  @Output() timeTravel = new EventEmitter<number | null>();\n\n  localTime = Date.now();\n  inTimeMachine = false;\n  timeTravelIsChanging = false;\n  timeTravelCurrentValue = 0;\n  timeTravelValue: number | null = null;\n\n  private liveInterval?: number;\n\n  ngOnInit() {\n    this.timeTravelCurrentValue = this.maxAvailableMinutes();\n    if (this.live) {\n      this.liveInterval = window.setInterval(() => this.handleProgressTimer(), 1000);\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.liveInterval) {\n      window.clearInterval(this.liveInterval);\n    }\n  }\n\n  secToTimeStr(seconds: number) {\n    return secToTimeStr(Math.round(seconds));\n  }\n\n  timeLabel(minutes: number) {\n    return secToTimeStr(minutes * 60);\n  }\n\n  durationMinutes() {\n    return getProgressDurationMinutes(this.data.contest);\n  }\n\n  maxAvailableMinutes() {\n    return getProgressMaxAvailableMinutes(this.data.contest, this.localTime, this.td);\n  }\n\n  isEnded() {\n    return isProgressEnded(this.data.contest, this.localTime, this.td);\n  }\n\n  progressMetrics() {\n    return getProgressMetrics(\n      this.data,\n      this.localTime,\n      this.td,\n      this.timeTravelCurrentValue,\n      this.inTimeMachine,\n    );\n  }\n\n  beginTimeTravel() {\n    this.timeTravelIsChanging = true;\n    this.inTimeMachine = true;\n  }\n\n  updateTimeTravelValue(event: Event) {\n    this.timeTravelCurrentValue = Number((event.target as HTMLInputElement).value);\n  }\n\n  commitTimeTravel() {\n    if (this.timeTravelIsChanging) {\n      this.handleTimeTravelChange(this.timeTravelCurrentValue);\n    }\n  }\n\n  private handleProgressTimer() {\n    this.localTime = Date.now();\n    if (this.isEnded() && this.liveInterval) {\n      window.clearInterval(this.liveInterval);\n    }\n    if (!this.timeTravelIsChanging && this.timeTravelValue === null) {\n      this.timeTravelCurrentValue = this.maxAvailableMinutes();\n    }\n  }\n\n  private handleTimeTravelChange(value: number) {\n    const exited = value >= this.durationMinutes() || value >= this.maxAvailableMinutes();\n    this.timeTravel.emit(exited ? null : value * 60 * 1000);\n    this.inTimeMachine = !exited;\n    this.timeTravelValue = exited ? null : value * 60 * 1000;\n    this.timeTravelIsChanging = false;\n  }\n}\n"]}

package/dist/esm2022/lib/progress/progress-utils.mjs

@@ -0,0 +1,45 @@
+import { canRegenerateRanklist, formatTimeDuration, } from '@algoux/standard-ranklist-utils';
+export function getProgressDurationMinutes(contest) {
+    return formatTimeDuration(contest.duration, 'min');
+}
+export function getProgressMaxAvailableMinutes(contest, localTime, td = 0) {
+    const startAt = new Date(contest.startAt).getTime();
+    const currentTime = localTime - td;
+    return Math.min(Math.max(Math.floor((currentTime - startAt) / 60000), 0), getProgressDurationMinutes(contest));
+}
+export function isProgressEnded(contest, localTime, td = 0) {
+    const startAt = new Date(contest.startAt).getTime();
+    const endAt = startAt + formatTimeDuration(contest.duration, 'ms');
+    const currentTime = localTime - td;
+    return currentTime >= endAt;
+}
+export function getProgressMetrics(data, localTime, td, timeTravelCurrentValue, inTimeMachine) {
+    const { contest } = data;
+    const startAt = new Date(contest.startAt).getTime();
+    const endAt = startAt + formatTimeDuration(contest.duration, 'ms');
+    const frozenLength = contest.frozenDuration ? formatTimeDuration(contest.frozenDuration, 'ms') : 0;
+    const currentTime = localTime - td;
+    const length = endAt - startAt;
+    const frozenBreakpoint = length ? 1 - frozenLength / length : 1;
+    const elapsed = Math.min(Math.max(currentTime - startAt, 0), length);
+    const remaining = length - elapsed;
+    const frozenAt = endAt - frozenLength;
+    const percent = length ? (elapsed / length) * 100 : 0;
+    const normalPercent = length ? (Math.max(Math.min(currentTime, frozenAt) - startAt, 0) / length) * 100 : 0;
+    const normalInnerPercent = Math.min(100, frozenBreakpoint ? normalPercent / frozenBreakpoint : 0);
+    const frozenPercent = percent - normalPercent;
+    const frozenInnerPercent = Math.min(100, 1 - frozenBreakpoint ? frozenPercent / (1 - frozenBreakpoint) : 0);
+    const timeTravelElapsed = timeTravelCurrentValue * 60 * 1000;
+    const timeTravelRemaining = length - timeTravelElapsed;
+    return {
+        elapsed: inTimeMachine ? timeTravelElapsed : elapsed,
+        remaining: inTimeMachine ? timeTravelRemaining : remaining,
+        frozenBreakpoint,
+        normalInnerPercent,
+        frozenInnerPercent,
+        timeTravelElapsed,
+        timeTravelRemaining,
+        supportRegen: canRegenerateRanklist(data),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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