@parhelia/localization 0.4.12872 → 0.4.12873

package/dist/translation-center/TranslationBatches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TranslationBatches.d.ts","sourceRoot":"","sources":["../../src/translation-center/TranslationBatches.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,MAAM,OAAO,CAAC;AA0V1B,wBAAgB,kBAAkB,sBA6qCjC;AAED,eAAO,MAAM,oCAAoC,8BAA8B,CAAC;AAEhF,wBAAgB,8BAA8B,sBA+Y7C"}
+{"version":3,"file":"TranslationBatches.d.ts","sourceRoot":"","sources":["../../src/translation-center/TranslationBatches.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,MAAM,OAAO,CAAC;AAyb1B,wBAAgB,kBAAkB,sBA8uCjC;AAED,eAAO,MAAM,oCAAoC,8BAA8B,CAAC;AAEhF,wBAAgB,8BAA8B,sBA+Y7C"}

package/dist/translation-center/TranslationBatches.js

@@ -1,10 +1,10 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useRef, useState, useMemo, useSyncExternalStore, } from "react";
 import React from "react";
-import { Button, Badge, Select, Input, UserPicker, Popover, PopoverContent, PopoverTrigger, Tooltip, TooltipContent, TooltipTrigger, ContentTree, ContentInspectorPopover, PageHeader, fetchItemStubs, searchUsers as searchBackendUsers, useEditContext, getLanguages, SimpleIconButton, WorkspaceHomeView, capitalizeFirstLetter, formatDateTime, } from "@parhelia/core";
+import { Button, Badge, Select, Input, UserPicker, Popover, PopoverContent, PopoverTrigger, Tooltip, TooltipContent, TooltipTrigger, ContentTree, ContentInspectorPopover, PageHeader, fetchItemStubs, searchUsers as searchBackendUsers, useEditContext, getLanguages, SimpleIconButton, WorkspaceHomeView, capitalizeFirstLetter, createCoalescedReload, formatDateTime, } from "@parhelia/core";
 import { listBatches, getTranslationProviders, getTranslationJobLastPayload, listBatchTranslationJobs, retryBatchTranslation, abortJob, abortBatch, subscribeToBatch, unsubscribeFromBatch, } from "../services/translationService";
 import { TRANSLATION_BATCH_STARTED_EVENT, } from "../translationEvents";
-import { useDebouncedCallback } from "use-debounce";
+import { useDebouncedCallback, useThrottledCallback } from "use-debounce";
 import { X, ChevronDown, Languages, Loader2, Globe, FolderTree, ExternalLink, Check, AlertCircle, CircleStop, Hourglass, Copy, Sparkles, RotateCcw, Plus, Bug, } from "lucide-react";
 import { toast } from "sonner";
 import { openLocalizeItemDialog } from "../LocalizeItemCommand";
@@ -142,6 +142,77 @@ function normalizeGuid(value) {
 function normalizeLanguageCode(value) {
     return (value ?? "").toString().trim().toLowerCase();
 }
+const JOB_STATUS_BY_EVENT = {
+    "translation-started": "In Progress",
+    "translation-finished": "Completed",
+    "translation-error": "Error",
+    "translation-aborted": "Aborted",
+};
+function pickPayloadValue(payload, ...keys) {
+    for (const key of keys) {
+        const value = payload[key];
+        if (value !== undefined && value !== null)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * Applies a per-job socket event to a loaded job list. The server sends the
+ * same event twice to the initiating session (directly and through the batch
+ * subscription) and in either property casing, so this is idempotent and
+ * reads both spellings.
+ *
+ * Returns `undefined` when the event's job is not in the list (the caller
+ * then needs a reload), the same array when nothing changed, and a new array
+ * with the patched record otherwise.
+ */
+function applyJobStatusEvent(jobs, eventType, rawPayload) {
+    const payload = (rawPayload ?? {});
+    const status = String(pickPayloadValue(payload, "status", "Status") ??
+        JOB_STATUS_BY_EVENT[eventType] ??
+        "");
+    if (!status)
+        return undefined;
+    const translationId = normalizeGuid(pickPayloadValue(payload, "id", "Id"));
+    const itemId = normalizeGuid(pickPayloadValue(payload, "itemId", "ItemId"));
+    const language = String(pickPayloadValue(payload, "language", "Language") ?? "");
+    let index = -1;
+    if (translationId) {
+        index = jobs.findIndex((job) => normalizeGuid(job.id) === translationId);
+    }
+    if (index < 0 && itemId && language) {
+        const candidates = jobs
+            .map((job, i) => ({ job, i }))
+            .filter(({ job }) => normalizeGuid(job.itemId) === itemId &&
+            job.targetLanguage === language);
+        // Retries add records for the same item and language; a running one is
+        // the event's subject, otherwise the newest record.
+        const active = candidates.find(({ job }) => !isTerminalBatchStatus(job.status));
+        index = (active ?? candidates[candidates.length - 1])?.i ?? -1;
+    }
+    const job = index >= 0 ? jobs[index] : undefined;
+    if (!job)
+        return undefined;
+    const next = { ...job, status };
+    const message = pickPayloadValue(payload, "message", "Message");
+    if (typeof message === "string" && message)
+        next.message = message;
+    const timestamp = pickPayloadValue(payload, "timestamp", "Timestamp");
+    if (typeof timestamp === "string" && timestamp)
+        next.timestamp = timestamp;
+    const totalCost = pickPayloadValue(payload, "totalCost", "TotalCost");
+    if (typeof totalCost === "number")
+        next.totalCost = totalCost;
+    const unchanged = next.status === job.status &&
+        next.message === job.message &&
+        next.timestamp === job.timestamp &&
+        next.totalCost === job.totalCost;
+    if (unchanged)
+        return jobs;
+    const result = jobs.slice();
+    result[index] = next;
+    return result;
+}
 function dateRangeToFromUtc(range) {
     const now = new Date();
     const cutoff = new Date(now);
@@ -175,6 +246,10 @@ function dateRangeToFromUtc(range) {
     }
     return cutoff.toISOString();
 }
+/** Quiet window that collapses a burst of job events into one job-list read. */
+const BATCH_JOBS_RELOAD_WINDOW_MS = 400;
+/** Longest a running batch's row counters lag behind its job events. */
+const BATCH_LIST_RELOAD_THROTTLE_MS = 3000;
 const EMPTY_STATE_SLOGANS = [
     "It's quiet here. In every language.",
     "Zero translations. Nada. Nichts. Rien.",
@@ -337,6 +412,10 @@ export function TranslationBatches() {
         }
     }, []);
     const debouncedReload = useDebouncedCallback(() => loadRecentBatches(0, false, effectiveFilters), 800);
+    // Per-job events only move a row's counters; one list read every few
+    // seconds keeps the rings honest without a read per job. Batch completion
+    // still goes through the quicker debounced reload above.
+    const throttledReload = useThrottledCallback(() => loadRecentBatches(0, false, effectiveFilters), BATCH_LIST_RELOAD_THROTTLE_MS);
     const loadMore = () => {
         if (!isLoadingMore && hasMore) {
             loadRecentBatches(currentOffset, true, effectiveFilters);
@@ -419,11 +498,28 @@ export function TranslationBatches() {
     useEffect(() => {
         debouncedReloadRef.current = debouncedReload;
     }, [debouncedReload]);
+    const throttledReloadRef = useRef(throttledReload);
+    useEffect(() => {
+        throttledReloadRef.current = throttledReload;
+    }, [throttledReload]);
+    // Mirror of the loaded job lists for the socket listener, which must know
+    // synchronously whether an event's job is loaded before deciding between an
+    // in-place patch and a full reload.
+    const batchJobsRef = useRef(batchJobs);
+    useEffect(() => {
+        batchJobsRef.current = batchJobs;
+    }, [batchJobs]);
     const expandedBatchIdRef = useRef(expandedBatchId);
     useEffect(() => {
         expandedBatchIdRef.current = expandedBatchId;
     }, [expandedBatchId]);
     const loadBatchJobsRef = useRef(null);
+    // Job events arrive in bursts: one per job start and finish, and the
+    // initiator's session receives each twice (sent directly and again through
+    // the batch subscription). Every one used to trigger its own full job-list
+    // read. Collapse them into one read per batch per window, never two at once.
+    const batchJobsReload = useMemo(() => createCoalescedReload((batchId) => loadBatchJobsRef.current?.(batchId) ?? Promise.resolve([]), BATCH_JOBS_RELOAD_WINDOW_MS), []);
+    useEffect(() => () => batchJobsReload.dispose(), [batchJobsReload]);
     // Listen for batch-related events to refresh the list
     useEffect(() => {
         const removeSocketMessageListener = editContext?.addSocketMessageListener((message) => {
@@ -460,19 +556,48 @@ export function TranslationBatches() {
                 }
                 return;
             }
-            if (message.type === "batch-completed" ||
-                ((message.type === "translation-started" ||
-                    message.type === "translation-finished" ||
-                    message.type === "translation-error" ||
-                    message.type === "translation-aborted") &&
-                    batchIdFromPayload)) {
+            if (message.type === "batch-completed") {
+                // Final state: the row's status and counters, and the authoritative
+                // job records (attempts, costs, messages) for the open batch.
                 debouncedReloadRef.current();
-                // If the impacted batch is currently expanded, refresh its per-job
-                // list too — otherwise the language chips keep their stale spinner.
                 if (batchIdFromPayload &&
                     expandedBatchIdRef.current === batchIdFromPayload) {
-                    void loadBatchJobsRef.current?.(batchIdFromPayload);
+                    batchJobsReload.request(batchIdFromPayload);
                 }
+                return;
+            }
+            if ((message.type === "translation-started" ||
+                message.type === "translation-finished" ||
+                message.type === "translation-error" ||
+                message.type === "translation-aborted") &&
+                batchIdFromPayload) {
+                throttledReloadRef.current();
+                if (expandedBatchIdRef.current !== batchIdFromPayload)
+                    return;
+                // The event names the job and its new status, so the open batch's
+                // chips are patched in place. A full job-list read (hundreds of KB
+                // for a large batch) is only needed when the job is not loaded,
+                // e.g. a retry that added records, or a list still being fetched.
+                const loadedJobs = batchJobsRef.current[batchIdFromPayload];
+                const isLoaded = !!loadedJobs &&
+                    applyJobStatusEvent(loadedJobs, message.type, message.payload) !==
+                        undefined;
+                if (!isLoaded) {
+                    batchJobsReload.request(batchIdFromPayload);
+                    return;
+                }
+                // Patch against React's own previous state: several events can
+                // arrive before the ref mirror above catches up.
+                setBatchJobs((prev) => {
+                    const current = prev[batchIdFromPayload];
+                    if (!current)
+                        return prev;
+                    const next = applyJobStatusEvent(current, message.type, message.payload) ??
+                        current;
+                    return next === current
+                        ? prev
+                        : { ...prev, [batchIdFromPayload]: next };
+                });
             }
         });
         return () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parhelia/localization",
-  "version": "0.4.12872",
+  "version": "0.4.12873",
   "type": "module",
   "publishConfig": {
     "access": "public"