Skip to content

armgit / ente

Public Imported from GitHub
0

💚 End-to-end encrypted cloud for everything.

feat(gallery):show-viewer-download-progress-and-retry

Aswin Asok055b7d2803de
diff --git a/web/apps/albums/src/public-album/viewer/lib/photoswipe.ts b/web/apps/albums/src/public-album/viewer/lib/photoswipe.ts
index 7d8565dde4..d0e050e718 100644
--- a/web/apps/albums/src/public-album/viewer/lib/photoswipe.ts
+++ b/web/apps/albums/src/public-album/viewer/lib/photoswipe.ts
@@ -1,3 +1,4 @@
+import { downloadManager } from "@/public-album/download/services/download-manager";
import {
enteWordmarkSVGHTML,
enteWordmarkViewBox,
@@ -31,6 +32,10 @@ export type FileViewerPhotoSwipeOptions<
>;
const fileViewerPhotoSwipeDataSource = {
+ fileDownloadProgressSubscribe: (onChange: () => void) =>
+ downloadManager.fileDownloadProgressSubscribe(onChange),
+ fileDownloadProgressSnapshot: () =>
+ downloadManager.fileDownloadProgressSnapshot(),
fileViewerDidClose,
fileViewerWillOpen,
forgetExifForItemData,
diff --git a/web/apps/photos/tests/download-progress.test.ts b/web/apps/photos/tests/download-progress.test.ts
new file mode 100644
index 0000000000..21ee216355
--- /dev/null
+++ b/web/apps/photos/tests/download-progress.test.ts
@@ -0,0 +1,121 @@
+import { downloadProgressState } from "ente-gallery/components/viewer/download-progress";
+import { describe, expect, test } from "vitest";
+
+const loading = { isContentLoading: true };
+
+describe("downloadProgressState", () => {
+ test("keeps decrypting during the live-photo conversion tail", () => {
+ const downloaded = downloadProgressState(
+ loading,
+ { loaded: 100, total: 100 },
+ undefined,
+ );
+ expect(downloaded).toEqual({
+ phase: "decrypting",
+ pct: 100,
+ loaded: 100,
+ total: 100,
+ });
+ const tail = downloadProgressState(loading, undefined, downloaded);
+ expect(tail).toEqual({ phase: "decrypting", pct: 100 });
+ expect(downloadProgressState(loading, undefined, tail)).toEqual(tail);
+ });
+
+ test("prepares HLS auto video without a download entry, then hides", () => {
+ const preparing = downloadProgressState(loading, undefined, undefined);
+ expect(preparing).toEqual({ phase: "preparing", pct: 0 });
+ expect(downloadProgressState({}, undefined, preparing)).toBeUndefined();
+ });
+
+ test("hides cached content regardless of previous progress or an entry", () => {
+ expect(
+ downloadProgressState(
+ {},
+ { loaded: 30, total: 100 },
+ { phase: "downloading", pct: 30 },
+ ),
+ ).toBeUndefined();
+ expect(
+ downloadProgressState({}, undefined, { phase: "failed", pct: 70 }),
+ ).toBeUndefined();
+ });
+
+ test("clamps ciphertext exceeding the plaintext size fallback", () => {
+ expect(
+ downloadProgressState(
+ loading,
+ { loaded: 117, total: 100 },
+ undefined,
+ ),
+ ).toEqual({ phase: "decrypting", pct: 100, loaded: 117, total: 100 });
+ });
+
+ test("shows unknown totals as indeterminate and retains the download tail", () => {
+ const state = downloadProgressState(
+ loading,
+ { loaded: 30, total: undefined },
+ undefined,
+ );
+ expect(state).toEqual({
+ phase: "downloading",
+ pct: undefined,
+ loaded: 30,
+ });
+ expect(downloadProgressState(loading, undefined, state)).toEqual({
+ phase: "decrypting",
+ pct: 100,
+ });
+ });
+
+ test("failure takes precedence and keeps the previous percentage", () => {
+ expect(
+ downloadProgressState({ fetchFailed: true }, undefined, {
+ phase: "downloading",
+ pct: 42,
+ }),
+ ).toEqual({ phase: "failed", pct: 42 });
+ expect(
+ downloadProgressState(
+ { ...loading, fetchFailed: true },
+ { loaded: 100, total: 100 },
+ undefined,
+ ),
+ ).toEqual({ phase: "failed", pct: 0 });
+ });
+
+ test("retry ignores the previous failed percentage", () => {
+ expect(
+ downloadProgressState(loading, undefined, {
+ phase: "failed",
+ pct: 42,
+ }),
+ ).toEqual({ phase: "preparing", pct: 0 });
+ });
+
+ test("opens on an in-flight download without previous state", () => {
+ expect(
+ downloadProgressState(
+ loading,
+ { loaded: 30, total: 100 },
+ undefined,
+ ),
+ ).toEqual({ phase: "downloading", pct: 30, loaded: 30, total: 100 });
+ });
+
+ test("prepares a known total with no bytes and floors partial percentages", () => {
+ expect(
+ downloadProgressState(
+ loading,
+ { loaded: 0, total: 100 },
+ undefined,
+ ),
+ ).toEqual({ phase: "preparing", pct: 0 });
+ expect(
+ downloadProgressState(
+ loading,
+ { loaded: 9999, total: 10000 },
+ undefined,
+ )?.pct,
+ ).toBe(99);
+ });
+});
diff --git a/web/packages/base/locales/en-US/translation.json b/web/packages/base/locales/en-US/translation.json
index 07c7946b86..dd632cdfa3 100644
--- a/web/packages/base/locales/en-US/translation.json
+++ b/web/packages/base/locales/en-US/translation.json
@@ -942,6 +942,10 @@
"downloading_album": "Downloading {{name}}",
"creating_zip": "Creating ZIP for {{name}}",
"downloading": "Downloading",
+ "size_downloaded": "{{size}} downloaded",
+ "preparing_download": "Preparing download",
+ "decrypting": "Decrypting",
+ "couldnt_download": "Couldn't download",
"preparing_part": "Preparing Part {{part}}",
"downloading_part": "Downloading Part {{part}}",
"downloading_file": "Downloading file",
diff --git a/web/packages/gallery/components/viewer/download-progress.ts b/web/packages/gallery/components/viewer/download-progress.ts
new file mode 100644
index 0000000000..0e75355016
--- /dev/null
+++ b/web/packages/gallery/components/viewer/download-progress.ts
@@ -0,0 +1,49 @@
+import type { FileDownloadProgress } from "ente-gallery/services/download-core";
+import type { ItemData } from "./data-source-core";
+
+export type DownloadProgressPhase =
+ | "preparing"
+ | "downloading"
+ | "decrypting"
+ | "failed";
+
+export interface DownloadProgressState {
+ phase: DownloadProgressPhase;
+ pct: number | undefined;
+ loaded?: number;
+ total?: number;
+}
+
+export const downloadProgressState = (
+ itemData: Pick<ItemData, "isContentLoading" | "fetchFailed">,
+ entry: FileDownloadProgress | undefined,
+ previous: DownloadProgressState | undefined,
+): DownloadProgressState | undefined => {
+ if (itemData.fetchFailed)
+ return { phase: "failed", pct: previous?.pct ?? 0 };
+ if (!itemData.isContentLoading) return undefined;
+
+ if (entry) {
+ const { loaded, total } = entry;
+ if (total !== undefined && total > 0) {
+ if (loaded >= total)
+ return { phase: "decrypting", pct: 100, loaded, total };
+ if (loaded > 0)
+ return {
+ phase: "downloading",
+ pct: Math.min(99, Math.floor((loaded * 100) / total)),
+ loaded,
+ total,
+ };
+ return { phase: "preparing", pct: 0 };
+ }
+ if (total === undefined && loaded > 0)
+ return { phase: "downloading", pct: undefined, loaded };
+ } else if (
+ previous?.phase == "downloading" ||
+ previous?.phase == "decrypting"
+ ) {
+ return { phase: "decrypting", pct: 100 };
+ }
+ return { phase: "preparing", pct: 0 };
+};
diff --git a/web/packages/gallery/components/viewer/photoswipe-core.ts b/web/packages/gallery/components/viewer/photoswipe-core.ts
index 68d3e57290..7a919872c7 100644
--- a/web/packages/gallery/components/viewer/photoswipe-core.ts
+++ b/web/packages/gallery/components/viewer/photoswipe-core.ts
@@ -1,5 +1,7 @@
import { isNamedError } from "ente-base/error";
import log from "ente-base/log";
+import type { FileDownloadProgress } from "ente-gallery/services/download-core";
+import { formattedByteSize } from "ente-gallery/utils/units";
import type { EnteFile } from "ente-media/file";
import { FileType } from "ente-media/file-type";
import "hls-video-element";
@@ -10,6 +12,10 @@ import "media-chrome/menu";
import { MediaChromeMenu, MediaChromeMenuButton } from "media-chrome/menu";
import PhotoSwipe, { type SlideData } from "photoswipe";
import type { ItemData, ItemDataOpts } from "./data-source-core";
+import {
+ downloadProgressState,
+ type DownloadProgressState,
+} from "./download-progress";
import {
commentSVGPath,
createPSRegisterElementIconHTML,
@@ -28,6 +34,11 @@ export interface FileViewerPhotoSwipeAnnotatedFile {
}
export interface FileViewerPhotoSwipeDataSource {
+ fileDownloadProgressSubscribe: (onChange: () => void) => () => void;
+ fileDownloadProgressSnapshot: () => ReadonlyMap<
+ number,
+ FileDownloadProgress
+ >;
fileViewerDidClose: () => void;
fileViewerWillOpen: () => void;
forgetExifForItemData: (itemData: ItemData) => void;
@@ -792,6 +803,12 @@ export class FileViewerPhotoSwipe<
if (currentFileAnnotation().showDownload) handleDownload();
};
+ const refetchCurrentSlide = (fileID: number) => {
+ dataSource.forgetItemDataForFileID(fileID);
+ _currentAnnotatedFile = undefined;
+ pswp.refreshSlideContent(pswp.currIndex);
+ };
+
const onVideoQualityChange = () => {
if (shouldIgnoreNextVideoQualityChange) {
shouldIgnoreNextVideoQualityChange = false;
@@ -801,14 +818,13 @@ export class FileViewerPhotoSwipe<
toggleMediaChromeSettingsMenu();
const fileID = currentAnnotatedFile().file.id;
- dataSource.forgetItemDataForFileID(fileID);
if (originalVideoFileIDs.has(fileID)) {
originalVideoFileIDs.delete(fileID);
} else {
originalVideoFileIDs.add(fileID);
}
- pswp.refreshSlideContent(pswp.currIndex);
+ refetchCurrentSlide(fileID);
};
const showIf = (element: HTMLElement, condition: boolean) =>
@@ -816,11 +832,236 @@ export class FileViewerPhotoSwipe<
? element.classList.remove("pswp__hidden")
: element.classList.add("pswp__hidden");
+ let unsubscribeDownloadProgress: (() => void) | undefined;
+ let downloadProgressTimer: ReturnType<typeof setTimeout> | undefined;
+
pswp.on("uiRegister", () => {
const ui = pswp.ui!;
ui.uiElementsData.find((e) => e.name == "zoom")!.order = 6;
- ui.uiElementsData.find((e) => e.name == "preloader")!.order = 10;
+ const preloaderIndex = ui.uiElementsData.findIndex(
+ (e) => e.name == "preloader",
+ );
+ if (preloaderIndex != -1)
+ ui.uiElementsData.splice(preloaderIndex, 1);
+
+ const lastProgressByFileID = new Map<
+ number,
+ DownloadProgressState
+ >();
+ const compactProgress = window.matchMedia("(width < 450px)");
+ let progressText: HTMLElement;
+ let progressValue: HTMLElement;
+ let progressRing: SVGCircleElement;
+ let progressBar: HTMLElement;
+ let fill: HTMLElement;
+ let pct: HTMLElement;
+ let status: HTMLElement;
+ let separator: HTMLElement;
+ let size: HTMLElement;
+ let retry: HTMLButtonElement;
+ let progressClosed = false;
+
+ const setText = (element: HTMLElement, text: string) => {
+ if (element.textContent != text) element.textContent = text;
+ };
+ const setAttribute = (
+ element: HTMLElement,
+ name: string,
+ value: string | undefined,
+ ) => {
+ if (element.getAttribute(name) == (value ?? null)) return;
+ if (value === undefined) element.removeAttribute(name);
+ else element.setAttribute(name, value);
+ };
+ const rememberDownloadProgress = () => {
+ if (progressClosed || !pswp.currSlide) return;
+ const itemData = currSlideData();
+ const { fileID } = itemData;
+ const state = downloadProgressState(
+ itemData,
+ dataSource.fileDownloadProgressSnapshot().get(fileID),
+ lastProgressByFileID.get(fileID),
+ );
+ if (state) lastProgressByFileID.set(fileID, state);
+ else lastProgressByFileID.delete(fileID);
+ return state;
+ };
+ const renderDownloadProgress = () => {
+ if (progressClosed || !pswp.currSlide) return;
+ const state = rememberDownloadProgress();
+
+ const failed = state?.phase == "failed";
+ const pctText = state?.pct === undefined ? "" : `${state.pct}%`;
+ const statusText = state
+ ? t(
+ {
+ preparing: "preparing_download",
+ downloading: "downloading",
+ decrypting: "decrypting",
+ failed: "couldnt_download",
+ }[state.phase],
+ )
+ : "";
+ const sizeText =
+ state?.phase != "preparing" &&
+ state?.total !== undefined &&
+ state.loaded !== undefined
+ ? compactProgress.matches
+ ? t("size_downloaded", {
+ size: `${formattedByteSize(state.loaded, 1)} / ${formattedByteSize(state.total, 1)}`,
+ })
+ : `${formattedByteSize(state.loaded, 1)} / ${formattedByteSize(state.total, 1)}`
+ : "";
+ setText(pct, pctText);
+ setText(status, statusText);
+ setText(size, sizeText);
+ setText(retry, t("retry"));
+ size.hidden = !sizeText;
+ separator.hidden = !(sizeText || failed);
+ retry.hidden = !failed;
+ fill.style.width = `${Math.max(state?.pct ?? 0, 1)}%`;
+ progressRing.style.strokeDashoffset = `${100 - (state?.pct ?? 0)}`;
+ for (const [element, prefix] of [
+ [progressText, "pswp__ente-progress-text"],
+ [progressValue, "pswp__ente-progress-overlay"],
+ [progressBar, "pswp__ente-progress-bar"],
+ ] as const) {
+ element.classList.toggle(`${prefix}--active`, !!state);
+ element.classList.toggle(`${prefix}--failed`, failed);
+ element.classList.toggle(
+ `${prefix}--indeterminate`,
+ !!state && state.pct === undefined,
+ );
+ }
+ setAttribute(
+ progressText,
+ "aria-hidden",
+ state ? undefined : "true",
+ );
+ setAttribute(
+ progressValue,
+ "aria-hidden",
+ state ? undefined : "true",
+ );
+ setAttribute(
+ progressValue,
+ "aria-valuenow",
+ state?.pct?.toString(),
+ );
+ setAttribute(
+ progressValue,
+ "aria-valuetext",
+ [
+ pctText,
+ !(compactProgress.matches && sizeText) && statusText,
+ !compactProgress.matches && (sizeText || failed) && "·",
+ sizeText,
+ failed && t("retry"),
+ ]
+ .filter(Boolean)
+ .join(" "),
+ );
+ };
+
+ ui.registerElement({
+ name: "ente-progress-text",
+ order: 10,
+ isButton: false,
+ html: `<span class="pswp__ente-progress-status"></span>
+<span class="pswp__ente-progress-separator" hidden>·</span>
+<span class="pswp__ente-progress-size" hidden></span>
+<button type="button" class="pswp__ente-progress-retry" hidden></button>`,
+ onInit: (element) => {
+ progressText = element;
+ status = element.querySelector<HTMLElement>(
+ ".pswp__ente-progress-status",
+ )!;
+ separator = element.querySelector<HTMLElement>(
+ ".pswp__ente-progress-separator",
+ )!;
+ size = element.querySelector<HTMLElement>(
+ ".pswp__ente-progress-size",
+ )!;
+ retry = element.querySelector<HTMLButtonElement>(
+ ".pswp__ente-progress-retry",
+ )!;
+ retry.addEventListener("click", () => {
+ const { fileID } = currSlideData();
+ lastProgressByFileID.delete(fileID);
+ refetchCurrentSlide(fileID);
+ });
+ },
+ });
+ ui.registerElement({
+ name: "ente-progress-overlay",
+ appendTo: "root",
+ order: 10,
+ isButton: false,
+ html: `<svg class="pswp__ente-progress-ring" viewBox="0 0 48 48" aria-hidden="true">
+<circle cx="24" cy="24" r="20" pathLength="100" />
+</svg>
+<span class="pswp__ente-progress-pct"></span>`,
+ onInit: (element) => {
+ progressValue = element;
+ progressRing = element.querySelector("circle")!;
+ pct = element.querySelector<HTMLElement>(
+ ".pswp__ente-progress-pct",
+ )!;
+ element.setAttribute("role", "progressbar");
+ element.setAttribute("aria-label", t("download"));
+ element.setAttribute("aria-valuemin", "0");
+ element.setAttribute("aria-valuemax", "100");
+ element.setAttribute("aria-hidden", "true");
+ },
+ });
+ ui.registerElement({
+ name: "ente-progress-bar",
+ appendTo: "root",
+ order: 0,
+ html: '<div class="pswp__ente-progress-fill"></div>',
+ onInit: (element) => {
+ progressBar = element;
+ fill = element.querySelector<HTMLElement>(
+ ".pswp__ente-progress-fill",
+ )!;
+ element.setAttribute("aria-hidden", "true");
+ const unsubscribe =
+ dataSource.fileDownloadProgressSubscribe(() => {
+ const state = rememberDownloadProgress();
+ if (!state || downloadProgressTimer !== undefined)
+ return;
+ downloadProgressTimer = setTimeout(() => {
+ downloadProgressTimer = undefined;
+ renderDownloadProgress();
+ }, 400);
+ });
+ compactProgress.addEventListener(
+ "change",
+ renderDownloadProgress,
+ );
+ unsubscribeDownloadProgress = () => {
+ unsubscribe();
+ compactProgress.removeEventListener(
+ "change",
+ renderDownloadProgress,
+ );
+ };
+ pswp.on("change", renderDownloadProgress);
+ pswp.on("close", () => {
+ progressClosed = true;
+ progressBar.classList.remove(
+ "pswp__ente-progress-bar--active",
+ );
+ progressText.classList.remove(
+ "pswp__ente-progress-text--active",
+ );
+ progressValue.classList.remove(
+ "pswp__ente-progress-overlay--active",
+ );
+ });
+ },
+ });
if (isPublicAlbum && publicAlbumLogoHTML) {
ui.registerElement({
@@ -1317,6 +1558,9 @@ export class FileViewerPhotoSwipe<
});
pswp.on("destroy", () => {
+ unsubscribeDownloadProgress?.();
+ if (downloadProgressTimer !== undefined)
+ clearTimeout(downloadProgressTimer);
pswp.element?.removeEventListener(
"mousedown",
blurMediaChromeFocus,
diff --git a/web/packages/gallery/components/viewer/photoswipe.ts b/web/packages/gallery/components/viewer/photoswipe.ts
index 736e9717b6..1ac2ad8a6f 100644
--- a/web/packages/gallery/components/viewer/photoswipe.ts
+++ b/web/packages/gallery/components/viewer/photoswipe.ts
@@ -1,3 +1,4 @@
+import { downloadManager } from "ente-gallery/services/download";
import {
fileViewerDidClose,
fileViewerWillOpen,
@@ -27,6 +28,10 @@ export type FileViewerPhotoSwipeOptions<
>;
const fileViewerPhotoSwipeDataSource = {
+ fileDownloadProgressSubscribe: (onChange: () => void) =>
+ downloadManager.fileDownloadProgressSubscribe(onChange),
+ fileDownloadProgressSnapshot: () =>
+ downloadManager.fileDownloadProgressSnapshot(),
fileViewerDidClose,
fileViewerWillOpen,
forgetExifForItemData,
diff --git a/web/packages/gallery/styles/photoswipe.css b/web/packages/gallery/styles/photoswipe.css
index 2460a27468..3db2de9717 100644
--- a/web/packages/gallery/styles/photoswipe.css
+++ b/web/packages/gallery/styles/photoswipe.css
@@ -44,10 +44,6 @@
pointer-events: auto;
}
-.pswp-ente .pswp__preloader--active .pswp__icn {
- opacity: 0.4;
-}
-
.pswp-ente .pswp__error {
position: relative;
overflow: hidden;
@@ -106,10 +102,6 @@
}
}
-.pswp-ente .pswp__preloader {
- transform: translate(-2px, 2px);
-}
-
.pswp-ente .pswp__error {
transform: translate(-2px, 2px);
}
@@ -529,3 +521,218 @@ body:has(
#pswp__icn-heart.pswp__hidden {
display: none;
}
+
+.pswp.pswp-ente .pswp__ente-progress-bar {
+ position: absolute;
+ top: calc(env(titlebar-area-height, 0px) * 0.4);
+ left: 0;
+ right: 0;
+ height: 3px;
+ background: rgb(255 255 255 / 0.16);
+ pointer-events: none;
+ opacity: 0;
+ transition: opacity 160ms linear;
+ transition-delay: 0ms;
+}
+
+.pswp.pswp-ente .pswp__ente-progress-bar--active {
+ opacity: 1;
+ transition-delay: 400ms;
+}
+
+.pswp-ente .pswp__ente-progress-fill {
+ height: 3px;
+ width: 1%;
+ background: var(--mui-palette-fixed-success);
+ transition: width 400ms linear;
+}
+
+.pswp-ente .pswp__ente-progress-bar--failed .pswp__ente-progress-fill {
+ background: var(--mui-palette-fixed-danger-main);
+}
+
+.pswp-ente .pswp__ente-progress-bar--indeterminate .pswp__ente-progress-fill {
+ animation: ente-progress-pulse 1s ease-in-out infinite alternate;
+}
+
+@keyframes ente-progress-pulse {
+ to {
+ opacity: 0.35;
+ }
+}
+
+.pswp-ente .pswp__ente-progress-text {
+ margin-inline-start: 6px;
+ margin-top: 22px;
+ margin-inline-end: auto;
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ height: 20px;
+ min-width: 0;
+ overflow: hidden;
+ white-space: nowrap;
+ text-shadow: 0 1px 3px rgb(0 0 0 / 0.6);
+ font-size: 13px;
+ line-height: 20px;
+ color: rgb(255 255 255 / 0.6);
+ opacity: 0;
+ visibility: hidden;
+ transition: opacity 160ms linear;
+ transition-delay: 0ms;
+}
+
+.pswp-ente .pswp__ente-progress-text--active {
+ opacity: 1;
+ visibility: visible;
+ transition-delay: 400ms;
+}
+
+.pswp-ente .pswp__ente-progress-status,
+.pswp-ente .pswp__ente-progress-size {
+ min-width: 0;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ flex: 0 1 auto;
+}
+
+.pswp-ente
+ .pswp__ente-progress-text--active:not(.pswp__ente-progress-text--failed)
+ .pswp__ente-progress-status::after {
+ content: "";
+ display: inline-block;
+ width: 1.2em;
+ text-align: left;
+ animation: ente-progress-dots 1.2s steps(1, end) infinite;
+
+ @media (prefers-reduced-motion: reduce) {
+ content: "…";
+ animation: none;
+ }
+}
+
+@keyframes ente-progress-dots {
+ 0%,
+ 100% {
+ content: "";
+ }
+ 25% {
+ content: ".";
+ }
+ 50% {
+ content: "..";
+ }
+ 75% {
+ content: "...";
+ }
+}
+
+.pswp-ente .pswp__ente-progress-separator,
+.pswp-ente .pswp__ente-progress-retry {
+ flex-shrink: 0;
+}
+
+.pswp.pswp-ente .pswp__ente-progress-overlay {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ transform: translate(-50%, -50%);
+ display: grid;
+ place-items: center;
+ box-sizing: border-box;
+ width: 48px;
+ height: 48px;
+ border: 1px solid rgb(255 255 255 / 0.16);
+ border-radius: 50%;
+ background: rgb(0 0 0 / 0.3);
+ pointer-events: none;
+ opacity: 0;
+ visibility: hidden;
+ transition: opacity 160ms linear;
+}
+
+.pswp.pswp-ente .pswp__ente-progress-overlay--active {
+ opacity: 1;
+ visibility: visible;
+ transition-delay: 400ms;
+}
+
+.pswp-ente .pswp__ente-progress-ring {
+ position: absolute;
+ width: 100%;
+ height: 100%;
+ transform: rotate(-90deg);
+ fill: none;
+ stroke: var(--mui-palette-fixed-success);
+ stroke-width: 2;
+ stroke-linecap: round;
+ stroke-dasharray: 100;
+}
+
+.pswp-ente .pswp__ente-progress-overlay--failed .pswp__ente-progress-ring {
+ stroke: var(--mui-palette-fixed-danger-main);
+}
+
+.pswp-ente
+ .pswp__ente-progress-overlay--indeterminate
+ .pswp__ente-progress-ring {
+ stroke-dasharray: 25 75;
+ animation: ente-progress-spin 1s linear infinite;
+}
+
+@keyframes ente-progress-spin {
+ to {
+ transform: rotate(270deg);
+ }
+}
+
+.pswp-ente .pswp__ente-progress-pct {
+ color: #fff;
+ font-size: 11px;
+ font-weight: 600;
+ font-variant-numeric: tabular-nums;
+}
+
+.pswp-ente .pswp__ente-progress-size {
+ font-variant-numeric: tabular-nums;
+}
+
+.pswp-ente .pswp__ente-progress-retry {
+ border: 0;
+ padding: 0;
+ background: none;
+ color: #fff;
+ font: inherit;
+ text-shadow: inherit;
+ cursor: pointer;
+}
+
+.pswp-ente .pswp__ente-progress-retry:hover {
+ text-decoration: underline;
+}
+
+@media (width < 450px) {
+ .pswp-ente .pswp__ente-progress-text::before {
+ content: "·";
+ flex-shrink: 0;
+ color: rgb(255 255 255 / 0.4);
+ }
+
+ .pswp-ente
+ .pswp__ente-progress-text:has(.pswp__ente-progress-size:not([hidden]))
+ .pswp__ente-progress-status,
+ .pswp-ente .pswp__ente-progress-separator {
+ display: none;
+ }
+}
+
+@media (prefers-reduced-motion: reduce) {
+ .pswp.pswp-ente .pswp__ente-progress-bar,
+ .pswp.pswp-ente .pswp__ente-progress-overlay,
+ .pswp.pswp-ente .pswp__ente-progress-ring,
+ .pswp-ente .pswp__ente-progress-text,
+ .pswp.pswp-ente .pswp__ente-progress-fill {
+ transition: none;
+ animation: none;
+ }
+}