Upload folder using huggingface_hub

6.16.0/statustracker/index.ts

@@ -0,0 +1,7 @@
+export { default as StatusTracker } from "./static/index.svelte";
+export { default as Toast } from "./static/Toast.svelte";
+export { default as Loader } from "./static/Loader.svelte";
+export { default as StreamingBar } from "./static/StreamingBar.svelte";
+export type * from "./static/types";
+export { default } from "./static/index.svelte";
+export { LoadingStatus } from "./static/state.svelte.js";

6.16.0/statustracker/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@gradio/statustracker",
+	"version": "0.14.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"main": "./index.ts",
+	"author": "",
+	"license": "ISC",
+	"main_changeset": true,
+	"exports": {
+		".": {
+			"gradio": "./index.ts",
+			"svelte": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/sanitize": "^0.2.0",
+		"@gradio/utils": "workspace:^"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/statustracker"
+	}
+}

6.16.0/statustracker/static/Loader.svelte

@@ -0,0 +1,107 @@
+<script lang="ts">
+	import { spring } from "svelte/motion";
+
+	interface Props {
+		margin?: boolean;
+	}
+
+	let { margin = true }: Props = $props();
+
+	const top = spring([0, 0]);
+	const bottom = spring([0, 0]);
+
+	let dismounted = $state(false);
+
+	async function animate(): Promise<void> {
+		await Promise.all([top.set([125, 140]), bottom.set([-125, -140])]);
+		await Promise.all([top.set([-125, 140]), bottom.set([125, -140])]);
+		await Promise.all([top.set([-125, 0]), bottom.set([125, -0])]);
+		await Promise.all([top.set([125, 0]), bottom.set([-125, 0])]);
+	}
+
+	async function run(): Promise<void> {
+		await animate();
+		if (!dismounted) run();
+	}
+
+	async function loading(): Promise<void> {
+		await Promise.all([top.set([125, 0]), bottom.set([-125, 0])]);
+
+		run();
+	}
+
+	$effect(() => {
+		loading();
+		return () => {
+			dismounted = true;
+		};
+	});
+</script>
+
+<div class:margin>
+	<svg
+		viewBox="-1200 -1200 3000 3000"
+		fill="none"
+		xmlns="http://www.w3.org/2000/svg"
+	>
+		<g style="transform: translate({$top[0]}px, {$top[1]}px);">
+			<path
+				d="M255.926 0.754768L509.702 139.936V221.027L255.926 81.8465V0.754768Z"
+				fill="#FF7C00"
+				fill-opacity="0.4"
+			/>
+			<path
+				d="M509.69 139.936L254.981 279.641V361.255L509.69 221.55V139.936Z"
+				fill="#FF7C00"
+			/>
+			<path
+				d="M0.250138 139.937L254.981 279.641V361.255L0.250138 221.55V139.937Z"
+				fill="#FF7C00"
+				fill-opacity="0.4"
+			/>
+			<path
+				d="M255.923 0.232622L0.236328 139.936V221.55L255.923 81.8469V0.232622Z"
+				fill="#FF7C00"
+			/>
+		</g>
+		<g style="transform: translate({$bottom[0]}px, {$bottom[1]}px);">
+			<path
+				d="M255.926 141.5L509.702 280.681V361.773L255.926 222.592V141.5Z"
+				fill="#FF7C00"
+				fill-opacity="0.4"
+			/>
+			<path
+				d="M509.69 280.679L254.981 420.384V501.998L509.69 362.293V280.679Z"
+				fill="#FF7C00"
+			/>
+			<path
+				d="M0.250138 280.681L254.981 420.386V502L0.250138 362.295V280.681Z"
+				fill="#FF7C00"
+				fill-opacity="0.4"
+			/>
+			<path
+				d="M255.923 140.977L0.236328 280.68V362.294L255.923 222.591V140.977Z"
+				fill="#FF7C00"
+			/>
+		</g>
+	</svg>
+</div>
+
+<style>
+	svg {
+		width: var(--size-20);
+		height: var(--size-20);
+	}
+
+	svg path {
+		fill: var(--loader-color);
+	}
+
+	div {
+		z-index: var(--layer-2);
+	}
+
+	.margin {
+		margin: var(--size-4);
+	}
+</style>

6.16.0/statustracker/static/StreamingBar.svelte

@@ -0,0 +1,33 @@
+<script lang="ts">
+	interface Props {
+		time_limit: number | null;
+	}
+
+	let { time_limit }: Props = $props();
+</script>
+
+{#if time_limit}
+	<div class="streaming-bar" style:animation-duration="{time_limit}s"></div>
+{/if}
+
+<style>
+	.streaming-bar {
+		position: absolute;
+		bottom: 0;
+		left: 0;
+		right: 0;
+		height: 4px;
+		background-color: var(--primary-600);
+		animation: countdown linear forwards;
+		z-index: 1;
+	}
+
+	@keyframes countdown {
+		from {
+			transform: translateX(0%);
+		}
+		to {
+			transform: translateX(-100%);
+		}
+	}
+</style>

6.16.0/statustracker/static/Toast.svelte

@@ -0,0 +1,105 @@
+<script lang="ts">
+	import type { ToastMessage, GroupedToastMessage } from "./types";
+	import ToastContent from "./ToastContent.svelte";
+	import { spring } from "svelte/motion";
+
+	interface Props {
+		messages?: ToastMessage[];
+		on_close: (id: number) => void;
+	}
+
+	let { messages = [], on_close }: Props = $props();
+	const top = spring(0, { stiffness: 0.4, damping: 0.5 });
+
+	let grouped_messages: GroupedToastMessage[] = $state([]);
+
+	$effect(() => {
+		scroll_to_top(messages);
+	});
+
+	$effect(() => {
+		grouped_messages = group_messages(messages);
+	});
+
+	function group_messages(msgs: ToastMessage[]): GroupedToastMessage[] {
+		const groups = new Map<string, GroupedToastMessage>();
+
+		msgs.forEach((msg) => {
+			const key = msg.type;
+			if (!groups.has(key)) {
+				groups.set(key, {
+					type: msg.type,
+					messages: [],
+					expanded: true
+				});
+			}
+			groups.get(key)!.messages.push(msg);
+		});
+
+		return Array.from(groups.values());
+	}
+
+	function scroll_to_top(_messages: ToastMessage[]): void {
+		if (_messages.length > 0) {
+			if ("parentIFrame" in window) {
+				window.parentIFrame?.getPageInfo((page_info) => {
+					if (page_info.scrollTop < page_info.offsetTop) {
+						top.set(0);
+					} else {
+						top.set(page_info.scrollTop - page_info.offsetTop);
+					}
+				});
+			}
+		}
+	}
+
+	function toggle_group(type: string): void {
+		grouped_messages = grouped_messages.map((group) => {
+			if (group.type === type) {
+				return { ...group, expanded: !group.expanded };
+			}
+			return group;
+		});
+	}
+</script>
+
+<div class="toast-wrap" style="--toast-top: {$top}px;">
+	{#each grouped_messages as group (group.type)}
+		<div class="toast-item">
+			<ToastContent
+				type={group.type}
+				messages={group.messages}
+				expanded={group.expanded}
+				ontoggle={() => toggle_group(group.type)}
+				onclose={(id) => on_close(id)}
+			/>
+		</div>
+	{/each}
+</div>
+
+<style>
+	.toast-wrap {
+		--toast-top: var(--size-4);
+		display: flex;
+		position: fixed;
+		top: calc(var(--toast-top) + var(--size-3));
+		flex-direction: column;
+		gap: var(--size-2);
+		z-index: var(--layer-top);
+		right: var(--size-3);
+		left: var(--size-3);
+		align-items: end;
+		max-width: none;
+	}
+
+	.toast-item {
+		width: 100%;
+	}
+
+	@media (min-width: 640px) {
+		.toast-wrap {
+			left: auto;
+			width: calc(var(--size-96) + var(--size-10));
+		}
+	}
+</style>

6.16.0/statustracker/static/ToastContent.svelte

@@ -0,0 +1,396 @@
+<script lang="ts">
+	import { Error, Info, Warning, Success, ChevronDown } from "@gradio/icons";
+	import { sanitize } from "@gradio/sanitize";
+	import { fade, slide } from "svelte/transition";
+	import type { ToastMessage } from "./types";
+
+	interface Props {
+		type: ToastMessage["type"];
+		messages?: ToastMessage[];
+		expanded?: boolean;
+		ontoggle?: () => void;
+		onclose?: (id: number) => void;
+	}
+
+	let {
+		type,
+		messages = [],
+		expanded = true,
+		ontoggle,
+		onclose
+	}: Props = $props();
+
+	let touch_start_x = $state(0);
+	let touch_start_y = $state(0);
+	let offset_x = $state(0);
+	let is_dragging = $state(false);
+	let toast_element: HTMLElement;
+
+	const default_messages: Record<ToastMessage["type"], string> = {
+		error: "An error occurred.",
+		warning: "Warning.",
+		success: "Success.",
+		info: "Info."
+	};
+
+	let count = $derived(messages.length);
+	let first_message = $derived(messages[0]);
+	let type_label = $derived(type.charAt(0).toUpperCase() + type.slice(1));
+	let has_duration = $derived(first_message?.duration !== null);
+	let timer_duration = $derived(
+		has_duration ? `${first_message.duration}s` : "0s"
+	);
+
+	function handle_toggle(): void {
+		ontoggle?.();
+	}
+
+	function close_all(): void {
+		messages.forEach((msg) => {
+			onclose?.(msg.id);
+		});
+	}
+
+	function handle_touch_start(e: TouchEvent): void {
+		touch_start_x = e.touches[0].clientX;
+		touch_start_y = e.touches[0].clientY;
+		is_dragging = true;
+	}
+
+	function handle_touch_move(e: TouchEvent): void {
+		if (!is_dragging) return;
+
+		const touch_x = e.touches[0].clientX;
+		const touch_y = e.touches[0].clientY;
+		const delta_x = touch_x - touch_start_x;
+		const delta_y = touch_y - touch_start_y;
+
+		if (Math.abs(delta_x) > Math.abs(delta_y) && Math.abs(delta_x) > 10) {
+			e.preventDefault();
+			offset_x = delta_x;
+		}
+	}
+
+	function handle_touch_end(): void {
+		if (!is_dragging) return;
+
+		if (Math.abs(offset_x) > 100) {
+			close_all();
+		} else {
+			offset_x = 0;
+		}
+
+		is_dragging = false;
+	}
+
+	$effect(() => {
+		if (has_duration && messages.length === 1) {
+			setTimeout(close_all, first_message.duration! * 1000);
+		}
+	});
+</script>
+
+<div
+	bind:this={toast_element}
+	class="toast-body {type}"
+	role="status"
+	aria-live="polite"
+	data-testid="toast-body"
+	ontouchstart={handle_touch_start}
+	ontouchmove={handle_touch_move}
+	ontouchend={handle_touch_end}
+	in:fade={{ duration: 200, delay: 100 }}
+	out:fade={{ duration: 200 }}
+	style="transform: translateX({offset_x}px); opacity: {1 -
+		Math.abs(offset_x) / 300};"
+>
+	<div
+		class="toast-header"
+		onclick={handle_toggle}
+		role="button"
+		tabindex="0"
+		onkeydown={(e) => {
+			if (e.key === "Enter" || e.key === " ") {
+				handle_toggle();
+			}
+		}}
+	>
+		<div class="toast-icon {type}">
+			{#if type === "warning"}
+				<Warning />
+			{:else if type === "info"}
+				<Info />
+			{:else if type === "success"}
+				<Success />
+			{:else if type === "error"}
+				<Error />
+			{/if}
+		</div>
+
+		<div class="toast-title-row">
+			<span class="toast-title {type}">
+				{type_label}
+				{#if count > 1}
+					<span class="toast-count">({count})</span>
+				{/if}
+			</span>
+			<div class="chevron" class:expanded class:visible={count > 0}>
+				<ChevronDown />
+			</div>
+		</div>
+
+		<button
+			onclick={(e) => {
+				e.stopPropagation();
+				close_all();
+			}}
+			class="toast-close {type}"
+			type="button"
+			aria-label="Close"
+			data-testid="toast-close"
+		>
+			<span aria-hidden="true">&#215;</span>
+		</button>
+	</div>
+
+	{#if expanded}
+		<div class="toast-messages" transition:slide={{ duration: 200 }}>
+			{#each messages as message, i (message.id)}
+				<div class="toast-message-item {type}">
+					<div class="toast-message-text {type}" data-testid="toast-text">
+						{@html sanitize(message.message || default_messages[type])}
+					</div>
+				</div>
+				{#if i < messages.length - 1}
+					<div class="toast-separator" />
+				{/if}
+			{/each}
+		</div>
+	{/if}
+
+	{#if has_duration}
+		<div class="timer {type}" style="animation-duration: {timer_duration}" />
+	{/if}
+</div>
+
+<!-- s-csdrBJqpTpqa  -->
+<style>
+	.toast-body {
+		display: flex;
+		flex-direction: column;
+		position: relative;
+		right: 0;
+		left: 0;
+		margin: auto;
+		border-radius: var(--radius-sm);
+		overflow: hidden;
+		pointer-events: auto;
+		background: var(--background-fill-secondary);
+		border: 1px solid var(--border-color-primary);
+		box-shadow: var(--shadow-drop);
+		touch-action: pan-y;
+		user-select: none;
+	}
+
+	:global(.dark) .toast-body {
+		background: var(--background-fill-primary);
+	}
+
+	.toast-body.error {
+		--toast-color: var(--color-red-700);
+	}
+
+	.toast-body.warning {
+		--toast-color: var(--color-yellow-700);
+	}
+
+	.toast-body.info {
+		--toast-color: var(--color-grey-700);
+	}
+
+	.toast-body.success {
+		--toast-color: var(--color-green-700);
+	}
+
+	:global(.dark) .toast-body.error {
+		--toast-color: var(--color-red-500);
+	}
+
+	:global(.dark) .toast-body.warning {
+		--toast-color: var(--color-yellow-500);
+	}
+
+	:global(.dark) .toast-body.info {
+		--toast-color: var(--color-grey-500);
+	}
+
+	:global(.dark) .toast-body.success {
+		--toast-color: var(--color-green-500);
+	}
+
+	.toast-header {
+		display: flex;
+		align-items: center;
+		padding: var(--size-3) var(--size-3);
+		cursor: pointer;
+	}
+
+	.toast-header:hover {
+		opacity: 0.9;
+	}
+
+	.toast-title-row {
+		flex: 1;
+		display: flex;
+		align-items: center;
+		gap: var(--size-2);
+	}
+
+	.chevron {
+		display: flex;
+		align-items: center;
+		width: var(--size-4);
+		height: var(--size-4);
+		transition: transform 0.2s ease;
+		opacity: 0.6;
+	}
+
+	.chevron.visible {
+		opacity: 1;
+	}
+
+	.chevron.expanded {
+		transform: rotate(180deg);
+	}
+
+	.toast-title {
+		display: flex;
+		align-items: center;
+		font-weight: var(--weight-bold);
+		font-size: var(--text-lg);
+		line-height: var(--line-sm);
+	}
+
+	.toast-count {
+		margin-left: var(--size-1);
+		font-weight: var(--weight-semibold);
+	}
+
+	.toast-close {
+		margin: 0 var(--size-1);
+		border-radius: var(--radius-lg);
+		padding: var(--size-1);
+		font-size: var(--text-xl);
+		line-height: 1;
+		background: transparent;
+		border: none;
+		cursor: pointer;
+		transition: all 0.2s ease;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: var(--size-7);
+		height: var(--size-7);
+		opacity: 0.6;
+		flex-shrink: 0;
+	}
+
+	.toast-close:hover {
+		opacity: 1;
+		transform: scale(1.1);
+	}
+
+	.toast-close:active {
+		transform: scale(0.95);
+	}
+
+	.toast-close {
+		color: var(--body-text-color);
+	}
+
+	.toast-icon {
+		display: flex;
+		position: relative;
+		flex-shrink: 0;
+		justify-content: center;
+		align-items: center;
+		margin-right: var(--size-2);
+		border-radius: var(--radius-full);
+		padding: var(--size-1-5);
+		width: var(--size-8);
+		height: var(--size-8);
+	}
+
+	.toast-icon {
+		color: var(--toast-color);
+	}
+
+	.toast-messages {
+		display: flex;
+		flex-direction: column;
+		gap: var(--size-2);
+		padding: 0 var(--size-3) var(--size-2) var(--size-3);
+	}
+
+	.toast-message-item {
+		padding: var(--size-1-5) var(--size-1-5) var(--size-1-5) var(--size-1-5);
+		border-radius: var(--radius-lg);
+	}
+
+	.toast-separator {
+		height: 1px;
+		background: var(--border-color-primary);
+		margin: 0;
+	}
+
+	.toast-message-text {
+		font-size: var(--text-md);
+		line-height: 1.5;
+		word-wrap: break-word;
+		overflow-wrap: break-word;
+		word-break: break-word;
+		color: var(--body-text-color);
+	}
+
+	.toast-message-text :global(a) {
+		text-decoration: underline;
+	}
+
+	@keyframes countdown {
+		from {
+			transform: scaleX(1);
+		}
+		to {
+			transform: scaleX(0);
+		}
+	}
+
+	.timer {
+		position: absolute;
+		bottom: 0;
+		left: 0;
+		transform-origin: 0 0;
+		animation: countdown 10s linear forwards;
+		width: 100%;
+		height: var(--size-1);
+	}
+
+	.timer {
+		background: var(--toast-color);
+	}
+
+	@media (max-width: 640px) {
+		.toast-header {
+			padding: var(--size-2) var(--size-2);
+		}
+
+		.toast-messages {
+			gap: var(--size-1);
+			padding: 0 var(--size-2) var(--size-1-5) var(--size-2);
+		}
+
+		.toast-message-item {
+			padding: 0 var(--size-1) var(--size-1) var(--size-1);
+		}
+	}
+</style>

6.16.0/statustracker/static/index.svelte

@@ -0,0 +1,680 @@
+<script context="module" lang="ts">
+	import { tick, untrack } from "svelte";
+	import { pretty_si } from "./utils";
+
+	let items: HTMLDivElement[] = [];
+
+	let called = false;
+
+	const is_browser = typeof window !== "undefined";
+	const raf = is_browser
+		? window.requestAnimationFrame
+		: (cb: (...args: any[]) => void) => {};
+	const shown_cache_indicator_keys = new Set<string>();
+
+	async function scroll_into_view(
+		el: HTMLDivElement,
+		enable: boolean | null = true
+	): Promise<void> {
+		if (
+			window.__gradio_mode__ === "website" ||
+			(window.__gradio_mode__ !== "app" && enable !== true)
+		) {
+			return;
+		}
+
+		items.push(el);
+		if (!called) called = true;
+		else return;
+
+		await tick();
+
+		raf(() => {
+			let min = [0, 0];
+
+			for (let i = 0; i < items.length; i++) {
+				const element = items[i];
+
+				const box = element.getBoundingClientRect();
+				if (i === 0 || box.top + window.scrollY <= min[0]) {
+					min[0] = box.top + window.scrollY;
+					min[1] = i;
+				}
+			}
+
+			window.scrollTo({ top: min[0] - 20, behavior: "smooth" });
+
+			called = false;
+			items = [];
+		});
+	}
+</script>
+
+<script lang="ts">
+	import Loader from "./Loader.svelte";
+	import type { LoadingStatus } from "./types";
+	import type { I18nFormatter } from "@gradio/utils";
+
+	import { IconButton } from "@gradio/atoms";
+	import { Clear } from "@gradio/icons";
+
+	interface Props {
+		i18n: I18nFormatter;
+		eta?: number | null;
+		queue_position: number | null;
+		queue_size: number | null;
+		component_id?: number | null;
+		fn_index?: number | null;
+		status:
+			| "complete"
+			| "pending"
+			| "error"
+			| "generating"
+			| "streaming"
+			| null;
+		scroll_to_output?: boolean;
+		timer?: boolean;
+		show_progress?: "full" | "minimal" | "hidden";
+		message?: string | null;
+		progress?: LoadingStatus["progress"] | null | undefined;
+		variant?: "default" | "center";
+		loading_text?: string;
+		absolute?: boolean;
+		translucent?: boolean;
+		border?: boolean;
+		autoscroll: boolean;
+		validation_error?: string | null;
+		show_validation_error?: boolean;
+		type?: "input" | "output" | null;
+		on_clear_status?: () => void;
+		used_cache?: "full" | "partial" | null;
+		cache_duration?: number | null;
+		avg_time?: number | null;
+		cache_event_id?: number | null;
+	}
+
+	interface ProgressLevel {
+		progress_level: (number | undefined)[] | null;
+		last_progress_level: number | undefined;
+		progress_bar_transition: string;
+	}
+
+	let {
+		i18n,
+		eta = null,
+		queue_position,
+		queue_size,
+		component_id = null,
+		fn_index = null,
+		status,
+		scroll_to_output = false,
+		timer = true,
+		show_progress = "full",
+		message = null,
+		progress = null,
+		variant = "default",
+		loading_text = "Loading...",
+		absolute = true,
+		translucent = false,
+		border = false,
+		autoscroll,
+		validation_error = null,
+		show_validation_error = true,
+		type = null,
+		on_clear_status,
+		used_cache = null,
+		cache_duration = null,
+		avg_time = null,
+		cache_event_id = null
+	}: Props = $props();
+
+	let el: HTMLDivElement;
+
+	let _timer = false;
+	let timer_start = $state(0);
+	let old_eta = $state<number | null>(null);
+	let eta_from_start = $state<number | null>(null);
+	let message_visible = $state(false);
+	let formatted_eta = $state<string | null>(null);
+	let show_message_timeout = $state<NodeJS.Timeout | null>(null);
+	let show_cache_indicator = $state(false);
+	let cache_indicator_fading = $state(false);
+	let cache_display_time = $state<string | null>(null);
+	let cache_display_avg = $state<string | null>(null);
+	let cache_indicator_label = $state("from cache");
+	let show_cache_avg = $state(false);
+	let cache_timeout: ReturnType<typeof setTimeout> | null = null;
+	let cache_fade_timeout: ReturnType<typeof setTimeout> | null = null;
+	let last_cache_indicator_key: string | null = null;
+
+	function hide_cache_indicator(): void {
+		if (cache_timeout) clearTimeout(cache_timeout);
+		if (cache_fade_timeout) clearTimeout(cache_fade_timeout);
+		cache_timeout = null;
+		cache_fade_timeout = null;
+		show_cache_indicator = false;
+		cache_indicator_fading = false;
+	}
+
+	const should_hide = $derived(
+		!(show_validation_error && validation_error) &&
+			(type === "input" ||
+				!status ||
+				status === "complete" ||
+				show_progress === "hidden" ||
+				status == "streaming")
+	);
+
+	let timer_diff = $state(0);
+
+	const eta_level = $derived(
+		eta_from_start === null || eta_from_start <= 0 || !timer_diff
+			? 0
+			: Math.min(timer_diff / eta_from_start, 1)
+	);
+
+	const formatted_timer = $derived(timer_diff.toFixed(1));
+
+	let show_eta_bar = $derived(progress != null ? false : true);
+	let effective_eta = $derived(eta ?? old_eta);
+
+	function run(): void {
+		raf(() => {
+			timer_diff = (performance.now() - timer_start) / 1000;
+			if (_timer) run();
+		});
+	}
+
+	let progress_level = $derived.by<ProgressLevel>(() => {
+		let _progress_level: (number | undefined)[] | null = null;
+		if (progress != null) {
+			_progress_level = progress.map((p) => {
+				if (p.index != null && p.length != null) {
+					return p.index / p.length;
+				} else if (p.progress != null) {
+					return p.progress;
+				}
+				return undefined;
+			});
+		} else {
+			_progress_level = null;
+		}
+
+		let _last_progress_level: number | undefined;
+		let transition = "";
+		if (_progress_level) {
+			_last_progress_level = _progress_level[_progress_level.length - 1];
+
+			if (_last_progress_level === 0) {
+				transition = "0";
+			} else {
+				transition = "150ms";
+			}
+		} else {
+			_last_progress_level = undefined;
+		}
+
+		return {
+			progress_level: _progress_level,
+			last_progress_level: _last_progress_level,
+			progress_bar_transition: transition
+		};
+	});
+
+	function start_timer(): void {
+		if (_timer) return;
+
+		old_eta = formatted_eta = null;
+		timer_start = performance.now();
+
+		_timer = true;
+		run();
+	}
+
+	function stop_timer(): void {
+		old_eta = formatted_eta = null;
+		if (!_timer) return;
+		_timer = false;
+	}
+
+	$effect(() => {
+		if (status === "pending") {
+			start_timer();
+		} else {
+			untrack(() => {
+				stop_timer();
+			});
+		}
+	});
+
+	$effect(() => {
+		if (
+			el &&
+			scroll_to_output &&
+			(status === "pending" || status === "complete")
+		) {
+			scroll_into_view(el, autoscroll);
+		}
+	});
+
+	$effect(() => {
+		if (effective_eta != null && old_eta !== effective_eta) {
+			eta_from_start = (performance.now() - timer_start) / 1000 + effective_eta;
+			formatted_eta = eta_from_start.toFixed(1);
+			old_eta = effective_eta;
+		}
+	});
+
+	function close_message(): void {
+		message_visible = false;
+		if (show_message_timeout !== null) {
+			clearTimeout(show_message_timeout);
+		}
+	}
+
+	$effect(() => {
+		untrack(() => {
+			close_message();
+		});
+
+		if (status === "error" && message) {
+			message_visible = true;
+		}
+	});
+
+	$effect(() => {
+		if (
+			status === "complete" &&
+			type === "output" &&
+			used_cache &&
+			cache_duration != null
+		) {
+			const cache_indicator_key =
+				cache_event_id == null
+					? null
+					: `${component_id ?? fn_index ?? "unknown"}:${fn_index ?? "unknown"}:${cache_event_id}`;
+			if (
+				cache_indicator_key === last_cache_indicator_key ||
+				(cache_indicator_key != null &&
+					shown_cache_indicator_keys.has(cache_indicator_key))
+			) {
+				return;
+			}
+			last_cache_indicator_key = cache_indicator_key;
+			if (cache_indicator_key != null) {
+				shown_cache_indicator_keys.add(cache_indicator_key);
+			}
+			cache_display_time = cache_duration.toFixed(1);
+			cache_indicator_label =
+				used_cache === "full" ? "from cache" : "used cache";
+			show_cache_avg =
+				avg_time != null && avg_time > cache_duration && avg_time > 0;
+			cache_display_avg = show_cache_avg ? avg_time!.toFixed(1) : null;
+			show_cache_indicator = true;
+			cache_indicator_fading = false;
+
+			if (cache_timeout) clearTimeout(cache_timeout);
+			if (cache_fade_timeout) clearTimeout(cache_fade_timeout);
+			cache_timeout = setTimeout(() => {
+				cache_indicator_fading = true;
+				cache_fade_timeout = setTimeout(() => {
+					show_cache_indicator = false;
+					cache_indicator_fading = false;
+				}, 500);
+			}, 1750);
+		} else if (type === "output" && !used_cache) {
+			hide_cache_indicator();
+		}
+	});
+</script>
+
+<div
+	class="wrap {variant} {show_progress}"
+	class:no-click={validation_error && show_validation_error}
+	class:hide={should_hide}
+	class:translucent={(variant === "center" &&
+		(status === "pending" || status === "error")) ||
+		translucent ||
+		show_progress === "minimal" ||
+		validation_error}
+	class:generating={status === "generating" && show_progress === "full"}
+	class:border
+	style:position={absolute ? "absolute" : "static"}
+	style:padding={absolute ? "0" : "var(--size-8) 0"}
+	data-testid="status-tracker"
+	bind:this={el}
+>
+	{#if validation_error && show_validation_error}
+		<div class="validation-error">
+			{validation_error}
+			<button
+				><IconButton
+					Icon={Clear}
+					label={i18n ? i18n("common.clear") : "Clear"}
+					disabled={false}
+					size="x-small"
+					background="var(--background-fill-primary)"
+					color="var(--error-background-text)"
+					border="var(--border-color-primary)"
+					onclick={() => (validation_error = null)}
+				/></button
+			>
+		</div>
+	{/if}
+	{#if status === "pending"}
+		{#if variant === "default" && show_eta_bar && show_progress === "full"}
+			<div
+				class="eta-bar"
+				style:transform="translateX({(eta_level || 0) * 100 - 100}%)"
+			/>
+		{/if}
+		<div
+			class:meta-text-center={variant === "center"}
+			class:meta-text={variant === "default"}
+			class="progress-text"
+		>
+			{#if progress}
+				{#each progress as p}
+					{#if p.index != null}
+						{#if p.length != null}
+							{pretty_si(p.index || 0)}/{pretty_si(p.length)}
+						{:else}
+							{pretty_si(p.index || 0)}
+						{/if}
+						{p.unit} | {" "}
+					{/if}
+				{/each}
+			{:else if queue_position !== null && queue_size !== undefined && queue_position >= 0}
+				queue: {queue_position + 1}/{queue_size} |
+			{:else if queue_position === 0}
+				processing |
+			{/if}
+
+			{#if timer}
+				{formatted_timer}{eta ? `/${formatted_eta}` : ""}s
+			{/if}
+		</div>
+
+		{#if progress_level.last_progress_level != null}
+			<div class="progress-level">
+				<div class="progress-level-inner">
+					{#if progress != null}
+						{#each progress as p, i}
+							{#if p.desc != null || (progress_level.progress_level && progress_level.progress_level[i] != null)}
+								{#if i !== 0}
+									&nbsp;/
+								{/if}
+								{#if p.desc != null}
+									{p.desc}
+								{/if}
+								{#if p.desc != null && progress_level.progress_level && progress_level.progress_level[i] != null}
+									-
+								{/if}
+								{#if progress_level.progress_level != null}
+									{(100 * (progress_level.progress_level[i] || 0)).toFixed(1)}%
+								{/if}
+							{/if}
+						{/each}
+					{/if}
+				</div>
+
+				<div class="progress-bar-wrap">
+					<div
+						class="progress-bar"
+						style:width="{progress_level.last_progress_level * 100}%"
+						style:transition={progress_level.progress_bar_transition}
+					/>
+				</div>
+			</div>
+		{:else if show_progress === "full"}
+			<Loader margin={variant === "default"} />
+		{/if}
+
+		{#if !timer}
+			<p class="loading">{loading_text}</p>
+			<slot name="additional-loading-text" />
+		{/if}
+	{:else if status === "error"}
+		<div class="clear-status">
+			<IconButton
+				Icon={Clear}
+				label={i18n("common.clear")}
+				disabled={false}
+				on:click={() => {
+					on_clear_status?.();
+				}}
+			/>
+		</div>
+		<span class="error">{i18n("common.error")}</span>
+		<slot name="error" />
+	{/if}
+</div>
+
+{#if show_cache_indicator}
+	<div
+		class="cache-indicator"
+		class:fade-out={cache_indicator_fading}
+		style:position={absolute ? "absolute" : "static"}
+	>
+		&#9889; {cache_indicator_label}: {#if show_cache_avg}~{cache_display_avg}s
+			&rarr;&nbsp;
+		{/if}{cache_display_time}s
+	</div>
+{/if}
+
+<style>
+	.wrap {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		z-index: var(--layer-3);
+		transition: opacity 0.1s ease-in-out;
+		border-radius: var(--block-radius);
+		background: var(--block-background-fill);
+		padding: 0 var(--size-6);
+		overflow: hidden;
+	}
+	.no-click {
+		pointer-events: none;
+	}
+
+	.wrap.center {
+		top: 0;
+		right: 0px;
+		left: 0px;
+	}
+
+	.wrap.default {
+		top: 0px;
+		right: 0px;
+		bottom: 0px;
+		left: 0px;
+	}
+
+	.hide {
+		opacity: 0;
+		pointer-events: none;
+	}
+
+	.generating {
+		animation:
+			pulseStart 1s cubic-bezier(0.4, 0, 0.6, 1),
+			pulse 2s cubic-bezier(0.4, 0, 0.6, 1) 1s infinite;
+		border: 2px solid var(--color-accent);
+		background: transparent;
+		z-index: var(--layer-1);
+		pointer-events: none;
+	}
+
+	.translucent {
+		background: none;
+	}
+
+	@keyframes pulseStart {
+		0% {
+			opacity: 0;
+		}
+		100% {
+			opacity: 1;
+		}
+	}
+
+	@keyframes pulse {
+		0%,
+		100% {
+			opacity: 1;
+		}
+		50% {
+			opacity: 0.5;
+		}
+	}
+
+	.loading {
+		z-index: var(--layer-2);
+		color: var(--body-text-color);
+	}
+	.eta-bar {
+		position: absolute;
+		top: 0;
+		right: 0;
+		bottom: 0;
+		left: 0;
+		transform-origin: left;
+		opacity: 0.8;
+		z-index: var(--layer-1);
+		transition: 10ms;
+		background: var(--background-fill-secondary);
+	}
+	.progress-bar-wrap {
+		border: 1px solid var(--border-color-primary);
+		background: var(--background-fill-primary);
+		width: 55.5%;
+		height: var(--size-4);
+	}
+	.progress-bar {
+		transform-origin: left;
+		background-color: var(--loader-color);
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+
+	.progress-level {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		gap: 1;
+		z-index: var(--layer-2);
+		width: var(--size-full);
+	}
+
+	.progress-level-inner {
+		margin: var(--size-2) auto;
+		color: var(--body-text-color);
+		font-size: var(--text-sm);
+		font-family: var(--font-mono);
+	}
+
+	.meta-text {
+		position: absolute;
+		bottom: 0;
+		right: 0;
+		z-index: var(--layer-2);
+		padding: var(--size-1) var(--size-2);
+		font-size: var(--text-sm);
+		font-family: var(--font-mono);
+	}
+
+	.meta-text-center {
+		display: flex;
+		position: absolute;
+		top: 0;
+		right: 0;
+		justify-content: center;
+		align-items: center;
+		transform: translateY(var(--size-6));
+		z-index: var(--layer-2);
+		padding: var(--size-1) var(--size-2);
+		font-size: var(--text-sm);
+		font-family: var(--font-mono);
+		text-align: center;
+	}
+
+	.error {
+		box-shadow: var(--shadow-drop);
+		border: solid 1px var(--error-border-color);
+		border-radius: var(--radius-full);
+		background: var(--error-background-fill);
+		padding-right: var(--size-4);
+		padding-left: var(--size-4);
+		color: var(--error-text-color);
+		font-weight: var(--weight-semibold);
+		font-size: var(--text-lg);
+		line-height: var(--line-lg);
+		font-family: var(--font);
+	}
+
+	.validation-error {
+		pointer-events: auto;
+		color: var(--error-text-color);
+		font-weight: var(--weight-semibold);
+		font-size: var(--text-lg);
+		line-height: var(--line-lg);
+		font-family: var(--font);
+		position: absolute;
+		background: var(--error-background-fill);
+		top: 0;
+		right: 0;
+		z-index: var(--layer-3);
+		padding: var(--size-1) var(--size-2);
+		font-size: var(--text-md);
+		text-align: center;
+		border-bottom-left-radius: var(--radius-sm);
+		border-bottom: 1px solid var(--error-border-color);
+		border-left: 1px solid var(--error-border-color);
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		gap: var(--spacing-xl);
+	}
+
+	.minimal {
+		pointer-events: none;
+	}
+
+	.minimal .progress-text {
+		background: var(--block-background-fill);
+	}
+
+	.border {
+		border: 1px solid var(--border-color-primary);
+	}
+
+	.clear-status {
+		position: absolute;
+		display: flex;
+		top: var(--size-2);
+		right: var(--size-2);
+		justify-content: flex-end;
+		gap: var(--spacing-sm);
+		z-index: var(--layer-1);
+	}
+
+	.cache-indicator {
+		position: absolute;
+		bottom: 0;
+		right: 0;
+		z-index: var(--layer-2);
+		padding: var(--size-1) var(--size-2);
+		font-size: var(--text-sm);
+		font-family: var(--font-mono);
+		pointer-events: none;
+		background: var(--block-background-fill);
+		opacity: 1;
+		transition: opacity 0.5s ease-out;
+	}
+
+	.cache-indicator.fade-out {
+		opacity: 0;
+	}
+</style>

6.16.0/statustracker/static/index.ts

@@ -0,0 +1,11 @@
+export { default as StatusTracker } from "./index.svelte";
+export { default as Toast } from "./Toast.svelte";
+export { default as Loader } from "./Loader.svelte";
+export { default as StreamingBar } from "./StreamingBar.svelte";
+export type {
+	ILoadingStatus,
+	LoadingStatusArgs,
+	GroupedToastMessage,
+	ToastMessage
+} from "./types";
+export { default } from "./index.svelte";

6.16.0/statustracker/static/state.svelte.ts

@@ -0,0 +1,166 @@
+import type { ILoadingStatus, LoadingStatusArgs } from "./types.js";
+
+export class LoadingStatus {
+	current: Record<string, ILoadingStatus> = {};
+	fn_outputs: Record<number, number[]> = {};
+	fn_inputs: Record<number, number[]> = {};
+	pending_outputs = new Map<number, number>();
+	fn_status: Record<number, ILoadingStatus["status"]> = {};
+	show_progress: Record<number, "full" | "minimal" | "hidden"> = {};
+	cache_event_id = 0;
+
+	register(
+		dependency_id: number,
+		outputs: number[],
+		inputs: number[],
+		show_progress: "full" | "minimal" | "hidden"
+	): void {
+		this.fn_outputs[dependency_id] = outputs;
+		this.fn_inputs[dependency_id] = inputs;
+		this.show_progress[dependency_id] = show_progress;
+	}
+
+	clear(id: number): void {
+		if (id in this.current) {
+			//@ts-ignore
+			this.current[id] = {};
+		}
+	}
+
+	update(args: LoadingStatusArgs): void {
+		for (const [id, current] of Object.entries(this.current)) {
+			if (current.fn_index !== args.fn_index) {
+				this.current[id] = {
+					...current,
+					used_cache: null,
+					cache_duration: null,
+					avg_time: null,
+					cache_event_id: null
+				};
+			}
+		}
+
+		const cache_event_id = args.used_cache ? ++this.cache_event_id : null;
+		const updates = this.resolve_args(args);
+
+		updates.forEach(
+			({
+				id,
+				queue_position,
+				queue_size,
+				eta,
+				status,
+				message,
+				progress,
+				stream_state,
+				time_limit,
+				type,
+				used_cache,
+				cache_duration,
+				avg_time
+			}) => {
+				this.current[id] = {
+					queue: args.queue || false,
+					queue_size: queue_size,
+					queue_position: queue_position,
+					eta: eta,
+					component_id: Number(id),
+					stream_state: stream_state,
+					message: message,
+					progress: progress || undefined,
+					status,
+					fn_index: args.fn_index,
+					time_limit,
+					type,
+					show_progress: this.show_progress[args.fn_index],
+					used_cache,
+					cache_duration,
+					avg_time,
+					cache_event_id
+				};
+			}
+		);
+	}
+
+	set_status(id: number, status: ILoadingStatus["status"]): void {
+		this.current[id].status = status;
+	}
+
+	resolve_args(args: LoadingStatusArgs) {
+		const {
+			fn_index,
+			status,
+			size = undefined,
+			position = null,
+			eta = null,
+			message = null,
+			stream_state = null,
+			time_limit = null,
+			progress_data = null,
+			used_cache = null,
+			cache_duration = null,
+			avg_time = null
+		} = args;
+
+		const outputs = this.fn_outputs[fn_index];
+		const last_status = this.fn_status[fn_index];
+		const inputs = this.fn_inputs[fn_index];
+
+		const all_ids = outputs.concat(inputs);
+
+		// from (pending -> error) | complete - decrement pending count
+		return all_ids
+			.map((id) => {
+				let new_status: ILoadingStatus["status"];
+
+				const pending_count = this.pending_outputs.get(id) || 0;
+
+				// from (pending -> error) | complete - decrement pending count
+				if (last_status === "pending" && status !== "pending") {
+					let new_count = pending_count - 1;
+
+					this.pending_outputs.set(id, new_count < 0 ? 0 : new_count);
+
+					new_status = new_count > 0 ? "pending" : status;
+
+					// from pending -> pending - do nothing
+				} else if (last_status === "pending" && status === "pending") {
+					new_status = "pending";
+
+					// (error | complete) -> pending - - increment pending count
+				} else if (last_status !== "pending" && status === "pending") {
+					new_status = "pending";
+					this.pending_outputs.set(id, pending_count + 1);
+				} else {
+					new_status = status;
+				}
+
+				// We update the status tracker only for input components of streaming events
+				// or for outputs of the dependency
+				const type = (
+					inputs.includes(id) && stream_state
+						? "input"
+						: outputs.includes(id)
+							? "output"
+							: "skip"
+				) as "input" | "output" | "skip";
+
+				return {
+					id,
+					queue_position: position,
+					queue_size: size,
+					eta: eta,
+					status: new_status,
+					message: message,
+					progress: progress_data,
+					stream_state: stream_state,
+					time_limit,
+					type: type,
+					used_cache,
+					cache_duration,
+					avg_time
+				};
+			})
+			.filter((update) => update.type !== "skip");
+	}
+}

6.16.0/statustracker/static/types.ts

@@ -0,0 +1,61 @@
+export interface ILoadingStatus {
+	eta: number | null;
+	status: "pending" | "error" | "complete" | "generating" | "streaming";
+	queue: boolean;
+	queue_position: number | null;
+	queue_size?: number;
+	component_id?: number;
+	fn_index: number;
+	message?: string | null;
+	scroll_to_output?: boolean;
+	show_progress?: "full" | "minimal" | "hidden";
+	time_limit?: number | null | undefined;
+	progress?: {
+		progress: number | null;
+		index: number | null;
+		length: number | null;
+		unit: string | null;
+		desc: string | null;
+	}[];
+	validation_error?: string | null;
+	type: "input" | "output";
+	stream_state: "open" | "closed" | "waiting" | null;
+	used_cache?: "full" | "partial" | null;
+	cache_duration?: number | null;
+	avg_time?: number | null;
+	cache_event_id?: number | null;
+}
+
+export interface LoadingStatusArgs {
+	fn_index: ILoadingStatus["fn_index"];
+	status: ILoadingStatus["status"];
+	queue?: ILoadingStatus["queue"];
+	size?: ILoadingStatus["queue_size"];
+	position?: ILoadingStatus["queue_position"];
+	eta?: ILoadingStatus["eta"];
+	message?: ILoadingStatus["message"];
+	progress_data?: ILoadingStatus["progress"];
+	time_limit?: ILoadingStatus["time_limit"];
+	type?: "input" | "output";
+	stream_state: "open" | "closed" | "waiting" | null;
+	validation_error?: string;
+	show_validation_error?: boolean;
+	used_cache?: "full" | "partial" | null;
+	cache_duration?: number | null;
+	avg_time?: number | null;
+}
+
+export interface ToastMessage {
+	type: "error" | "warning" | "info" | "success";
+	title: string;
+	message: string;
+	id: number;
+	duration: number | null;
+	visible: boolean;
+}
+
+export interface GroupedToastMessage {
+	type: "error" | "warning" | "info" | "success";
+	messages: ToastMessage[];
+	expanded: boolean;
+}

6.16.0/statustracker/static/utils.ts

@@ -0,0 +1,10 @@
+export function pretty_si(num: number): string {
+	let units = ["", "k", "M", "G", "T", "P", "E", "Z"];
+	let i = 0;
+	while (num > 1000 && i < units.length - 1) {
+		num /= 1000;
+		i++;
+	}
+	let unit = units[i];
+	return (Number.isInteger(num) ? num : num.toFixed(1)) + unit;
+}