Upload folder using huggingface_hub

6.4.0/highlightedtext/Index.svelte

@@ -1,11 +1,9 @@
-<script context="module" lang="ts">
-	export { default as BaseStaticHighlightedText } from "./shared/StaticHighlightedtext.svelte";
-	export { default as BaseInteractiveHighlightedText } from "./shared/InteractiveHighlightedtext.svelte";
+<script module lang="ts">
+	export { default as BaseHighlightedText } from "./shared/HighlightedText.svelte";
 </script>
 
 <script lang="ts">
-	import StaticHighlightedText from "./shared/StaticHighlightedtext.svelte";
-	import InteractiveHighlightedText from "./shared/InteractiveHighlightedtext.svelte";
+	import HighlightedText from "./shared/HighlightedText.svelte";
 	import { Block, BlockLabel, Empty, IconButtonWrapper } from "@gradio/atoms";
 	import { TextHighlight } from "@gradio/icons";
 	import { StatusTracker } from "@gradio/statustracker";
@@ -19,7 +17,7 @@
 	let old_value = $state(gradio.props.value);
 
 	$effect(() => {
-		if (old_value != gradio.props.value) {
+		if (old_value !== gradio.props.value) {
 			old_value = gradio.props.value;
 			gradio.dispatch("change");
 		}
@@ -32,107 +30,65 @@
 	);
 </script>
 
-{#if !gradio.shared.interactive}
-	<Block
-		variant={"solid"}
-		test_id="highlighted-text"
-		visible={gradio.shared.visible}
-		elem_id={gradio.shared.elem_id}
-		elem_classes={gradio.shared.elem_classes}
-		padding={false}
-		container={gradio.shared.container}
-		scale={gradio.shared.scale}
-		min_width={gradio.shared.min_width}
-		rtl={gradio.props.rtl}
-	>
-		<StatusTracker
-			autoscroll={gradio.shared.autoscroll}
-			i18n={gradio.i18n}
-			{...gradio.shared.loading_status}
-			on_clear_status={() =>
-				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+<Block
+	variant={gradio.shared.interactive ? "dashed" : "solid"}
+	test_id="highlighted-text"
+	visible={gradio.shared.visible}
+	elem_id={gradio.shared.elem_id}
+	elem_classes={gradio.shared.elem_classes}
+	padding={false}
+	container={gradio.shared.container}
+	scale={gradio.shared.scale}
+	min_width={gradio.shared.min_width}
+	rtl={gradio.props.rtl}
+>
+	<StatusTracker
+		autoscroll={gradio.shared.autoscroll}
+		i18n={gradio.i18n}
+		{...gradio.shared.loading_status}
+		onclearstatus={() =>
+			gradio.dispatch("clear_status", gradio.shared.loading_status)}
+	/>
+
+	{#if gradio.shared.interactive && gradio.shared.label && gradio.shared.show_label && gradio.props.buttons?.length}
+		<IconButtonWrapper
+			buttons={gradio.props.buttons}
+			on_custom_button_click={(id) =>
+				gradio.dispatch("custom_button_click", { id })}
 		/>
-		{#if gradio.shared.label && gradio.shared.show_label}
-			<BlockLabel
-				Icon={TextHighlight}
-				label={gradio.shared.label ||
-					gradio.i18n("highlighted_text.highlighted_text")}
-				float={false}
-				disable={gradio.shared.container === false}
-				show_label={gradio.shared.show_label}
-				rtl={gradio.props.rtl}
-			/>
-		{/if}
+	{/if}
 
-		{#if value}
-			<StaticHighlightedText
-				on:select={({ detail }) => gradio.dispatch("select", detail)}
-				selectable={false}
-				{value}
-				show_legend={gradio.props.show_legend}
-				show_inline_category={gradio.props.show_inline_category}
-				color_map={gradio.props.color_map}
-			/>
-		{:else}
-			<Empty>
-				<TextHighlight />
-			</Empty>
-		{/if}
-	</Block>
-{:else}
-	<Block
-		variant={gradio.shared.interactive ? "dashed" : "solid"}
-		test_id="highlighted-text"
-		visible={gradio.shared.visible}
-		elem_id={gradio.shared.elem_id}
-		elem_classes={gradio.shared.elem_classes}
-		padding={false}
-		container={gradio.shared.container}
-		scale={gradio.shared.scale}
-		min_width={gradio.shared.min_width}
-		rtl={gradio.props.rtl}
-	>
-		<StatusTracker
-			autoscroll={gradio.shared.autoscroll}
-			{...gradio.shared.loading_status}
-			i18n={gradio.i18n}
-			on_clear_status={() =>
-				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+	{#if gradio.shared.label && gradio.shared.show_label}
+		<BlockLabel
+			Icon={TextHighlight}
+			label={gradio.shared.label ||
+				gradio.i18n("highlighted_text.highlighted_text")}
+			float={false}
+			disable={gradio.shared.container === false}
+			show_label={gradio.shared.show_label}
+			rtl={gradio.props.rtl}
 		/>
-		{#if gradio.shared.label && gradio.shared.show_label && gradio.props.buttons && gradio.props.buttons.length > 0}
-			<IconButtonWrapper
-				buttons={gradio.props.buttons}
-				on_custom_button_click={(id) => {
-					gradio.dispatch("custom_button_click", { id });
-				}}
-			/>
-		{/if}
-		{#if gradio.shared.label && gradio.shared.show_label}
-			<BlockLabel
-				Icon={TextHighlight}
-				label={gradio.shared.label}
-				float={false}
-				disable={gradio.shared.container === false}
-				show_label={gradio.shared.show_label}
-				rtl={gradio.props.rtl}
-			/>
-		{/if}
+	{/if}
 
-		{#if value}
-			<InteractiveHighlightedText
-				bind:value
-				on:change={() => {
-					gradio.props.value = value;
-					gradio.dispatch("change");
-				}}
-				selectable={false}
-				show_legend={gradio.props.show_legend}
-				color_map={gradio.props.color_map}
-			/>
-		{:else}
-			<Empty size="small" unpadded_box={true}>
-				<TextHighlight />
-			</Empty>
-		{/if}
-	</Block>
-{/if}
+	{#if value}
+		<HighlightedText
+			bind:value
+			interactive={gradio.shared.interactive}
+			show_legend={gradio.props.show_legend}
+			show_inline_category={gradio.props.show_inline_category}
+			color_map={gradio.props.color_map}
+			onselect={(detail) => gradio.dispatch("select", detail)}
+			onchange={() => {
+				gradio.props.value = value;
+				gradio.dispatch("change");
+			}}
+		/>
+	{:else}
+		<Empty
+			size={gradio.shared.interactive ? "small" : "large"}
+			unpadded_box={gradio.shared.interactive}
+		>
+			<TextHighlight />
+		</Empty>
+	{/if}
+</Block>

6.4.0/highlightedtext/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@gradio/highlightedtext",
-	"version": "0.10.1",
+	"version": "0.11.0",
 	"description": "Gradio UI packages",
 	"type": "module",
 	"author": "",

6.4.0/highlightedtext/shared/HighlightedText.svelte

@@ -0,0 +1,492 @@
+<script lang="ts">
+	import { get_next_color } from "@gradio/utils";
+	import type { SelectData } from "@gradio/utils";
+	import { onMount } from "svelte";
+	import {
+		generate_color_map,
+		merge_elements,
+		get_score_color,
+		is_transparent,
+		type HighlightedToken,
+		type ColorPair
+	} from "./utils";
+	import LabelInput from "./LabelInput.svelte";
+	import { Clear } from "@gradio/icons";
+
+	const is_browser = typeof window !== "undefined";
+
+	let {
+		value = $bindable([]),
+		show_legend = false,
+		show_inline_category = true,
+		color_map = {},
+		interactive = false,
+		onselect,
+		onchange
+	}: {
+		value?: HighlightedToken[];
+		show_legend?: boolean;
+		show_inline_category?: boolean;
+		color_map?: Record<string, string>;
+		interactive?: boolean;
+		onselect?: (data: SelectData) => void;
+		onchange?: (data: HighlightedToken[]) => void;
+	} = $props();
+
+	let active_element_index = $state(-1);
+	let active_legend = $state("");
+	let label_to_edit = $state(-1);
+	let selection: Selection | null = $state(null);
+
+	let mode: "categories" | "scores" = $state("categories");
+	let resolved_color_map: Record<string, ColorPair> = $state({});
+
+	$effect(() => {
+		let local_colors = { ...color_map };
+
+		for (const entry of value) {
+			if (entry.class_or_confidence === null) continue;
+
+			if (typeof entry.class_or_confidence === "string") {
+				mode = "categories";
+				if (!(entry.class_or_confidence in local_colors)) {
+					local_colors[entry.class_or_confidence] = get_next_color(
+						Object.keys(local_colors).length
+					);
+				}
+			} else {
+				mode = "scores";
+			}
+		}
+
+		resolved_color_map = generate_color_map(local_colors, is_browser);
+	});
+
+	onMount(() => {
+		if (!interactive) return;
+
+		const on_mouse_up = (): void => {
+			selection = window.getSelection();
+			handle_selection_complete();
+			window.removeEventListener("mouseup", on_mouse_up);
+		};
+
+		window.addEventListener("mousedown", () => {
+			window.addEventListener("mouseup", on_mouse_up);
+		});
+	});
+
+	function handle_selection_complete(): void {
+		if (!selection || !selection.toString().trim()) return;
+
+		const start = selection.getRangeAt(0).startOffset;
+		const end = selection.getRangeAt(0).endOffset;
+		handle_text_selected(start, end);
+	}
+
+	function handle_text_selected(start: number, end: number): void {
+		if (
+			!selection?.toString() ||
+			active_element_index === -1 ||
+			!value[active_element_index].token.includes(selection.toString())
+		) {
+			return;
+		}
+
+		const str = value[active_element_index].token;
+		const new_entries: HighlightedToken[] = [
+			{ token: str.substring(0, start), class_or_confidence: null },
+			{
+				token: str.substring(start, end),
+				class_or_confidence: mode === "scores" ? 1 : "label"
+			},
+			{ token: str.substring(end), class_or_confidence: null }
+		].filter((e) => e.token.trim() !== "");
+
+		value = [
+			...value.slice(0, active_element_index),
+			...new_entries,
+			...value.slice(active_element_index + 1)
+		];
+
+		label_to_edit = value.findIndex(
+			(v, i) =>
+				i >= active_element_index &&
+				v.token === str.substring(start, end) &&
+				v.class_or_confidence !== null
+		);
+
+		handle_value_change();
+		document.getElementById(`label-input-${label_to_edit}`)?.focus();
+	}
+
+	function remove_highlight(index: number): void {
+		if (index < 0 || index >= value.length) return;
+		value[index].class_or_confidence = null;
+		value = merge_elements(value, "equal");
+		handle_value_change();
+		window.getSelection()?.empty();
+	}
+
+	function handle_value_change(): void {
+		onchange?.(value);
+		label_to_edit = -1;
+	}
+
+	function get_background_color(
+		class_or_confidence: string | number | null
+	): string {
+		if (class_or_confidence === null) return "";
+		if (active_legend && active_legend !== class_or_confidence) return "";
+		return resolved_color_map[class_or_confidence]?.secondary ?? "";
+	}
+
+	function get_label_color(
+		class_or_confidence: string | number | null
+	): string {
+		if (class_or_confidence === null) return "";
+		if (active_legend && active_legend !== class_or_confidence) return "";
+		return resolved_color_map[class_or_confidence]?.primary ?? "";
+	}
+
+	function get_text_color(class_or_confidence: string | number | null): string {
+		const bg = get_background_color(class_or_confidence);
+		return is_transparent(bg) ? "" : "black";
+	}
+</script>
+
+<div class="container">
+	{#if mode === "categories"}
+		{#if show_legend}
+			<div class="legend" data-testid="highlighted-text:category-legend">
+				{#each Object.entries(resolved_color_map) as [category, colors]}
+					<button
+						class="legend-item"
+						style:background-color={colors.secondary}
+						onmouseenter={() => (active_legend = category)}
+						onmouseleave={() => (active_legend = "")}
+						onfocus={() => (active_legend = category)}
+						onblur={() => (active_legend = "")}
+					>
+						{category}
+					</button>
+				{/each}
+			</div>
+		{/if}
+
+		<div class="textfield">
+			{#each value as { token, class_or_confidence }, i}
+				{@const lines = token.split("\n")}
+				{#each lines as line, j}
+					{#if line.trim()}
+						{@const bg_color = get_background_color(class_or_confidence)}
+						<span class="token-container">
+							<span
+								class="token"
+								class:highlighted={class_or_confidence !== null}
+								class:transparent={class_or_confidence !== null &&
+									is_transparent(bg_color)}
+								class:dimmed={active_legend &&
+									active_legend !== class_or_confidence}
+								style:background-color={bg_color}
+								style:color={get_text_color(class_or_confidence)}
+								role={class_or_confidence !== null ? "button" : undefined}
+								tabindex={class_or_confidence !== null ? 0 : undefined}
+								onclick={() => {
+									if (class_or_confidence === null) return;
+									if (interactive) {
+										onselect?.({
+											index: i,
+											value: [token, class_or_confidence]
+										});
+										label_to_edit = i;
+									} else {
+										onselect?.({
+											index: i,
+											value: [token, class_or_confidence]
+										});
+									}
+								}}
+								onkeydown={(e) => {
+									if (!interactive) return;
+									if (e.key === "Enter" && class_or_confidence !== null) {
+										label_to_edit = i;
+									}
+								}}
+								onfocus={() => (active_element_index = i)}
+								onmouseenter={() => (active_element_index = i)}
+							>
+								<span
+									class="text"
+									class:unlabeled={class_or_confidence === null}>{line}</span
+								>
+
+								{#if !show_legend && show_inline_category && class_or_confidence !== null && label_to_edit !== i}
+									<span
+										class="label"
+										style:background-color={get_label_color(
+											class_or_confidence
+										)}
+									>
+										{class_or_confidence}
+									</span>
+								{/if}
+
+								{#if interactive && label_to_edit === i && class_or_confidence !== null}
+									<LabelInput
+										bind:value
+										bind:label_to_edit
+										category={class_or_confidence}
+										{active_legend}
+										color_map={resolved_color_map}
+										label_index={i}
+										{token}
+										onchange={handle_value_change}
+									/>
+								{/if}
+							</span>
+
+							{#if interactive && class_or_confidence !== null}
+								<button
+									class="remove-btn"
+									aria-label="Remove label"
+									onclick={() => remove_highlight(i)}
+								>
+									<Clear />
+								</button>
+							{/if}
+						</span>
+					{/if}
+					{#if j < lines.length - 1}
+						<span class="line-break"></span>
+					{/if}
+				{/each}
+			{/each}
+		</div>
+	{:else}
+		{#if show_legend}
+			<div class="score-legend" data-testid="highlighted-text:color-legend">
+				<span>-1</span>
+				<span>0</span>
+				<span>+1</span>
+			</div>
+		{/if}
+
+		<div class="textfield" data-testid="highlighted-text:textfield">
+			{#each value as { token, class_or_confidence }, i}
+				{@const score =
+					typeof class_or_confidence === "string"
+						? parseFloat(class_or_confidence)
+						: class_or_confidence}
+				<span class="token-container">
+					<span
+						class="token score-token"
+						class:highlighted={score !== null}
+						style:background-color={get_score_color(score)}
+						role="button"
+						tabindex={0}
+						onmouseenter={() => (active_element_index = i)}
+						onfocus={() => (active_element_index = i)}
+						onclick={() => {
+							if (interactive) {
+								label_to_edit = i;
+							} else {
+								onselect?.({
+									index: i,
+									value: [token, class_or_confidence]
+								});
+							}
+						}}
+						onkeydown={(e) => {
+							if (e.key === "Enter") {
+								if (interactive) {
+									label_to_edit = i;
+								} else {
+									onselect?.({
+										index: i,
+										value: [token, class_or_confidence]
+									});
+								}
+							}
+						}}
+					>
+						<span class="text">{token}</span>
+
+						{#if interactive && class_or_confidence !== null && label_to_edit === i}
+							<LabelInput
+								bind:value
+								bind:label_to_edit
+								category={class_or_confidence}
+								{active_legend}
+								color_map={resolved_color_map}
+								label_index={i}
+								{token}
+								onchange={handle_value_change}
+								is_scores_mode
+							/>
+						{/if}
+					</span>
+
+					{#if interactive && class_or_confidence !== null && active_element_index === i}
+						<button
+							class="remove-btn"
+							aria-label="Remove label"
+							onclick={() => remove_highlight(i)}
+						>
+							<Clear />
+						</button>
+					{/if}
+				</span>
+			{/each}
+		</div>
+	{/if}
+</div>
+
+<style>
+	.container {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-sm);
+		padding: var(--block-padding);
+	}
+
+	.legend,
+	.score-legend {
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--spacing-sm);
+	}
+
+	.legend-item {
+		cursor: pointer;
+		border: none;
+		border-radius: var(--radius-xs);
+		padding: 0 var(--size-2);
+		font-weight: var(--weight-semibold);
+		color: black;
+	}
+
+	.score-legend {
+		justify-content: space-between;
+		border-radius: var(--radius-xs);
+		background: linear-gradient(
+			to right,
+			var(--color-purple),
+			transparent,
+			var(--color-red)
+		);
+		padding: var(--size-1) var(--size-2);
+		font-weight: var(--weight-semibold);
+	}
+
+	.textfield {
+		display: flex;
+		flex-wrap: wrap;
+		line-height: var(--scale-4);
+		word-break: break-all;
+	}
+
+	.line-break {
+		flex-basis: 100%;
+		height: 0;
+	}
+
+	.token-container {
+		position: relative;
+	}
+
+	.token {
+		transition: 150ms;
+		border-radius: var(--radius-xs);
+	}
+
+	.token.highlighted {
+		cursor: pointer;
+		padding: var(--size-0-5) var(--size-1);
+		margin-left: var(--size-1);
+		margin-right: var(--size-2);
+	}
+
+	.token.highlighted.transparent {
+		padding: var(--size-0-5) var(--size-0-5);
+		margin: 0;
+		outline: 1px solid transparent;
+	}
+
+	.token.highlighted.transparent:hover {
+		outline-color: var(--neutral-400);
+	}
+
+	:global(.dark) .token.highlighted.transparent:hover {
+		outline-color: var(--neutral-500);
+	}
+
+	.token.dimmed {
+		color: var(--body-text-color);
+	}
+
+	.text {
+		white-space: pre-wrap;
+	}
+
+	.text.unlabeled {
+		color: var(--body-text-color);
+	}
+
+	.score-token .text {
+		color: var(--body-text-color);
+	}
+
+	.label {
+		margin-left: 4px;
+		border-radius: var(--radius-xs);
+		padding: 1px 5px;
+		color: var(--color-white);
+		font-weight: var(--weight-bold);
+		text-transform: uppercase;
+		font-size: 70%;
+		vertical-align: middle;
+		bottom: 1px;
+		position: relative;
+	}
+
+	.remove-btn {
+		display: none;
+		position: absolute;
+		top: 0;
+		right: 0;
+		width: var(--size-3);
+		height: var(--size-3);
+		border: none;
+		border-radius: 50%;
+		background: var(--neutral-400);
+		color: white;
+		font-size: 10px;
+		cursor: pointer;
+		justify-content: center;
+		align-items: center;
+	}
+
+	:global(.dark) .remove-btn {
+		background: var(--neutral-500);
+		color: var(--neutral-950);
+	}
+
+	.remove-btn :global(svg) {
+		width: var(--size-1-5);
+		height: var(--size-1-5);
+	}
+
+	.remove-btn:hover {
+		background: var(--neutral-500);
+	}
+
+	:global(.dark) .remove-btn:hover {
+		background: var(--neutral-400);
+	}
+
+	.token-container:hover .remove-btn,
+	.token-container:focus-within .remove-btn {
+		display: flex;
+	}
+</style>

6.4.0/highlightedtext/shared/LabelInput.svelte

@@ -1,124 +1,103 @@
 <script lang="ts">
-	type HighlightedTextType = {
-		token: string;
-		class_or_confidence: string | number | null;
-	};
+	import type { HighlightedToken, ColorPair } from "./utils";
+	import { get_score_color } from "./utils";
 
-	export let value: HighlightedTextType[];
-	export let category: string | number | null;
-	export let active: string;
-	export let labelToEdit: number;
-	export let indexOfLabel: number;
-	export let text: string;
-	export let handleValueChange: () => void;
-	export let isScoresMode = false;
-	export let _color_map: Record<string, { primary: string; secondary: string }>;
+	let {
+		value = $bindable([]),
+		label_to_edit = $bindable(-1),
+		category,
+		active_legend,
+		color_map,
+		label_index,
+		token,
+		onchange,
+		is_scores_mode = false
+	}: {
+		value: HighlightedToken[];
+		label_to_edit: number;
+		category: string | number | null;
+		active_legend: string;
+		color_map: Record<string, ColorPair>;
+		label_index: number;
+		token: string;
+		onchange: () => void;
+		is_scores_mode?: boolean;
+	} = $props();
 
-	let _input_value = category;
+	let input_value = $state(category?.toString() ?? "");
 
-	function handleInput(e: Event): void {
-		let target = e.target as HTMLInputElement;
-		if (target) {
-			_input_value = target.value;
+	function get_background_color(): string {
+		if (is_scores_mode) {
+			const score =
+				typeof category === "number" ? category : parseFloat(category ?? "0");
+			return get_score_color(score);
+		}
+		if (category === null || (active_legend && active_legend !== category)) {
+			return "";
 		}
+		return color_map[category]?.primary ?? "";
 	}
 
-	function updateLabelValue(
-		e: Event,
-		elementIndex: number,
-		text: string
-	): void {
-		let target = e.target as HTMLInputElement;
+	function update_value(e: Event): void {
+		const target = e.target as HTMLInputElement;
+		const new_value = target.value.trim();
+
 		value = [
-			...value.slice(0, elementIndex),
+			...value.slice(0, label_index),
 			{
-				token: text,
+				token,
 				class_or_confidence:
-					target.value === ""
+					new_value === ""
 						? null
-						: isScoresMode
-							? Number(target.value)
-							: target.value
+						: is_scores_mode
+							? Number(new_value)
+							: new_value
 			},
-			...value.slice(elementIndex + 1)
+			...value.slice(label_index + 1)
 		];
 
-		handleValueChange();
+		onchange();
 	}
 
-	function clearPlaceHolderOnFocus(e: FocusEvent): void {
-		let target = e.target as HTMLInputElement;
-		if (target && target.placeholder) target.placeholder = "";
+	function handle_keydown(e: KeyboardEvent): void {
+		if (e.key === "Enter") {
+			update_value(e);
+			label_to_edit = -1;
+		}
 	}
 </script>
 
-<!-- svelte-ignore a11y-autofocus -->
-<!-- autofocus should not be disorienting for a screen reader users
-as input is only rendered once a new label is created -->
-{#if !isScoresMode}
-	<input
-		class="label-input"
-		autofocus
-		id={`label-input-${indexOfLabel}`}
-		type="text"
-		placeholder="label"
-		value={category}
-		style:background-color={category === null || (active && active !== category)
-			? ""
-			: _color_map[category].primary}
-		style:width={_input_value
-			? _input_value.toString()?.length + 4 + "ch"
-			: "8ch"}
-		on:input={handleInput}
-		on:blur={(e) => updateLabelValue(e, indexOfLabel, text)}
-		on:keydown={(e) => {
-			if (e.key === "Enter") {
-				updateLabelValue(e, indexOfLabel, text);
-				labelToEdit = -1;
-			}
-		}}
-		on:focus={clearPlaceHolderOnFocus}
-	/>
-{:else}
-	<input
-		class="label-input"
-		autofocus
-		type="number"
-		step="0.1"
-		style={"background-color: rgba(" +
-			(typeof category === "number" && category < 0
-				? "128, 90, 213," + -category
-				: "239, 68, 60," + category) +
-			")"}
-		value={category}
-		style:width="7ch"
-		on:input={handleInput}
-		on:blur={(e) => updateLabelValue(e, indexOfLabel, text)}
-		on:keydown={(e) => {
-			if (e.key === "Enter") {
-				updateLabelValue(e, indexOfLabel, text);
-				labelToEdit = -1;
-			}
-		}}
-	/>
-{/if}
+<input
+	class="label-input"
+	autofocus
+	type={is_scores_mode ? "number" : "text"}
+	step={is_scores_mode ? "0.1" : undefined}
+	placeholder={is_scores_mode ? undefined : "label"}
+	value={category}
+	style:background-color={get_background_color()}
+	style:width={is_scores_mode ? "7ch" : `${(input_value?.length || 4) + 4}ch`}
+	oninput={(e) => {
+		input_value = (e.target as HTMLInputElement).value;
+	}}
+	onblur={update_value}
+	onkeydown={handle_keydown}
+/>
 
 <style>
 	.label-input {
-		transition: 150ms;
 		margin-top: 1px;
-		margin-right: calc(var(--size-1));
+		margin-left: 4px;
+		border: none;
 		border-radius: var(--radius-xs);
 		padding: 1px 5px;
-		color: black;
+		color: var(--color-white);
 		font-weight: var(--weight-bold);
 		font-size: var(--text-sm);
 		text-transform: uppercase;
 		line-height: 1;
-		color: white;
 	}
 
 	.label-input::placeholder {
-		color: rgba(1, 1, 1, 0.5);
+		color: rgba(255, 255, 255, 0.5);
 	}
 </style>

6.4.0/highlightedtext/shared/utils.ts

@@ -1,77 +1,92 @@
 import { colors } from "@gradio/theme";
 
-export function name_to_rgba(
-	name: string,
-	a: number,
-	ctx: CanvasRenderingContext2D | null
-): string {
-	if (!ctx) {
-		var canvas = document.createElement("canvas");
-		ctx = canvas.getContext("2d")!;
-	}
+export interface HighlightedToken {
+	token: string;
+	class_or_confidence: string | number | null;
+}
+
+export interface ColorPair {
+	primary: string;
+	secondary: string;
+}
+
+function name_to_rgba(name: string, alpha: number): string {
+	const canvas = document.createElement("canvas");
+	const ctx = canvas.getContext("2d")!;
 	ctx.fillStyle = name;
 	ctx.fillRect(0, 0, 1, 1);
 	const [r, g, b] = ctx.getImageData(0, 0, 1, 1).data;
-	ctx.clearRect(0, 0, 1, 1);
-	return `rgba(${r}, ${g}, ${b}, ${255 / a})`;
+	return `rgba(${r}, ${g}, ${b}, ${alpha})`;
 }
 
-export function correct_color_map(
+export function is_transparent(color: string): boolean {
+	if (!color) return true;
+	const c = color.toLowerCase().trim();
+	// 9 chars + ends with 00 = #RRGGBBAA format with 0 alpha
+	return c === "transparent" || (c.length === 9 && c.endsWith("00"));
+}
+
+export function generate_color_map(
 	color_map: Record<string, string>,
-	_color_map: Record<string, { primary: string; secondary: string }>,
-	browser: any,
-	ctx: CanvasRenderingContext2D | null
-): void {
-	for (const col in color_map) {
-		const _c = color_map[col].trim();
+	is_browser: boolean
+): Record<string, ColorPair> {
+	const result: Record<string, ColorPair> = {};
 
-		if (_c in colors) {
-			_color_map[col] = colors[_c as keyof typeof colors];
+	for (const key in color_map) {
+		const color = color_map[key].trim();
+
+		if (color in colors) {
+			result[key] = colors[color as keyof typeof colors];
+		} else if (is_transparent(color)) {
+			result[key] = {
+				primary: "transparent",
+				secondary: "transparent"
+			};
 		} else {
-			_color_map[col] = {
-				primary: browser
-					? name_to_rgba(color_map[col], 1, ctx)
-					: color_map[col],
-				secondary: browser
-					? name_to_rgba(color_map[col], 0.5, ctx)
-					: color_map[col]
+			result[key] = {
+				primary: is_browser ? name_to_rgba(color, 1) : color,
+				secondary: is_browser ? name_to_rgba(color, 0.5) : color
 			};
 		}
 	}
+
+	return result;
 }
 
 export function merge_elements(
-	value: { token: string; class_or_confidence: string | number | null }[],
-	mergeMode: "empty" | "equal"
-): { token: string; class_or_confidence: string | number | null }[] {
-	let result: typeof value = [];
-	let tempStr: string | null = null;
-	let tempVal: string | number | null = null;
+	value: HighlightedToken[],
+	merge_mode: "empty" | "equal"
+): HighlightedToken[] {
+	if (value.length === 0) return [];
+
+	const result: HighlightedToken[] = [];
+	let current_token = value[0].token;
+	let current_class = value[0].class_or_confidence;
 
-	for (const val of value) {
-		if (
-			(mergeMode === "empty" && val.class_or_confidence === null) ||
-			(mergeMode === "equal" && tempVal === val.class_or_confidence)
-		) {
-			tempStr = tempStr ? tempStr + val.token : val.token;
+	for (let i = 1; i < value.length; i++) {
+		const { token, class_or_confidence } = value[i];
+		const should_merge =
+			merge_mode === "empty"
+				? class_or_confidence === null
+				: current_class === class_or_confidence;
+
+		if (should_merge) {
+			current_token += token;
 		} else {
-			if (tempStr !== null) {
-				result.push({
-					token: tempStr,
-					class_or_confidence: tempVal
-				});
-			}
-			tempStr = val.token;
-			tempVal = val.class_or_confidence;
+			result.push({ token: current_token, class_or_confidence: current_class });
+			current_token = token;
+			current_class = class_or_confidence;
 		}
 	}
 
-	if (tempStr !== null) {
-		result.push({
-			token: tempStr,
-			class_or_confidence: tempVal
-		});
-	}
-
+	result.push({ token: current_token, class_or_confidence: current_class });
 	return result;
 }
+
+export function get_score_color(score: number | null): string {
+	if (score === null) return "";
+	if (score < 0) {
+		return `rgba(128, 90, 213, ${-score})`;
+	}
+	return `rgba(239, 68, 60, ${score})`;
+}