@walkinissue/angy 0.2.17

package/dist/client/VibeTooltip.svelte

@@ -0,0 +1,146 @@
+<script lang="ts">
+	let {
+		text,
+		position = 'top',
+		disabled = false,
+		delay = 120
+	}: {
+		text: string;
+		position?: 'top' | 'bottom' | 'left' | 'right';
+		disabled?: boolean;
+		delay?: number;
+	} = $props();
+
+	let visible = $state(false);
+	let timeout: ReturnType<typeof setTimeout> | null = null;
+	const id = `tooltip-${Math.random().toString(36).slice(2, 10)}`;
+
+	function show() {
+		if (disabled || !text) return;
+		clearDelay();
+		timeout = setTimeout(() => {
+			visible = true;
+		}, delay);
+	}
+
+	function hide() {
+		clearDelay();
+		visible = false;
+	}
+
+	function clearDelay() {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = null;
+		}
+	}
+</script>
+
+<div
+	class="tooltip-wrap"
+	onmouseenter={show}
+	onmouseleave={hide}
+	onfocusin={show}
+	onfocusout={hide}
+>
+	<slot />
+
+	{#if visible && !disabled && text}
+		<div
+			id={id}
+			role="tooltip"
+			class={`tooltip tooltip--${position}`}
+		>
+			{text}
+		</div>
+	{/if}
+</div>
+
+<style>
+	.tooltip-wrap {
+		position: relative;
+		display: inline-flex;
+		width: fit-content;
+	}
+
+	.tooltip {
+		position: absolute;
+		z-index: 1000;
+		/*max-width: 18rem; /*:S*/
+		padding: 0.45rem 0.65rem;
+		border-radius: 0.5rem;
+		background: rgba(20, 20, 20, 0.96);
+		color: white;
+		font-size: 0.8rem;
+		line-height: 1.2;
+		white-space: nowrap;
+		pointer-events: none;
+		box-shadow:
+			0 8px 24px rgba(0, 0, 0, 0.22),
+			0 2px 8px rgba(0, 0, 0, 0.14);
+	}
+
+	.tooltip::after {
+		content: '';
+		position: absolute;
+		width: 0;
+		height: 0;
+		border-style: solid;
+	}
+
+	.tooltip--top {
+		bottom: calc(100% + 0.5rem);
+		left: 50%;
+		transform: translateX(-50%);
+	}
+
+	.tooltip--top::after {
+		top: 100%;
+		left: 50%;
+		transform: translateX(-50%);
+		border-width: 0.35rem 0.35rem 0 0.35rem;
+		border-color: rgba(20, 20, 20, 0.96) transparent transparent transparent;
+	}
+
+	.tooltip--bottom {
+		top: calc(100% + 0.5rem);
+		left: 50%;
+		transform: translateX(-50%);
+	}
+
+	.tooltip--bottom::after {
+		bottom: 100%;
+		left: 50%;
+		transform: translateX(-50%);
+		border-width: 0 0.35rem 0.35rem 0.35rem;
+		border-color: transparent transparent rgba(20, 20, 20, 0.96) transparent;
+	}
+
+	.tooltip--left {
+		right: calc(100% + 0.5rem);
+		top: 50%;
+		transform: translateY(-50%);
+	}
+
+	.tooltip--left::after {
+		left: 100%;
+		top: 50%;
+		transform: translateY(-50%);
+		border-width: 0.35rem 0 0.35rem 0.35rem;
+		border-color: transparent transparent transparent rgba(20, 20, 20, 0.96);
+	}
+
+	.tooltip--right {
+		left: calc(100% + 0.5rem);
+		top: 50%;
+		transform: translateY(-50%);
+	}
+
+	.tooltip--right::after {
+		right: 100%;
+		top: 50%;
+		transform: translateY(-50%);
+		border-width: 0.35rem 0.35rem 0.35rem 0;
+		border-color: transparent rgba(20, 20, 20, 0.96) transparent transparent;
+	}
+</style>

package/dist/client/dragItem.ts

@@ -0,0 +1,50 @@
+
+export function draggable(node: HTMLElement, param:{active: (activate:boolean) => void, drag: ()=> boolean}) {
+
+    let x = 100;
+    let y = 100;
+    let offsetX = 0;
+    let offsetY = 0;
+    let dragging = false;
+    
+    function down(event: PointerEvent) {
+        dragging = param.drag();
+        offsetX = event.clientX - x;
+        offsetY = event.clientY - y;
+        
+        window.addEventListener('pointermove', move);
+        window.addEventListener('pointerup', up);
+        param.active(false)
+    }
+    
+    function move(event: PointerEvent) {
+        if (!dragging) return;
+        x = event.clientX - offsetX;
+        y = event.clientY - offsetY;
+        node.style.left = `${x}px`;
+        node.style.top = `${y}px`;
+        param.active(true)
+    }
+    
+    function up(event: Event) {
+        dragging = false;
+        window.removeEventListener('pointermove', move);
+        window.removeEventListener('pointerup', up);
+
+    }
+    
+    node.style.position = 'fixed';
+    node.style.left = `${x}px`;
+    node.style.top = `${y}px`;
+    node.style.touchAction = 'none';
+
+    node.addEventListener('pointerdown', down);
+
+    return {
+        destroy() {
+            node.removeEventListener('pointerdown', down);
+            window.removeEventListener('pointermove', move);
+            window.removeEventListener('pointerup', up);
+        }
+    };
+}

package/dist/client/toggleQA.shared.ts

@@ -0,0 +1,164 @@
+export type TranslationOrigin = "base" | "working";
+
+export type ResolvedKey = {
+	msgid: string;
+	msgctxt: string | null;
+};
+
+export type TranslationEntry = {
+	msgid: string;
+	msgctxt: string | null;
+	msgidPlural: string | null;
+	msgstr: string[];
+	references: string[];
+	extractedComments: string[];
+	flags: string[];
+	previous: string[];
+	obsolete: boolean;
+	hasTranslation?: boolean;
+	isFuzzy?: boolean | null;
+	isCommittedToWorking?: boolean;
+	matchesTargetTranslation?: boolean;
+	translationOrigin?: TranslationOrigin | null;
+};
+
+export type TranslationAlternative = {
+	msgid: string;
+	msgctxt: string | null;
+	score: number;
+	references: string[];
+	msgstr: string[];
+	hasTranslation: boolean;
+	isFuzzy: boolean | null | undefined;
+	isCommittedToWorking?: boolean;
+	matchesTargetTranslation?: boolean;
+	translationOrigin?: TranslationOrigin | null;
+};
+
+export type TranslationContextResult = {
+	match: {
+		score: number;
+		via: string;
+	};
+	entry: TranslationEntry;
+	alternatives: TranslationAlternative[];
+};
+
+export type DraftTranslation = {
+	msgid: string;
+	msgctxt: string | null;
+	value: string;
+	origin: TranslationOrigin | null;
+	originalValue: string;
+	isDirty: boolean;
+};
+
+export type TranslationCandidate = Pick<
+	TranslationEntry,
+	"msgid" | "msgctxt" | "hasTranslation" | "translationOrigin" | "isFuzzy"
+>;
+
+export const TRANSLATION_STATUS_TOOLTIP =
+	"'\u{1F914}' fuzzy translation needs review. '\u2705' target and working agree. '\u274C' no translation. '\u{1F6E0}\uFE0F' working differs from target.";
+
+export function translationKey(msgid: string, msgctxt: string | null) {
+	return `${msgctxt ?? ""}::${msgid}`;
+}
+
+export function sameResolvedKey(
+	left: Pick<ResolvedKey, "msgid" | "msgctxt"> | null | undefined,
+	right: Pick<ResolvedKey, "msgid" | "msgctxt"> | null | undefined
+) {
+	return (
+		Boolean(left && right) &&
+		left?.msgid === right?.msgid &&
+		(left?.msgctxt ?? null) === (right?.msgctxt ?? null)
+	);
+}
+
+export function getEffectiveResolvedKey(
+	selectedResolvedKey: ResolvedKey | null,
+	contextResult: TranslationContextResult | null
+) {
+	return (
+		selectedResolvedKey ??
+		(contextResult?.entry
+			? {
+					msgid: contextResult.entry.msgid,
+					msgctxt: contextResult.entry.msgctxt
+				}
+			: null)
+	);
+}
+
+export function findContextEntry(
+	contextResult: TranslationContextResult | null,
+	msgid: string,
+	msgctxt: string | null
+) {
+	if (!contextResult) return null;
+
+	if (
+		contextResult.entry.msgid === msgid &&
+		(contextResult.entry.msgctxt ?? null) === (msgctxt ?? null)
+	) {
+		return contextResult.entry;
+	}
+
+	return (
+		contextResult.alternatives.find(
+			(alternative) =>
+				alternative.msgid === msgid && (alternative.msgctxt ?? null) === (msgctxt ?? null)
+		) ?? null
+	);
+}
+
+export function getEntryOriginalValue(
+	contextResult: TranslationContextResult | null,
+	msgid: string,
+	msgctxt: string | null
+) {
+	return findContextEntry(contextResult, msgid, msgctxt)?.msgstr?.[0] ?? "";
+}
+
+export function getEntryOrigin(
+	contextResult: TranslationContextResult | null,
+	msgid: string,
+	msgctxt: string | null
+): TranslationOrigin | null {
+	return findContextEntry(contextResult, msgid, msgctxt)?.translationOrigin ?? null;
+}
+
+export function getCandidateList(contextResult: TranslationContextResult | null): TranslationCandidate[] {
+	if (!contextResult) return [];
+
+	return [
+		{
+			msgid: contextResult.entry.msgid,
+			msgctxt: contextResult.entry.msgctxt,
+			translationOrigin: contextResult.entry.translationOrigin ?? null,
+			hasTranslation: contextResult.entry.hasTranslation ?? false,
+			isFuzzy: contextResult.entry.isFuzzy ?? null
+		},
+		...contextResult.alternatives.map((alternative) => ({
+			msgid: alternative.msgid,
+			msgctxt: alternative.msgctxt,
+			translationOrigin: alternative.translationOrigin ?? null,
+			hasTranslation: alternative.hasTranslation,
+			isFuzzy: alternative.isFuzzy ?? null
+		}))
+	];
+}
+
+export function getTranslationStatus(item: {
+	isCommittedToWorking?: boolean;
+	matchesTargetTranslation?: boolean;
+	hasTranslation?: boolean;
+	isFuzzy?: boolean | null;
+}) {
+	if (item.hasTranslation && item.matchesTargetTranslation) return "\u2705";
+	if (item.isCommittedToWorking) return "\u{1F6E0}\uFE0F";
+	if (!item.hasTranslation) return "\u274C";
+	if (item.isFuzzy) return "\u{1F914}";
+	return "\u2705";
+}

package/dist/client/translationSuggestions.ts

@@ -0,0 +1,100 @@
+import { translationKey, type TranslationContextResult } from "./toggleQA.shared";
+
+const STORAGE_KEY = "i18n-translation-suggestions-v1";
+
+
+type SuggestionMap = Record<string, string>;
+
+type SuggestionItem = {
+	msgid: string;
+	msgctxt: string | null;
+	suggestion: string;
+};
+
+function isBrowser() {
+	return typeof window !== "undefined" && typeof localStorage !== "undefined";
+}
+
+export function readSuggestionCache(): SuggestionMap {
+	if (!isBrowser()) return {};
+
+	try {
+		const raw = localStorage.getItem(STORAGE_KEY);
+		if (!raw) return {};
+		const parsed = JSON.parse(raw);
+		return typeof parsed === "object" && parsed ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+
+export function writeSuggestionCache(cache: SuggestionMap) {
+	if (!isBrowser()) return;
+
+	try {
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(cache));
+	} catch {
+		// Ignore storage failures in this dev-only helper.
+	}
+}
+
+function getEntriesForSuggestions(contextResult: TranslationContextResult) {
+	return [contextResult.entry, ...contextResult.alternatives];
+}
+
+function getUntranslatedItems(contextResult: TranslationContextResult, cache: SuggestionMap) {
+	return getEntriesForSuggestions(contextResult)
+		.filter((entry) => !entry.hasTranslation)
+		.filter((entry) => !cache[translationKey(entry.msgid, entry.msgctxt)])
+		.map((entry) => ({
+			msgid: entry.msgid,
+			msgctxt: entry.msgctxt
+		}));
+}
+
+function mergeSuggestionItems(cache: SuggestionMap, items: SuggestionItem[]) {
+	const nextCache = { ...cache };
+	for (const item of items) {
+		nextCache[translationKey(item.msgid, item.msgctxt)] = item.suggestion.trim();
+	}
+	return nextCache;
+}
+
+export async function requestTranslationSuggestions(
+	contextResult: TranslationContextResult,
+	endpoint: string
+): Promise<SuggestionMap> {
+	const cache = readSuggestionCache();
+	const untranslatedItems = getUntranslatedItems(contextResult, cache);
+	if (!untranslatedItems.length) {
+		return cache;
+	}
+
+	const response = await fetch(`${endpoint}?intent=suggestions`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json"
+		},
+		body: JSON.stringify({
+			context: contextResult,
+			items: untranslatedItems
+		})
+	});
+
+	if (!response.ok) {
+		throw new Error(`Suggestion request failed: ${response.status}`);
+	}
+
+	const json = await response.json();
+	if (json?.disabled) {
+		return cache;
+	}
+	const items = Array.isArray(json?.items) ? (json.items as SuggestionItem[]) : [];
+	if (!items.length) {
+		return cache;
+	}
+
+	const nextCache = mergeSuggestionItems(cache, items);
+	writeSuggestionCache(nextCache);
+	return nextCache;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { default as Angy } from "./client/Angy.svelte";

package/dist/index.js

@@ -0,0 +1 @@
+export { default as Angy } from "./client/Angy.svelte";

package/dist/plugin.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin } from "vite";
+import {
+	defineAngyConfig,
+	type AngyConfigInput,
+	type AngyResolvedConfig,
+	type SuggestionProvider,
+	type SuggestionProviderInput,
+	type SuggestionRequestItem,
+	type SuggestionResponseItem
+} from "./server";
+
+export type AngyPluginOptions = {
+	config?: Partial<AngyResolvedConfig>;
+};
+
+export declare function angy(options?: AngyPluginOptions): Plugin;
+
+export {
+	defineAngyConfig,
+	type AngyConfigInput,
+	type AngyResolvedConfig,
+	type SuggestionProvider,
+	type SuggestionProviderInput,
+	type SuggestionRequestItem,
+	type SuggestionResponseItem
+};