@algoux/standard-ranklist-renderer-component-angular 0.5.0

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

@@ -0,0 +1,593 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChild, EventEmitter, Input, Output, } from '@angular/core';
+import { EnumTheme, formatTimeDuration, numberToAlphabet, resolveStyle, resolveText, resolveUserMarkers, } from '@algoux/standard-ranklist-utils';
+import { getAcceptedStatusDetails, caniuse, getMarkerPresentation, getProblemHeaderBackgroundImage, resolveSrkAssetUrl, shouldShowTimeColumn, srkSupportedVersions, } from './ranklist-utils';
+import { captureModalTriggerPointFromMouseEvent } from '../modal/modal-interactions';
+import { SrkStatusCellTemplateDirective, } from './status-cell-template.directive';
+import { SrkUserCellTemplateDirective, } from './user-cell-template.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class RanklistComponent {
+    data;
+    theme = EnumTheme.light;
+    borderedRows = false;
+    stripedRows = false;
+    formatSrkAssetUrl;
+    userClick = new EventEmitter();
+    solutionClick = new EventEmitter();
+    statusCellTemplate;
+    userCellTemplate;
+    supportedVersions = srkSupportedVersions;
+    isSupportedVersion() {
+        return caniuse(this.data.version);
+    }
+    showTimeColumn() {
+        return shouldShowTimeColumn(this.data.rows);
+    }
+    getRankValues(row) {
+        return row.rankValues || this.data.series.map(() => ({ rank: null, segmentIndex: null }));
+    }
+    getRankText(rankValue, row) {
+        return rankValue.rank ? rankValue.rank : row.user.official === false ? '＊' : '';
+    }
+    resolveDisplayText(text) {
+        return resolveText(text);
+    }
+    problemAlias(problem, problemIndex) {
+        return problem.alias || numberToAlphabet(problemIndex);
+    }
+    problemStatsTitle(statistics) {
+        const ratio = statistics.submitted ? ((statistics.accepted / statistics.submitted) * 100).toFixed(1) : 0;
+        return `${statistics.accepted} / ${statistics.submitted} (${ratio}%)`;
+    }
+    problemHeaderBackgroundImage(problem) {
+        return getProblemHeaderBackgroundImage(problem.style, this.theme);
+    }
+    resolvedUserMarkers(user) {
+        return resolveUserMarkers(user, this.data.markers).map((marker) => ({
+            marker,
+            presentation: getMarkerPresentation(marker, this.theme),
+        }));
+    }
+    formatAssetUrl(url, field) {
+        return resolveSrkAssetUrl(url, field, this.formatSrkAssetUrl);
+    }
+    formatTime(time) {
+        return formatTimeDuration(time, 'min', Math.floor);
+    }
+    acceptedStatusDetails(status) {
+        return getAcceptedStatusDetails(status);
+    }
+    isNumber(value) {
+        return typeof value === 'number';
+    }
+    getStatusSolutions(status) {
+        return [...(status.solutions || [])].reverse();
+    }
+    statusCellClass(status) {
+        const classNames = ['srk-prest-status-block', 'srk--text-center', 'srk--nowrap'];
+        if (this.isStatusClickable(status)) {
+            classNames.push('srk--cursor-pointer');
+        }
+        if (status.result === 'FB') {
+            classNames.push('srk-prest-status-block-fb');
+        }
+        else if (status.result === 'AC') {
+            classNames.push('srk-prest-status-block-accepted');
+        }
+        else if (status.result === '?') {
+            classNames.push('srk-prest-status-block-frozen');
+        }
+        else if (status.result === 'RJ') {
+            classNames.push('srk-prest-status-block-failed');
+        }
+        return classNames.join(' ');
+    }
+    isStatusClickable(status) {
+        return this.getStatusSolutions(status).length > 0;
+    }
+    statusCellRole(status) {
+        return this.isStatusClickable(status) ? 'button' : null;
+    }
+    statusCellTabIndex(status) {
+        return this.isStatusClickable(status) ? 0 : null;
+    }
+    buildUserCellContext(row, rowIndex) {
+        return {
+            $implicit: row.user,
+            user: row.user,
+            row,
+            rowIndex,
+            ranklist: this.data,
+            markers: this.data.markers,
+            onClick: (event) => this.emitUserClick(event, row, rowIndex),
+        };
+    }
+    buildStatusCellContext(row, rowIndex, status, problemIndex) {
+        return {
+            $implicit: status,
+            status,
+            problem: this.data.problems[problemIndex],
+            problemIndex,
+            user: row.user,
+            row,
+            rowIndex,
+            ranklist: this.data,
+            solutions: this.getStatusSolutions(status),
+            onClick: (event) => this.emitSolutionClick(event, row, rowIndex, status, problemIndex),
+        };
+    }
+    activateUserCellFromKeyboard(event, row, rowIndex) {
+        event.preventDefault();
+        this.emitUserClick(undefined, row, rowIndex);
+    }
+    activateStatusCellFromKeyboard(event, row, rowIndex, status, problemIndex) {
+        event.preventDefault();
+        this.emitSolutionClick(undefined, row, rowIndex, status, problemIndex);
+    }
+    emitUserClick(event, row, rowIndex) {
+        if (event) {
+            captureModalTriggerPointFromMouseEvent(event, {
+                source: 'user-cell',
+                context: {
+                    rowIndex,
+                    userId: row.user.id || null,
+                    userName: this.resolveDisplayText(row.user.name),
+                },
+            });
+        }
+        this.userClick.emit({
+            user: row.user,
+            row,
+            rowIndex,
+            ranklist: this.data,
+        });
+    }
+    emitSolutionClick(event, row, rowIndex, status, problemIndex) {
+        const solutions = this.getStatusSolutions(status);
+        if (!solutions.length) {
+            return;
+        }
+        if (event) {
+            captureModalTriggerPointFromMouseEvent(event, {
+                source: 'status-cell',
+                context: {
+                    rowIndex,
+                    problemIndex,
+                    problemAlias: this.data.problems[problemIndex]?.alias || null,
+                    problemTitle: this.data.problems[problemIndex]?.title || null,
+                    userId: row.user.id || null,
+                },
+            });
+        }
+        this.solutionClick.emit({
+            user: row.user,
+            row,
+            rowIndex,
+            problemIndex,
+            problem: this.data.problems[problemIndex],
+            status,
+            solutions,
+            ranklist: this.data,
+        });
+    }
+    resolveSeriesSegment(rankValue, series) {
+        const index = rankValue.segmentIndex || rankValue.segmentIndex === 0 ? rankValue.segmentIndex : -1;
+        return (series?.segments || [])[index] || {};
+    }
+    getSeriesSegmentClass(rankValue, series) {
+        const segmentStyle = this.resolveSeriesSegment(rankValue, series).style;
+        return typeof segmentStyle === 'string' ? `srk-preset-series-segment-${segmentStyle}` : '';
+    }
+    getSeriesSegmentStyle(rankValue, series) {
+        const emptyColor = {
+            [EnumTheme.light]: undefined,
+            [EnumTheme.dark]: undefined,
+        };
+        const segmentStyle = this.resolveSeriesSegment(rankValue, series).style;
+        if (!segmentStyle || typeof segmentStyle === 'string') {
+            return {};
+        }
+        const style = resolveStyle(segmentStyle);
+        const textColor = style.textColor || emptyColor;
+        const backgroundColor = style.backgroundColor || emptyColor;
+        return {
+            color: textColor[this.theme],
+            backgroundColor: backgroundColor[this.theme],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RanklistComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: RanklistComponent, isStandalone: true, selector: "srk-ranklist", inputs: { data: "data", theme: "theme", borderedRows: "borderedRows", stripedRows: "stripedRows", formatSrkAssetUrl: "formatSrkAssetUrl" }, outputs: { userClick: "userClick", solutionClick: "solutionClick" }, queries: [{ propertyName: "statusCellTemplate", first: true, predicate: SrkStatusCellTemplateDirective, descendants: true }, { propertyName: "userCellTemplate", first: true, predicate: SrkUserCellTemplateDirective, descendants: true }], ngImport: i0, template: `
+    <div *ngIf="data.type !== 'general'; else versionState">
+      srk type "{{ data.type }}" is not supported
+    </div>
+
+    <ng-template #versionState>
+      <div *ngIf="!isSupportedVersion(); else ranklistTable">
+        srk version "{{ data.version }}" is not supported (current supported: {{ supportedVersions }})
+      </div>
+    </ng-template>
+
+    <ng-template #ranklistTable>
+      <div class="srk-common-table srk-main">
+        <table
+          [class.srk-table-row-bordered]="borderedRows"
+          [class.srk-table-row-striped]="stripedRows"
+        >
+          <thead>
+            <tr>
+              <th
+                *ngFor="let seriesItem of data.series"
+                class="srk-series-header srk--text-right srk--nowrap"
+              >
+                {{ seriesItem.title }}
+              </th>
+              <th class="srk--text-left srk--nowrap">Name</th>
+              <th class="srk--nowrap">Score</th>
+              <th *ngIf="showTimeColumn()" class="srk--nowrap">Time</th>
+              <th
+                *ngFor="let problem of data.problems; let problemIndex = index"
+                class="srk--nowrap srk-problem-header"
+                [style.background-image]="problemHeaderBackgroundImage(problem)"
+              >
+                <a
+                  *ngIf="problem.link; else unlinkedProblemHeader"
+                  [href]="problem.link"
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  style="color: unset"
+                >
+                  <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+                  <span
+                    *ngIf="problem.statistics"
+                    class="srk--display-block srk-problem-stats"
+                    [title]="problemStatsTitle(problem.statistics)"
+                  >
+                    {{ problem.statistics.accepted }}
+                  </span>
+                </a>
+                <ng-template #unlinkedProblemHeader>
+                  <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+                  <span
+                    *ngIf="problem.statistics"
+                    class="srk--display-block srk-problem-stats"
+                    [title]="problemStatsTitle(problem.statistics)"
+                  >
+                    {{ problem.statistics.accepted }}
+                  </span>
+                </ng-template>
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr *ngFor="let row of data.rows; let rowIndex = index">
+              <td
+                *ngFor="let rankValue of getRankValues(row); let seriesIndex = index"
+                class="srk--text-right srk--nowrap"
+                [ngClass]="getSeriesSegmentClass(rankValue, data.series[seriesIndex])"
+                [ngStyle]="getSeriesSegmentStyle(rankValue, data.series[seriesIndex])"
+              >
+                {{ getRankText(rankValue, row) }}
+              </td>
+
+              <ng-container *ngIf="userCellTemplate; else defaultUserCell">
+                <ng-container
+                  [ngTemplateOutlet]="userCellTemplate.templateRef"
+                  [ngTemplateOutletContext]="buildUserCellContext(row, rowIndex)"
+                />
+              </ng-container>
+              <ng-template #defaultUserCell>
+                <td
+                  class="srk--text-left srk--nowrap srk-user-cell srk--cursor-pointer"
+                  role="button"
+                  tabindex="0"
+                  (click)="emitUserClick($event, row, rowIndex)"
+                  (keydown.enter)="activateUserCellFromKeyboard($event, row, rowIndex)"
+                  (keydown.space)="activateUserCellFromKeyboard($event, row, rowIndex)"
+                >
+                  <div class="srk-user-cell-content">
+                    <div *ngIf="row.user.avatar" class="srk-user-avatar">
+                      <img
+                        [src]="formatAssetUrl(row.user.avatar, 'user.avatar')"
+                        alt="User Avatar"
+                      />
+                    </div>
+                    <div class="srk-user-body">
+                      <div class="srk-user-name-row">
+                        <span
+                          class="srk-user-name-text"
+                          [title]="resolveDisplayText(row.user.name)"
+                        >
+                          {{ resolveDisplayText(row.user.name) }}
+                        </span>
+                        <span class="srk-marker-dot-group">
+                          <span
+                            *ngFor="let marker of resolvedUserMarkers(row.user)"
+                            class="srk-marker srk-marker-dot srk--c-tooltip"
+                            [ngClass]="marker.presentation.className"
+                            [ngStyle]="marker.presentation.style"
+                            [attr.data-tooltip]="resolveDisplayText(marker.marker.label)"
+                          ></span>
+                        </span>
+                      </div>
+                      <p
+                        *ngIf="row.user.organization"
+                        class="srk-user-secondary-text srk--text-ellipsis"
+                        title=""
+                      >
+                        {{ resolveDisplayText(row.user.organization) }}
+                      </p>
+                    </div>
+                  </div>
+                </td>
+              </ng-template>
+
+              <td class="srk--text-right srk--nowrap">{{ row.score.value }}</td>
+              <td *ngIf="showTimeColumn()" class="srk--text-right srk--nowrap">
+                {{ row.score.time ? formatTime(row.score.time) : '-' }}
+              </td>
+
+              <ng-container *ngFor="let status of row.statuses; let problemIndex = index">
+                <ng-container *ngIf="statusCellTemplate; else defaultStatusCell">
+                  <ng-container
+                    [ngTemplateOutlet]="statusCellTemplate.templateRef"
+                    [ngTemplateOutletContext]="buildStatusCellContext(row, rowIndex, status, problemIndex)"
+                  />
+                </ng-container>
+                <ng-template #defaultStatusCell>
+                  <td
+                    *ngIf="status.result === 'FB' || status.result === 'AC'; else failedOrFrozenStatus"
+                    [ngClass]="statusCellClass(status)"
+                    [attr.role]="statusCellRole(status)"
+                    [attr.tabindex]="statusCellTabIndex(status)"
+                    (click)="emitSolutionClick($event, row, rowIndex, status, problemIndex)"
+                    (keydown.enter)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                    (keydown.space)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                  >
+                    <ng-container *ngIf="isNumber(status.score); else acceptedDetails">
+                      <span class="srk-prest-status-block-score">{{ status.score }}</span>
+                      <span class="srk-prest-status-block-score-details">
+                        {{ acceptedStatusDetails(status) }}
+                      </span>
+                    </ng-container>
+                    <ng-template #acceptedDetails>
+                      {{ acceptedStatusDetails(status) }}
+                    </ng-template>
+                  </td>
+                  <ng-template #failedOrFrozenStatus>
+                    <td
+                      *ngIf="status.result === '?' || status.result === 'RJ'; else emptyStatus"
+                      [ngClass]="statusCellClass(status)"
+                      [attr.role]="statusCellRole(status)"
+                      [attr.tabindex]="statusCellTabIndex(status)"
+                      (click)="emitSolutionClick($event, row, rowIndex, status, problemIndex)"
+                      (keydown.enter)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                      (keydown.space)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                    >
+                      {{ status.tries }}
+                    </td>
+                  </ng-template>
+                  <ng-template #emptyStatus>
+                    <td></td>
+                  </ng-template>
+                </ng-template>
+              </ng-container>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RanklistComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'srk-ranklist',
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule],
+                    template: `
+    <div *ngIf="data.type !== 'general'; else versionState">
+      srk type "{{ data.type }}" is not supported
+    </div>
+
+    <ng-template #versionState>
+      <div *ngIf="!isSupportedVersion(); else ranklistTable">
+        srk version "{{ data.version }}" is not supported (current supported: {{ supportedVersions }})
+      </div>
+    </ng-template>
+
+    <ng-template #ranklistTable>
+      <div class="srk-common-table srk-main">
+        <table
+          [class.srk-table-row-bordered]="borderedRows"
+          [class.srk-table-row-striped]="stripedRows"
+        >
+          <thead>
+            <tr>
+              <th
+                *ngFor="let seriesItem of data.series"
+                class="srk-series-header srk--text-right srk--nowrap"
+              >
+                {{ seriesItem.title }}
+              </th>
+              <th class="srk--text-left srk--nowrap">Name</th>
+              <th class="srk--nowrap">Score</th>
+              <th *ngIf="showTimeColumn()" class="srk--nowrap">Time</th>
+              <th
+                *ngFor="let problem of data.problems; let problemIndex = index"
+                class="srk--nowrap srk-problem-header"
+                [style.background-image]="problemHeaderBackgroundImage(problem)"
+              >
+                <a
+                  *ngIf="problem.link; else unlinkedProblemHeader"
+                  [href]="problem.link"
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  style="color: unset"
+                >
+                  <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+                  <span
+                    *ngIf="problem.statistics"
+                    class="srk--display-block srk-problem-stats"
+                    [title]="problemStatsTitle(problem.statistics)"
+                  >
+                    {{ problem.statistics.accepted }}
+                  </span>
+                </a>
+                <ng-template #unlinkedProblemHeader>
+                  <span class="srk--display-block">{{ problemAlias(problem, problemIndex) }}</span>
+                  <span
+                    *ngIf="problem.statistics"
+                    class="srk--display-block srk-problem-stats"
+                    [title]="problemStatsTitle(problem.statistics)"
+                  >
+                    {{ problem.statistics.accepted }}
+                  </span>
+                </ng-template>
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr *ngFor="let row of data.rows; let rowIndex = index">
+              <td
+                *ngFor="let rankValue of getRankValues(row); let seriesIndex = index"
+                class="srk--text-right srk--nowrap"
+                [ngClass]="getSeriesSegmentClass(rankValue, data.series[seriesIndex])"
+                [ngStyle]="getSeriesSegmentStyle(rankValue, data.series[seriesIndex])"
+              >
+                {{ getRankText(rankValue, row) }}
+              </td>
+
+              <ng-container *ngIf="userCellTemplate; else defaultUserCell">
+                <ng-container
+                  [ngTemplateOutlet]="userCellTemplate.templateRef"
+                  [ngTemplateOutletContext]="buildUserCellContext(row, rowIndex)"
+                />
+              </ng-container>
+              <ng-template #defaultUserCell>
+                <td
+                  class="srk--text-left srk--nowrap srk-user-cell srk--cursor-pointer"
+                  role="button"
+                  tabindex="0"
+                  (click)="emitUserClick($event, row, rowIndex)"
+                  (keydown.enter)="activateUserCellFromKeyboard($event, row, rowIndex)"
+                  (keydown.space)="activateUserCellFromKeyboard($event, row, rowIndex)"
+                >
+                  <div class="srk-user-cell-content">
+                    <div *ngIf="row.user.avatar" class="srk-user-avatar">
+                      <img
+                        [src]="formatAssetUrl(row.user.avatar, 'user.avatar')"
+                        alt="User Avatar"
+                      />
+                    </div>
+                    <div class="srk-user-body">
+                      <div class="srk-user-name-row">
+                        <span
+                          class="srk-user-name-text"
+                          [title]="resolveDisplayText(row.user.name)"
+                        >
+                          {{ resolveDisplayText(row.user.name) }}
+                        </span>
+                        <span class="srk-marker-dot-group">
+                          <span
+                            *ngFor="let marker of resolvedUserMarkers(row.user)"
+                            class="srk-marker srk-marker-dot srk--c-tooltip"
+                            [ngClass]="marker.presentation.className"
+                            [ngStyle]="marker.presentation.style"
+                            [attr.data-tooltip]="resolveDisplayText(marker.marker.label)"
+                          ></span>
+                        </span>
+                      </div>
+                      <p
+                        *ngIf="row.user.organization"
+                        class="srk-user-secondary-text srk--text-ellipsis"
+                        title=""
+                      >
+                        {{ resolveDisplayText(row.user.organization) }}
+                      </p>
+                    </div>
+                  </div>
+                </td>
+              </ng-template>
+
+              <td class="srk--text-right srk--nowrap">{{ row.score.value }}</td>
+              <td *ngIf="showTimeColumn()" class="srk--text-right srk--nowrap">
+                {{ row.score.time ? formatTime(row.score.time) : '-' }}
+              </td>
+
+              <ng-container *ngFor="let status of row.statuses; let problemIndex = index">
+                <ng-container *ngIf="statusCellTemplate; else defaultStatusCell">
+                  <ng-container
+                    [ngTemplateOutlet]="statusCellTemplate.templateRef"
+                    [ngTemplateOutletContext]="buildStatusCellContext(row, rowIndex, status, problemIndex)"
+                  />
+                </ng-container>
+                <ng-template #defaultStatusCell>
+                  <td
+                    *ngIf="status.result === 'FB' || status.result === 'AC'; else failedOrFrozenStatus"
+                    [ngClass]="statusCellClass(status)"
+                    [attr.role]="statusCellRole(status)"
+                    [attr.tabindex]="statusCellTabIndex(status)"
+                    (click)="emitSolutionClick($event, row, rowIndex, status, problemIndex)"
+                    (keydown.enter)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                    (keydown.space)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                  >
+                    <ng-container *ngIf="isNumber(status.score); else acceptedDetails">
+                      <span class="srk-prest-status-block-score">{{ status.score }}</span>
+                      <span class="srk-prest-status-block-score-details">
+                        {{ acceptedStatusDetails(status) }}
+                      </span>
+                    </ng-container>
+                    <ng-template #acceptedDetails>
+                      {{ acceptedStatusDetails(status) }}
+                    </ng-template>
+                  </td>
+                  <ng-template #failedOrFrozenStatus>
+                    <td
+                      *ngIf="status.result === '?' || status.result === 'RJ'; else emptyStatus"
+                      [ngClass]="statusCellClass(status)"
+                      [attr.role]="statusCellRole(status)"
+                      [attr.tabindex]="statusCellTabIndex(status)"
+                      (click)="emitSolutionClick($event, row, rowIndex, status, problemIndex)"
+                      (keydown.enter)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                      (keydown.space)="activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)"
+                    >
+                      {{ status.tries }}
+                    </td>
+                  </ng-template>
+                  <ng-template #emptyStatus>
+                    <td></td>
+                  </ng-template>
+                </ng-template>
+              </ng-container>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </ng-template>
+  `,
+                }]
+        }], propDecorators: { data: [{
+                type: Input,
+                args: [{ required: true }]
+            }], theme: [{
+                type: Input
+            }], borderedRows: [{
+                type: Input
+            }], stripedRows: [{
+                type: Input
+            }], formatSrkAssetUrl: [{
+                type: Input
+            }], userClick: [{
+                type: Output
+            }], solutionClick: [{
+                type: Output
+            }], statusCellTemplate: [{
+                type: ContentChild,
+                args: [SrkStatusCellTemplateDirective]
+            }], userCellTemplate: [{
+                type: ContentChild,
+                args: [SrkUserCellTemplateDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ranklist.component.js","sourceRoot":"","sources":["../../../../src/lib/ranklist/ranklist.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as srk from '@algoux/standard-ranklist';\nimport { CommonModule } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  EventEmitter,\n  Input,\n  Output,\n} from '@angular/core';\nimport {\n  EnumTheme,\n  formatTimeDuration,\n  numberToAlphabet,\n  resolveStyle,\n  resolveText,\n  resolveUserMarkers,\n} from '@algoux/standard-ranklist-utils';\nimport type { ThemeColor } from '@algoux/standard-ranklist-utils';\nimport {\n  getAcceptedStatusDetails,\n  caniuse,\n  getMarkerPresentation,\n  getProblemHeaderBackgroundImage,\n  resolveSrkAssetUrl,\n  shouldShowTimeColumn,\n  srkSupportedVersions,\n} from './ranklist-utils';\nimport { captureModalTriggerPointFromMouseEvent } from '../modal/modal-interactions';\nimport type {\n  RankValue,\n  SolutionClickPayload,\n  StaticRanklist,\n  StaticRanklistRow,\n  UserClickPayload,\n} from '../types';\nimport {\n  SrkStatusCellTemplateDirective,\n  type StatusCellTemplateContext,\n} from './status-cell-template.directive';\nimport {\n  SrkUserCellTemplateDirective,\n  type UserCellTemplateContext,\n} from './user-cell-template.directive';\n\n@Component({\n  selector: 'srk-ranklist',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [CommonModule],\n  template: `\n    <div *ngIf=\"data.type !== 'general'; else versionState\">\n      srk type \"{{ data.type }}\" is not supported\n    </div>\n\n    <ng-template #versionState>\n      <div *ngIf=\"!isSupportedVersion(); else ranklistTable\">\n        srk version \"{{ data.version }}\" is not supported (current supported: {{ supportedVersions }})\n      </div>\n    </ng-template>\n\n    <ng-template #ranklistTable>\n      <div class=\"srk-common-table srk-main\">\n        <table\n          [class.srk-table-row-bordered]=\"borderedRows\"\n          [class.srk-table-row-striped]=\"stripedRows\"\n        >\n          <thead>\n            <tr>\n              <th\n                *ngFor=\"let seriesItem of data.series\"\n                class=\"srk-series-header srk--text-right srk--nowrap\"\n              >\n                {{ seriesItem.title }}\n              </th>\n              <th class=\"srk--text-left srk--nowrap\">Name</th>\n              <th class=\"srk--nowrap\">Score</th>\n              <th *ngIf=\"showTimeColumn()\" class=\"srk--nowrap\">Time</th>\n              <th\n                *ngFor=\"let problem of data.problems; let problemIndex = index\"\n                class=\"srk--nowrap srk-problem-header\"\n                [style.background-image]=\"problemHeaderBackgroundImage(problem)\"\n              >\n                <a\n                  *ngIf=\"problem.link; else unlinkedProblemHeader\"\n                  [href]=\"problem.link\"\n                  target=\"_blank\"\n                  rel=\"noopener noreferrer\"\n                  style=\"color: unset\"\n                >\n                  <span class=\"srk--display-block\">{{ problemAlias(problem, problemIndex) }}</span>\n                  <span\n                    *ngIf=\"problem.statistics\"\n                    class=\"srk--display-block srk-problem-stats\"\n                    [title]=\"problemStatsTitle(problem.statistics)\"\n                  >\n                    {{ problem.statistics.accepted }}\n                  </span>\n                </a>\n                <ng-template #unlinkedProblemHeader>\n                  <span class=\"srk--display-block\">{{ problemAlias(problem, problemIndex) }}</span>\n                  <span\n                    *ngIf=\"problem.statistics\"\n                    class=\"srk--display-block srk-problem-stats\"\n                    [title]=\"problemStatsTitle(problem.statistics)\"\n                  >\n                    {{ problem.statistics.accepted }}\n                  </span>\n                </ng-template>\n              </th>\n            </tr>\n          </thead>\n          <tbody>\n            <tr *ngFor=\"let row of data.rows; let rowIndex = index\">\n              <td\n                *ngFor=\"let rankValue of getRankValues(row); let seriesIndex = index\"\n                class=\"srk--text-right srk--nowrap\"\n                [ngClass]=\"getSeriesSegmentClass(rankValue, data.series[seriesIndex])\"\n                [ngStyle]=\"getSeriesSegmentStyle(rankValue, data.series[seriesIndex])\"\n              >\n                {{ getRankText(rankValue, row) }}\n              </td>\n\n              <ng-container *ngIf=\"userCellTemplate; else defaultUserCell\">\n                <ng-container\n                  [ngTemplateOutlet]=\"userCellTemplate.templateRef\"\n                  [ngTemplateOutletContext]=\"buildUserCellContext(row, rowIndex)\"\n                />\n              </ng-container>\n              <ng-template #defaultUserCell>\n                <td\n                  class=\"srk--text-left srk--nowrap srk-user-cell srk--cursor-pointer\"\n                  role=\"button\"\n                  tabindex=\"0\"\n                  (click)=\"emitUserClick($event, row, rowIndex)\"\n                  (keydown.enter)=\"activateUserCellFromKeyboard($event, row, rowIndex)\"\n                  (keydown.space)=\"activateUserCellFromKeyboard($event, row, rowIndex)\"\n                >\n                  <div class=\"srk-user-cell-content\">\n                    <div *ngIf=\"row.user.avatar\" class=\"srk-user-avatar\">\n                      <img\n                        [src]=\"formatAssetUrl(row.user.avatar, 'user.avatar')\"\n                        alt=\"User Avatar\"\n                      />\n                    </div>\n                    <div class=\"srk-user-body\">\n                      <div class=\"srk-user-name-row\">\n                        <span\n                          class=\"srk-user-name-text\"\n                          [title]=\"resolveDisplayText(row.user.name)\"\n                        >\n                          {{ resolveDisplayText(row.user.name) }}\n                        </span>\n                        <span class=\"srk-marker-dot-group\">\n                          <span\n                            *ngFor=\"let marker of resolvedUserMarkers(row.user)\"\n                            class=\"srk-marker srk-marker-dot srk--c-tooltip\"\n                            [ngClass]=\"marker.presentation.className\"\n                            [ngStyle]=\"marker.presentation.style\"\n                            [attr.data-tooltip]=\"resolveDisplayText(marker.marker.label)\"\n                          ></span>\n                        </span>\n                      </div>\n                      <p\n                        *ngIf=\"row.user.organization\"\n                        class=\"srk-user-secondary-text srk--text-ellipsis\"\n                        title=\"\"\n                      >\n                        {{ resolveDisplayText(row.user.organization) }}\n                      </p>\n                    </div>\n                  </div>\n                </td>\n              </ng-template>\n\n              <td class=\"srk--text-right srk--nowrap\">{{ row.score.value }}</td>\n              <td *ngIf=\"showTimeColumn()\" class=\"srk--text-right srk--nowrap\">\n                {{ row.score.time ? formatTime(row.score.time) : '-' }}\n              </td>\n\n              <ng-container *ngFor=\"let status of row.statuses; let problemIndex = index\">\n                <ng-container *ngIf=\"statusCellTemplate; else defaultStatusCell\">\n                  <ng-container\n                    [ngTemplateOutlet]=\"statusCellTemplate.templateRef\"\n                    [ngTemplateOutletContext]=\"buildStatusCellContext(row, rowIndex, status, problemIndex)\"\n                  />\n                </ng-container>\n                <ng-template #defaultStatusCell>\n                  <td\n                    *ngIf=\"status.result === 'FB' || status.result === 'AC'; else failedOrFrozenStatus\"\n                    [ngClass]=\"statusCellClass(status)\"\n                    [attr.role]=\"statusCellRole(status)\"\n                    [attr.tabindex]=\"statusCellTabIndex(status)\"\n                    (click)=\"emitSolutionClick($event, row, rowIndex, status, problemIndex)\"\n                    (keydown.enter)=\"activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)\"\n                    (keydown.space)=\"activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)\"\n                  >\n                    <ng-container *ngIf=\"isNumber(status.score); else acceptedDetails\">\n                      <span class=\"srk-prest-status-block-score\">{{ status.score }}</span>\n                      <span class=\"srk-prest-status-block-score-details\">\n                        {{ acceptedStatusDetails(status) }}\n                      </span>\n                    </ng-container>\n                    <ng-template #acceptedDetails>\n                      {{ acceptedStatusDetails(status) }}\n                    </ng-template>\n                  </td>\n                  <ng-template #failedOrFrozenStatus>\n                    <td\n                      *ngIf=\"status.result === '?' || status.result === 'RJ'; else emptyStatus\"\n                      [ngClass]=\"statusCellClass(status)\"\n                      [attr.role]=\"statusCellRole(status)\"\n                      [attr.tabindex]=\"statusCellTabIndex(status)\"\n                      (click)=\"emitSolutionClick($event, row, rowIndex, status, problemIndex)\"\n                      (keydown.enter)=\"activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)\"\n                      (keydown.space)=\"activateStatusCellFromKeyboard($event, row, rowIndex, status, problemIndex)\"\n                    >\n                      {{ status.tries }}\n                    </td>\n                  </ng-template>\n                  <ng-template #emptyStatus>\n                    <td></td>\n                  </ng-template>\n                </ng-template>\n              </ng-container>\n            </tr>\n          </tbody>\n        </table>\n      </div>\n    </ng-template>\n  `,\n})\nexport class RanklistComponent {\n  @Input({ required: true }) data!: StaticRanklist;\n  @Input() theme: EnumTheme = EnumTheme.light;\n  @Input() borderedRows = false;\n  @Input() stripedRows = false;\n  @Input() formatSrkAssetUrl?: (url: string, field: string) => string;\n\n  @Output() userClick = new EventEmitter<UserClickPayload>();\n  @Output() solutionClick = new EventEmitter<SolutionClickPayload>();\n\n  @ContentChild(SrkStatusCellTemplateDirective)\n  statusCellTemplate?: SrkStatusCellTemplateDirective;\n\n  @ContentChild(SrkUserCellTemplateDirective)\n  userCellTemplate?: SrkUserCellTemplateDirective;\n\n  readonly supportedVersions = srkSupportedVersions;\n\n  isSupportedVersion() {\n    return caniuse(this.data.version);\n  }\n\n  showTimeColumn() {\n    return shouldShowTimeColumn(this.data.rows);\n  }\n\n  getRankValues(row: StaticRanklistRow): RankValue[] {\n    return row.rankValues || this.data.series.map(() => ({ rank: null, segmentIndex: null }));\n  }\n\n  getRankText(rankValue: RankValue, row: StaticRanklistRow) {\n    return rankValue.rank ? rankValue.rank : row.user.official === false ? '＊' : '';\n  }\n\n  resolveDisplayText(text: Parameters<typeof resolveText>[0]) {\n    return resolveText(text);\n  }\n\n  problemAlias(problem: srk.Problem, problemIndex: number) {\n    return problem.alias || numberToAlphabet(problemIndex);\n  }\n\n  problemStatsTitle(statistics: srk.ProblemStatistics) {\n    const ratio = statistics.submitted ? ((statistics.accepted / statistics.submitted) * 100).toFixed(1) : 0;\n    return `${statistics.accepted} / ${statistics.submitted} (${ratio}%)`;\n  }\n\n  problemHeaderBackgroundImage(problem: srk.Problem) {\n    return getProblemHeaderBackgroundImage(problem.style, this.theme);\n  }\n\n  resolvedUserMarkers(user: srk.User) {\n    return resolveUserMarkers(user, this.data.markers).map((marker) => ({\n      marker,\n      presentation: getMarkerPresentation(marker, this.theme),\n    }));\n  }\n\n  formatAssetUrl(url: string, field: string) {\n    return resolveSrkAssetUrl(url, field, this.formatSrkAssetUrl);\n  }\n\n  formatTime(time: Parameters<typeof formatTimeDuration>[0]) {\n    return formatTimeDuration(time, 'min', Math.floor);\n  }\n\n  acceptedStatusDetails(status: srk.RankProblemStatus) {\n    return getAcceptedStatusDetails(status);\n  }\n\n  isNumber(value: unknown): value is number {\n    return typeof value === 'number';\n  }\n\n  getStatusSolutions(status: srk.RankProblemStatus) {\n    return [...(status.solutions || [])].reverse();\n  }\n\n  statusCellClass(status: srk.RankProblemStatus) {\n    const classNames = ['srk-prest-status-block', 'srk--text-center', 'srk--nowrap'];\n    if (this.isStatusClickable(status)) {\n      classNames.push('srk--cursor-pointer');\n    }\n    if (status.result === 'FB') {\n      classNames.push('srk-prest-status-block-fb');\n    } else if (status.result === 'AC') {\n      classNames.push('srk-prest-status-block-accepted');\n    } else if (status.result === '?') {\n      classNames.push('srk-prest-status-block-frozen');\n    } else if (status.result === 'RJ') {\n      classNames.push('srk-prest-status-block-failed');\n    }\n    return classNames.join(' ');\n  }\n\n  isStatusClickable(status: srk.RankProblemStatus) {\n    return this.getStatusSolutions(status).length > 0;\n  }\n\n  statusCellRole(status: srk.RankProblemStatus) {\n    return this.isStatusClickable(status) ? 'button' : null;\n  }\n\n  statusCellTabIndex(status: srk.RankProblemStatus) {\n    return this.isStatusClickable(status) ? 0 : null;\n  }\n\n  buildUserCellContext(row: StaticRanklistRow, rowIndex: number): UserCellTemplateContext {\n    return {\n      $implicit: row.user,\n      user: row.user,\n      row,\n      rowIndex,\n      ranklist: this.data,\n      markers: this.data.markers,\n      onClick: (event?: MouseEvent) => this.emitUserClick(event, row, rowIndex),\n    };\n  }\n\n  buildStatusCellContext(\n    row: StaticRanklistRow,\n    rowIndex: number,\n    status: srk.RankProblemStatus,\n    problemIndex: number,\n  ): StatusCellTemplateContext {\n    return {\n      $implicit: status,\n      status,\n      problem: this.data.problems[problemIndex],\n      problemIndex,\n      user: row.user,\n      row,\n      rowIndex,\n      ranklist: this.data,\n      solutions: this.getStatusSolutions(status),\n      onClick: (event?: MouseEvent) => this.emitSolutionClick(event, row, rowIndex, status, problemIndex),\n    };\n  }\n\n  activateUserCellFromKeyboard(event: Event, row: StaticRanklistRow, rowIndex: number) {\n    event.preventDefault();\n    this.emitUserClick(undefined, row, rowIndex);\n  }\n\n  activateStatusCellFromKeyboard(\n    event: Event,\n    row: StaticRanklistRow,\n    rowIndex: number,\n    status: srk.RankProblemStatus,\n    problemIndex: number,\n  ) {\n    event.preventDefault();\n    this.emitSolutionClick(undefined, row, rowIndex, status, problemIndex);\n  }\n\n  emitUserClick(event: MouseEvent | undefined, row: StaticRanklistRow, rowIndex: number) {\n    if (event) {\n      captureModalTriggerPointFromMouseEvent(event, {\n        source: 'user-cell',\n        context: {\n          rowIndex,\n          userId: row.user.id || null,\n          userName: this.resolveDisplayText(row.user.name),\n        },\n      });\n    }\n    this.userClick.emit({\n      user: row.user,\n      row,\n      rowIndex,\n      ranklist: this.data,\n    });\n  }\n\n  emitSolutionClick(\n    event: MouseEvent | undefined,\n    row: StaticRanklistRow,\n    rowIndex: number,\n    status: srk.RankProblemStatus,\n    problemIndex: number,\n  ) {\n    const solutions = this.getStatusSolutions(status);\n    if (!solutions.length) {\n      return;\n    }\n    if (event) {\n      captureModalTriggerPointFromMouseEvent(event, {\n        source: 'status-cell',\n        context: {\n          rowIndex,\n          problemIndex,\n          problemAlias: this.data.problems[problemIndex]?.alias || null,\n          problemTitle: this.data.problems[problemIndex]?.title || null,\n          userId: row.user.id || null,\n        },\n      });\n    }\n    this.solutionClick.emit({\n      user: row.user,\n      row,\n      rowIndex,\n      problemIndex,\n      problem: this.data.problems[problemIndex],\n      status,\n      solutions,\n      ranklist: this.data,\n    });\n  }\n\n  private resolveSeriesSegment(rankValue: RankValue, series: srk.RankSeries | undefined) {\n    const index = rankValue.segmentIndex || rankValue.segmentIndex === 0 ? rankValue.segmentIndex : -1;\n    return (series?.segments || [])[index] || {};\n  }\n\n  getSeriesSegmentClass(rankValue: RankValue, series: srk.RankSeries | undefined) {\n    const segmentStyle = this.resolveSeriesSegment(rankValue, series).style;\n    return typeof segmentStyle === 'string' ? `srk-preset-series-segment-${segmentStyle}` : '';\n  }\n\n  getSeriesSegmentStyle(rankValue: RankValue, series: srk.RankSeries | undefined) {\n    const emptyColor: ThemeColor = {\n      [EnumTheme.light]: undefined,\n      [EnumTheme.dark]: undefined,\n    };\n    const segmentStyle = this.resolveSeriesSegment(rankValue, series).style;\n    if (!segmentStyle || typeof segmentStyle === 'string') {\n      return {};\n    }\n    const style = resolveStyle(segmentStyle);\n    const textColor = style.textColor || emptyColor;\n    const backgroundColor = style.backgroundColor || emptyColor;\n    return {\n      color: textColor[this.theme],\n      backgroundColor: backgroundColor[this.theme],\n    };\n  }\n}\n"]}