Upload folder using huggingface_hub

Browse files

Files changed (5) hide show

6.0.1/html/Example.svelte +20 -0
6.0.1/html/Index.svelte +108 -0
6.0.1/html/package.json +46 -0
6.0.1/html/shared/HTML.svelte +371 -0
6.0.1/html/types.ts +18 -0

6.0.1/html/Example.svelte ADDED Viewed

	@@ -0,0 +1,20 @@

+<script lang="ts">
+	export let value: string;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+	class="prose"
+>
+	{@html value}
+</div>
+<style>
+	.gallery {
+		padding: var(--size-2);
+	}
+</style>

6.0.1/html/Index.svelte ADDED Viewed

	@@ -0,0 +1,108 @@

+<script context="module" lang="ts">
+	export { default as BaseHTML } from "./shared/HTML.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+<script lang="ts">
+	import { Gradio } from "@gradio/utils";
+	import HTML from "./shared/HTML.svelte";
+	import { StatusTracker } from "@gradio/statustracker";
+	import { Block, BlockLabel } from "@gradio/atoms";
+	import { Code as CodeIcon } from "@gradio/icons";
+	import { css_units } from "@gradio/utils";
+	import type { HTMLProps, HTMLEvents } from "./types.ts";
+	let props = $props();
+	const gradio = new Gradio<HTMLEvents, HTMLProps>(props);
+	let _props = $derived({
+		value: gradio.props.value || "",
+		label: gradio.shared.label,
+		visible: gradio.shared.visible,
+		...gradio.props.props
+	});
+	let old_value = $state(gradio.props.value);
+	$effect(() => {
+		if (JSON.stringify(old_value) !== JSON.stringify(gradio.props.value)) {
+			old_value = gradio.props.value;
+			gradio.dispatch("change");
+		}
+	});
+</script>
+<Block
+	visible={gradio.shared.visible}
+	elem_id={gradio.shared.elem_id}
+	elem_classes={gradio.shared.elem_classes}
+	container={gradio.shared.container}
+	padding={true}
+	overflow_behavior="visible"
+>
+	{#if gradio.shared.show_label}
+		<BlockLabel
+			Icon={CodeIcon}
+			show_label={gradio.shared.show_label}
+			label={gradio.shared.label}
+			float={false}
+		/>
+	{/if}
+	<StatusTracker
+		autoscroll={gradio.shared.autoscroll}
+		i18n={gradio.i18n}
+		{...gradio.shared.loading_status}
+		variant="center"
+		on_clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+	<div
+		class="html-container"
+		class:padding={gradio.shared.padding}
+		class:pending={gradio.shared.loading_status?.status === "pending"}
+		style:min-height={gradio.props.min_height &&
+		gradio.shared.loading_status?.status !== "pending"
+			? css_units(gradio.props.min_height)
+			: undefined}
+		style:max-height={gradio.props.max_height
+			? css_units(gradio.props.max_height)
+			: undefined}
+	>
+		<HTML
+			props={_props}
+			html_template={gradio.props.html_template}
+			css_template={gradio.props.css_template}
+			js_on_load={gradio.props.js_on_load}
+			elem_classes={gradio.shared.elem_classes}
+			visible={gradio.shared.visible}
+			autoscroll={gradio.shared.autoscroll}
+			apply_default_css={gradio.props.apply_default_css}
+			component_class_name={gradio.props.component_class_name}
+			on:event={(e) => {
+				gradio.dispatch(e.detail.type, e.detail.data);
+			}}
+			on:update_value={(e) => {
+				if (e.detail.property === "value") {
+					gradio.props.value = e.detail.data;
+				} else if (e.detail.property === "label") {
+					gradio.shared.label = e.detail.data;
+				} else if (e.detail.property === "visible") {
+					gradio.shared.visible = e.detail.data;
+				}
+			}}
+		/>
+	</div>
+</Block>
+<style>
+	.padding {
+		padding: var(--block-padding);
+	}
+	div {
+		transition: 150ms;
+	}
+	.pending {
+		opacity: 0.2;
+	}
+</style>

6.0.1/html/package.json ADDED Viewed

	@@ -0,0 +1,46 @@

+{
+	"name": "@gradio/html",
+	"version": "0.8.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"main_changeset": true,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"handlebars": "^4.7.8"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./base": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.43.4"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/html"
+	}
+}

6.0.1/html/shared/HTML.svelte ADDED Viewed

	@@ -0,0 +1,371 @@

+<script lang="ts">
+	import { createEventDispatcher, tick } from "svelte";
+	import Handlebars from "handlebars";
+	let {
+		elem_classes = [],
+		props = {},
+		html_template = "${value}",
+		css_template = "",
+		js_on_load = null,
+		visible = true,
+		autoscroll = false,
+		apply_default_css = true,
+		component_class_name = "HTML"
+	} = $props();
+	let old_props = $state(props);
+	const dispatch = createEventDispatcher<{
+		event: { type: "click" | "submit"; data: any };
+		update_value: { data: any; property: "value" | "label" | "visible" };
+	}>();
+	const trigger = (
+		event_type: "click" | "submit",
+		event_data: any = {}
+	): void => {
+		dispatch("event", { type: event_type, data: event_data });
+	};
+	let element: HTMLDivElement;
+	let scrollable_parent: HTMLElement | null = null;
+	let random_id = `html-${Math.random().toString(36).substring(2, 11)}`;
+	let style_element: HTMLStyleElement | null = null;
+	let reactiveProps: Record<string, any> = {};
+	let currentHtml = $state("");
+	let currentCss = $state("");
+	let renderScheduled = $state(false);
+	let mounted = $state(false);
+	let error_message: string | null = $state(null);
+	function get_scrollable_parent(element: HTMLElement): HTMLElement | null {
+		let parent = element.parentElement;
+		while (parent) {
+			const style = window.getComputedStyle(parent);
+			if (
+				style.overflow === "auto" ||
+				style.overflow === "scroll" ||
+				style.overflowY === "auto" ||
+				style.overflowY === "scroll"
+			) {
+				return parent;
+			}
+			parent = parent.parentElement;
+		}
+		return null;
+	}
+	function is_at_bottom(): boolean {
+		if (!element) return true;
+		if (!scrollable_parent) {
+			return (
+				window.innerHeight + window.scrollY >=
+				document.documentElement.scrollHeight - 100
+			);
+		}
+		return (
+			scrollable_parent.offsetHeight + scrollable_parent.scrollTop >=
+			scrollable_parent.scrollHeight - 100
+		);
+	}
+	function scroll_to_bottom(): void {
+		if (!element) return;
+		if (scrollable_parent) {
+			scrollable_parent.scrollTo(0, scrollable_parent.scrollHeight);
+		} else {
+			window.scrollTo(0, document.documentElement.scrollHeight);
+		}
+	}
+	async function scroll_on_html_update(): Promise<void> {
+		if (!autoscroll || !element) return;
+		if (!scrollable_parent) {
+			scrollable_parent = get_scrollable_parent(element);
+		}
+		if (is_at_bottom()) {
+			await new Promise((resolve) => setTimeout(resolve, 300));
+			scroll_to_bottom();
+		}
+	}
+	function render_template(
+		template: string,
+		props: Record<string, any>
+	): string {
+		try {
+			const handlebarsTemplate = Handlebars.compile(template);
+			const handlebarsRendered = handlebarsTemplate(props);
+			const propKeys = Object.keys(props);
+			const propValues = Object.values(props);
+			const templateFunc = new Function(
+				...propKeys,
+				`return \`${handlebarsRendered}\`;`
+			);
+			error_message = null;
+			return templateFunc(...propValues);
+		} catch (e) {
+			console.error("Error evaluating template:", e);
+			error_message = e instanceof Error ? e.message : String(e);
+			return "";
+		}
+	}
+	function update_css(): void {
+		if (typeof document === "undefined") return;
+		if (!style_element) {
+			style_element = document.createElement("style");
+			document.head.appendChild(style_element);
+		}
+		currentCss = render_template(css_template, reactiveProps);
+		if (currentCss) {
+			style_element.textContent = `#${random_id} { ${currentCss} }`;
+		} else {
+			style_element.textContent = "";
+		}
+	}
+	function updateDOM(oldHtml: string, newHtml: string): void {
+		if (!element || oldHtml === newHtml) return;
+		const tempContainer = document.createElement("div");
+		tempContainer.innerHTML = newHtml;
+		const oldNodes = Array.from(element.childNodes);
+		const newNodes = Array.from(tempContainer.childNodes);
+		const maxLength = Math.max(oldNodes.length, newNodes.length);
+		for (let i = 0; i < maxLength; i++) {
+			const oldNode = oldNodes[i];
+			const newNode = newNodes[i];
+			if (!oldNode && newNode) {
+				element.appendChild(newNode.cloneNode(true));
+			} else if (oldNode && !newNode) {
+				element.removeChild(oldNode);
+			} else if (oldNode && newNode) {
+				updateNode(oldNode, newNode);
+			}
+		}
+	}
+	// eslint-disable-next-line complexity
+	function updateNode(oldNode: Node, newNode: Node): void {
+		if (
+			oldNode.nodeType === Node.TEXT_NODE &&
+			newNode.nodeType === Node.TEXT_NODE
+		) {
+			if (oldNode.textContent !== newNode.textContent) {
+				oldNode.textContent = newNode.textContent;
+			}
+			return;
+		}
+		if (
+			oldNode.nodeType === Node.ELEMENT_NODE &&
+			newNode.nodeType === Node.ELEMENT_NODE
+		) {
+			const oldElement = oldNode as Element;
+			const newElement = newNode as Element;
+			if (oldElement.tagName !== newElement.tagName) {
+				oldNode.parentNode?.replaceChild(newNode.cloneNode(true), oldNode);
+				return;
+			}
+			const oldAttrs = Array.from(oldElement.attributes);
+			const newAttrs = Array.from(newElement.attributes);
+			for (const attr of oldAttrs) {
+				if (!newElement.hasAttribute(attr.name)) {
+					oldElement.removeAttribute(attr.name);
+				}
+			}
+			for (const attr of newAttrs) {
+				if (oldElement.getAttribute(attr.name) !== attr.value) {
+					oldElement.setAttribute(attr.name, attr.value);
+					if (
+						attr.name === "value" &&
+						(oldElement.tagName === "INPUT" ||
+							oldElement.tagName === "TEXTAREA" ||
+							oldElement.tagName === "SELECT")
+					) {
+						(
+							oldElement as
+								| HTMLInputElement
+								| HTMLTextAreaElement
+								| HTMLSelectElement
+						).value = attr.value;
+					}
+				}
+			}
+			const oldChildren = Array.from(oldElement.childNodes);
+			const newChildren = Array.from(newElement.childNodes);
+			const maxChildren = Math.max(oldChildren.length, newChildren.length);
+			for (let i = 0; i < maxChildren; i++) {
+				const oldChild = oldChildren[i];
+				const newChild = newChildren[i];
+				if (!oldChild && newChild) {
+					oldElement.appendChild(newChild.cloneNode(true));
+				} else if (oldChild && !newChild) {
+					oldElement.removeChild(oldChild);
+				} else if (oldChild && newChild) {
+					updateNode(oldChild, newChild);
+				}
+			}
+		} else {
+			oldNode.parentNode?.replaceChild(newNode.cloneNode(true), oldNode);
+		}
+	}
+	function renderHTML(): void {
+		console.trace(
+			"re-rendering HTML with props:",
+			JSON.stringify(reactiveProps)
+		);
+		const newHtml = render_template(html_template, reactiveProps);
+		if (element) {
+			updateDOM(currentHtml, newHtml);
+		}
+		currentHtml = newHtml;
+		if (autoscroll) {
+			scroll_on_html_update();
+		}
+	}
+	function scheduleRender(): void {
+		if (!renderScheduled) {
+			renderScheduled = true;
+			queueMicrotask(() => {
+				renderScheduled = false;
+				renderHTML();
+				update_css();
+			});
+		}
+	}
+	// Mount effect
+	$effect(() => {
+		if (!element || mounted) return;
+		mounted = true;
+		reactiveProps = new Proxy(
+			{ ...props },
+			{
+				set(target, property, value) {
+					const oldValue = target[property as string];
+					target[property as string] = value;
+					if (oldValue !== value) {
+						scheduleRender();
+						if (
+							property === "value" ||
+							property === "label" ||
+							property === "visible"
+						) {
+							props[property] = value;
+							old_props[property] = value;
+							dispatch("update_value", { data: value, property });
+						}
+					}
+					return true;
+				}
+			}
+		);
+		currentHtml = render_template(html_template, reactiveProps);
+		element.innerHTML = currentHtml;
+		update_css();
+		if (autoscroll) {
+			scroll_to_bottom();
+		}
+		scroll_on_html_update();
+		if (js_on_load && element) {
+			try {
+				const func = new Function("element", "trigger", "props", js_on_load);
+				func(element, trigger, reactiveProps);
+			} catch (error) {
+				console.error("Error executing js_on_load:", error);
+			}
+		}
+	});
+	// Props update effect
+	$effect(() => {
+		if (
+			reactiveProps &&
+			props &&
+			JSON.stringify(old_props) !== JSON.stringify(props)
+		) {
+			for (const key in props) {
+				if (reactiveProps[key] !== props[key]) {
+					reactiveProps[key] = props[key];
+				}
+			}
+			old_props = props;
+		}
+	});
+</script>
+{#if error_message}
+	<div class="error-container">
+		<strong class="error-title"
+			>Error rendering <code class="error-component-name"
+				>{component_class_name}</code
+			>:</strong
+		>
+		<code class="error-message">{error_message}</code>
+	</div>
+{:else}
+	<div
+		bind:this={element}
+		id={random_id}
+		class="{apply_default_css ? 'prose gradio-style' : ''} {elem_classes.join(
+			' '
+		)}"
+		class:hide={!visible}
+	></div>
+{/if}
+<style>
+	.hide {
+		display: none;
+	}
+	.error-container {
+		padding: 12px;
+		background-color: #fee;
+		border: 1px solid #fcc;
+		border-radius: 4px;
+		color: #c33;
+		font-family: monospace;
+		font-size: 13px;
+	}
+	.error-title {
+		display: block;
+		margin-bottom: 8px;
+	}
+	.error-component-name {
+		background-color: #fdd;
+		padding: 2px 4px;
+		border-radius: 2px;
+	}
+	.error-message {
+		white-space: pre-wrap;
+		word-break: break-word;
+	}
+</style>

6.0.1/html/types.ts ADDED Viewed

	@@ -0,0 +1,18 @@

+export interface HTMLProps {
+	value: string;
+	html_template: string;
+	css_template: string;
+	js_on_load: string | null;
+	apply_default_css: boolean;
+	show_label: boolean;
+	min_height: number | undefined;
+	max_height: number | undefined;
+	props: Record<string, any>;
+	component_class_name: string;
+}
+export interface HTMLEvents {
+	change: never;
+	click: never;
+	submit: never;
+}