523 lines
22 KiB
JavaScript
523 lines
22 KiB
JavaScript
(() => {
|
|
const progressRoots = [...document.querySelectorAll("[data-story-intelligence-progress]")];
|
|
const dashboardRoots = [...document.querySelectorAll("[data-story-intelligence-dashboard]")];
|
|
const onboardingRoots = [...document.querySelectorAll("[data-story-intelligence-onboarding]")];
|
|
const legacyRoots = [...progressRoots, ...dashboardRoots];
|
|
const roots = [...legacyRoots, ...onboardingRoots];
|
|
if (roots.length === 0 || !window.signalR) {
|
|
return;
|
|
}
|
|
|
|
const field = (state, camel, pascal) => state?.[camel] ?? state?.[pascal] ?? null;
|
|
const legacyJobIds = [...new Set(legacyRoots.map((root) => root.dataset.storyIntelligenceJobId).filter(Boolean))];
|
|
const runIds = [...new Set(onboardingRoots
|
|
.flatMap((root) => (root.dataset.storyIntelligenceRunIds || "").split(","))
|
|
.map((value) => value.trim())
|
|
.filter(Boolean))];
|
|
|
|
const numberText = (value) => {
|
|
const number = Number.parseInt(value ?? "0", 10);
|
|
return Number.isFinite(number) ? number.toLocaleString() : "0";
|
|
};
|
|
|
|
const friendlyStatus = (status) => {
|
|
switch (status) {
|
|
case "Pending":
|
|
return "Waiting";
|
|
case "Running":
|
|
return "Reading";
|
|
case "Completed":
|
|
return "Ready to review";
|
|
case "CompletedWithWarnings":
|
|
return "Ready to review, with notes";
|
|
case "Failed":
|
|
return "Needs attention";
|
|
case "Cancelled":
|
|
return "Cancelled";
|
|
default:
|
|
return "Waiting";
|
|
}
|
|
};
|
|
|
|
const friendlyStage = (stage, status) => {
|
|
if (status === "Completed" || status === "CompletedWithWarnings") {
|
|
return "Ready to review";
|
|
}
|
|
if (status === "Failed") {
|
|
return "Needs attention";
|
|
}
|
|
if (status === "Cancelled") {
|
|
return "Cancelled";
|
|
}
|
|
|
|
switch (stage) {
|
|
case "Queued":
|
|
return "Waiting";
|
|
case "DocumentRead":
|
|
return "Preparing chapter";
|
|
case "ChapterStructure":
|
|
return "Finding scenes";
|
|
case "SceneSplit":
|
|
return "Preparing scenes";
|
|
case "SceneIntelligence":
|
|
return "Reading scenes";
|
|
case "Validation":
|
|
return "Checking results";
|
|
case "Persistence":
|
|
return "Saving analysis";
|
|
default:
|
|
return "Reading";
|
|
}
|
|
};
|
|
|
|
const friendlyRemainingFromSeconds = (seconds) => {
|
|
const minutes = Math.ceil(seconds / 60);
|
|
if (!Number.isFinite(minutes) || minutes <= 0) {
|
|
return "Estimating...";
|
|
}
|
|
|
|
if (minutes <= 20) {
|
|
return "About 20-30 minutes";
|
|
}
|
|
if (minutes <= 45) {
|
|
return "About 45-60 minutes";
|
|
}
|
|
if (minutes <= 120) {
|
|
return "About 1-2 hours";
|
|
}
|
|
return "More than 2 hours";
|
|
};
|
|
|
|
const calculateRemaining = (chapters, hasActiveRuns) => {
|
|
if (!hasActiveRuns) {
|
|
return "Ready to review";
|
|
}
|
|
|
|
const completed = chapters.filter((chapter) => {
|
|
const status = chapter.dataset.storyRawStatus || "";
|
|
const words = Number.parseInt(chapter.dataset.storySourceWordCount || "0", 10) || 0;
|
|
const duration = Number.parseInt(chapter.dataset.storyDurationMs || "0", 10) || 0;
|
|
return (status === "Completed" || status === "CompletedWithWarnings") && words > 0 && duration > 0;
|
|
});
|
|
|
|
if (completed.length === 0) {
|
|
return "Estimating...";
|
|
}
|
|
|
|
const completedWords = completed.reduce((total, chapter) => total + (Number.parseInt(chapter.dataset.storySourceWordCount || "0", 10) || 0), 0);
|
|
const completedSeconds = completed.reduce((total, chapter) => total + ((Number.parseInt(chapter.dataset.storyDurationMs || "0", 10) || 0) / 1000), 0);
|
|
const remainingWords = chapters.reduce((total, chapter) => {
|
|
const status = chapter.dataset.storyRawStatus || "";
|
|
if (status === "Completed" || status === "CompletedWithWarnings" || status === "Failed" || status === "Cancelled") {
|
|
return total;
|
|
}
|
|
return total + (Number.parseInt(chapter.dataset.storySourceWordCount || "0", 10) || 0);
|
|
}, 0);
|
|
|
|
if (completedWords <= 0 || completedSeconds <= 0 || remainingWords <= 0) {
|
|
return "Estimating...";
|
|
}
|
|
|
|
return friendlyRemainingFromSeconds((completedSeconds / completedWords) * remainingWords * 1.35);
|
|
};
|
|
|
|
const possibleDiscoveryText = (text) => String(text || "")
|
|
.replace(/^Character detected:/i, "Possible character found:")
|
|
.replace(/^Possible character detected:/i, "Possible character found:")
|
|
.replace(/^Location detected:/i, "Possible location found:")
|
|
.replace(/^Possible location detected:/i, "Possible location found:")
|
|
.replace(/^Asset detected:/i, "Possible asset found:")
|
|
.replace(/^Possible asset detected:/i, "Possible asset found:")
|
|
.replace(/^Timeline clue detected:/i, "Timeline clue found:")
|
|
.replace(/^Relationship detected:/i, "Relationship signal found:");
|
|
|
|
const friendlyMessage = (message, stage, status, sceneNumber) => {
|
|
if (status === "Cancelled") {
|
|
return "Analysis was cancelled. Any completed chapters remain available for review.";
|
|
}
|
|
if (status === "Failed") {
|
|
return "This chapter needs attention before scenes can be created.";
|
|
}
|
|
if (status === "Completed" || status === "CompletedWithWarnings") {
|
|
return "This chapter is ready to review.";
|
|
}
|
|
|
|
switch (stage) {
|
|
case "Queued":
|
|
return "Waiting to read this chapter.";
|
|
case "DocumentRead":
|
|
return "Preparing this chapter.";
|
|
case "ChapterStructure":
|
|
return "Finding scenes in this chapter.";
|
|
case "SceneSplit":
|
|
return "Preparing the detected scenes.";
|
|
case "SceneIntelligence":
|
|
return sceneNumber ? `Reading scene ${numberText(sceneNumber)}.` : "Reading the detected scenes.";
|
|
case "Validation":
|
|
return "Checking the results.";
|
|
default:
|
|
return message || "Waiting for analysis to begin.";
|
|
}
|
|
};
|
|
|
|
const updateLegacyRoot = (root, state) => {
|
|
const percent = field(state, "progressPercent", "ProgressPercent") ?? 0;
|
|
const status = field(state, "status", "Status") || "Pending";
|
|
const stage = field(state, "currentStage", "CurrentStage") || status;
|
|
const message = field(state, "currentMessage", "CurrentMessage") || "Story Intelligence is preparing.";
|
|
const elapsed = field(state, "elapsedTime", "ElapsedTime") || "0 sec";
|
|
const remaining = field(state, "estimatedRemaining", "EstimatedRemaining") || "Calculating";
|
|
|
|
root.querySelectorAll("[data-story-intelligence-message]").forEach((node) => {
|
|
node.textContent = message;
|
|
});
|
|
root.querySelectorAll("[data-story-intelligence-percent]").forEach((node) => {
|
|
node.textContent = `${percent}%`;
|
|
});
|
|
root.querySelectorAll("[data-story-intelligence-progress-bar]").forEach((node) => {
|
|
node.style.width = `${Math.max(0, Math.min(100, Number.parseInt(percent, 10) || 0))}%`;
|
|
});
|
|
root.querySelectorAll("[data-story-intelligence-stage]").forEach((node) => {
|
|
node.textContent = stage;
|
|
});
|
|
root.querySelectorAll("[data-story-intelligence-status]").forEach((node) => {
|
|
node.textContent = status;
|
|
});
|
|
root.querySelectorAll("[data-story-intelligence-elapsed]").forEach((node) => {
|
|
node.textContent = elapsed;
|
|
});
|
|
root.querySelectorAll("[data-story-intelligence-remaining]").forEach((node) => {
|
|
node.textContent = remaining;
|
|
});
|
|
|
|
const completed = !!field(state, "isCompleted", "IsCompleted");
|
|
root.querySelectorAll("[data-story-intelligence-complete-link]").forEach((node) => {
|
|
node.classList.toggle("disabled", !completed);
|
|
node.setAttribute("aria-disabled", String(!completed));
|
|
});
|
|
};
|
|
|
|
const applyLegacyProgress = (state) => {
|
|
const jobId = field(state, "jobID", "JobID") || field(state, "jobId", "JobId");
|
|
if (!jobId) {
|
|
return;
|
|
}
|
|
|
|
legacyRoots
|
|
.filter((root) => root.dataset.storyIntelligenceJobId?.toLowerCase() === String(jobId).toLowerCase())
|
|
.forEach((root) => updateLegacyRoot(root, state));
|
|
|
|
if (progressRoots.length > 0 && field(state, "isCompleted", "IsCompleted")) {
|
|
window.location.href = `/onboarding/story-intelligence/complete?jobId=${encodeURIComponent(jobId)}`;
|
|
}
|
|
};
|
|
|
|
const statusLabel = (state) => {
|
|
const status = field(state, "status", "Status") || "";
|
|
if (status === "Completed" || status === "CompletedWithWarnings") {
|
|
return "Ready to create";
|
|
}
|
|
if (status === "Failed" || status === "Cancelled") {
|
|
return "Needs attention";
|
|
}
|
|
if (status === "Pending" || status === "Running") {
|
|
return "Analysing";
|
|
}
|
|
return "Reviewing";
|
|
};
|
|
|
|
const addFeedItem = (list, text) => {
|
|
if (!list || !text) {
|
|
return;
|
|
}
|
|
|
|
const item = document.createElement("li");
|
|
item.textContent = possibleDiscoveryText(text);
|
|
list.prepend(item);
|
|
const placeholder = list.closest(".story-live-discoveries")?.querySelector("[data-story-discovery-empty]");
|
|
if (placeholder) {
|
|
placeholder.hidden = true;
|
|
}
|
|
while (list.children.length > 8) {
|
|
list.lastElementChild?.remove();
|
|
}
|
|
};
|
|
|
|
const parseNumber = (value) => Number.parseFloat(String(value || "").replace(/,/g, "")) || 0;
|
|
|
|
const parseTime = (value) => {
|
|
const parsed = Date.parse(value || "");
|
|
return Number.isNaN(parsed) ? 0 : parsed;
|
|
};
|
|
|
|
const isActiveStatus = (status) => status === "Pending" || status === "Running";
|
|
|
|
const authoritativeChapter = (chapters) => {
|
|
const active = chapters
|
|
.filter((chapter) => isActiveStatus(chapter.dataset.storyRawStatus || "")
|
|
&& parseNumber(chapter.dataset.storyCurrentSceneNumber) > 0)
|
|
.sort((left, right) => {
|
|
const byUpdated = parseTime(right.dataset.storyUpdatedUtc) - parseTime(left.dataset.storyUpdatedUtc);
|
|
if (byUpdated !== 0) return byUpdated;
|
|
return parseNumber(right.dataset.storyChapterNumber) - parseNumber(left.dataset.storyChapterNumber);
|
|
});
|
|
if (active.length > 0) return active[0];
|
|
|
|
const completed = chapters
|
|
.filter((chapter) => {
|
|
const status = chapter.dataset.storyRawStatus || "";
|
|
return status === "Completed" || status === "CompletedWithWarnings";
|
|
})
|
|
.sort((left, right) => {
|
|
const byUpdated = parseTime(right.dataset.storyUpdatedUtc) - parseTime(left.dataset.storyUpdatedUtc);
|
|
if (byUpdated !== 0) return byUpdated;
|
|
return parseNumber(right.dataset.storyChapterNumber) - parseNumber(left.dataset.storyChapterNumber);
|
|
});
|
|
return completed[0] || chapters[0] || null;
|
|
};
|
|
|
|
const applyAuthoritativeCursor = (root) => {
|
|
const chapters = [...root.querySelectorAll("[data-story-run-id]")];
|
|
const chapter = authoritativeChapter(chapters);
|
|
if (!chapter) return;
|
|
|
|
const status = chapter.dataset.storyRawStatus || "Pending";
|
|
const stage = chapter.dataset.storyCurrentStage || status;
|
|
const currentSceneNumber = chapter.dataset.storyCurrentSceneNumber || "";
|
|
const total = chapter.querySelector("[data-story-run-total]")?.textContent || "";
|
|
const completed = chapter.querySelector("[data-story-run-completed]")?.textContent || "";
|
|
const message = chapter.querySelector("[data-story-run-message]")?.textContent || "";
|
|
|
|
root.querySelectorAll("[data-story-current-chapter]").forEach((node) => {
|
|
node.textContent = chapter.dataset.storyChapterTitle || "Current chapter";
|
|
});
|
|
root.querySelectorAll("[data-story-current-stage]").forEach((node) => {
|
|
node.textContent = friendlyStage(stage, status);
|
|
});
|
|
root.querySelectorAll("[data-story-current-scene]").forEach((node) => {
|
|
node.textContent = currentSceneNumber ? numberText(currentSceneNumber) : "Waiting";
|
|
});
|
|
const totalNumber = Number.parseInt(total.replace(/,/g, "") || "0", 10) || 0;
|
|
const completedNumber = Number.parseInt(completed.replace(/,/g, "") || "0", 10) || 0;
|
|
const currentSceneDisplay = currentSceneNumber ? Number.parseInt(currentSceneNumber, 10) || completedNumber : completedNumber;
|
|
root.querySelectorAll("[data-story-chapter-progress-text]").forEach((node) => {
|
|
node.textContent = totalNumber > 0
|
|
? `Scene ${numberText(Math.min(Math.max(currentSceneDisplay, 0), totalNumber))} of ${numberText(totalNumber)}`
|
|
: "Finding scenes...";
|
|
});
|
|
root.querySelectorAll("[data-story-current-message]").forEach((node) => {
|
|
node.textContent = message;
|
|
});
|
|
};
|
|
|
|
const recalculateOnboardingTotals = (root) => {
|
|
const hadActiveRuns = root.dataset.storyIntelligenceHasActiveRuns === "true";
|
|
const chapters = [...root.querySelectorAll("[data-story-run-id]")];
|
|
const totals = chapters.reduce((current, chapter) => {
|
|
const status = chapter.dataset.storyRawStatus || "";
|
|
const completed = Number.parseInt(chapter.querySelector("[data-story-run-completed]")?.textContent?.replace(/,/g, "") || "0", 10) || 0;
|
|
const total = Number.parseInt(chapter.querySelector("[data-story-run-total]")?.textContent?.replace(/,/g, "") || "0", 10) || 0;
|
|
const failed = Number.parseInt(chapter.querySelector("[data-story-run-failed]")?.textContent?.replace(/,/g, "") || "0", 10) || 0;
|
|
current.completedChapters += status === "Completed" || status === "CompletedWithWarnings" ? 1 : 0;
|
|
current.failedChapters += status === "Failed" || status === "Cancelled" ? 1 : 0;
|
|
current.completedScenes += completed;
|
|
current.totalScenes += total;
|
|
current.failedScenes += failed;
|
|
return current;
|
|
}, { completedChapters: 0, failedChapters: 0, completedScenes: 0, totalScenes: 0, failedScenes: 0 });
|
|
|
|
const chapterProgress = chapters.reduce((total, chapter) => {
|
|
const status = chapter.dataset.storyRawStatus || "";
|
|
if (status === "Completed" || status === "CompletedWithWarnings" || status === "Failed" || status === "Cancelled") {
|
|
return total + 1;
|
|
}
|
|
if (status === "Pending") {
|
|
return total;
|
|
}
|
|
const completed = Number.parseInt(chapter.querySelector("[data-story-run-completed]")?.textContent?.replace(/,/g, "") || "0", 10) || 0;
|
|
const detected = Number.parseInt(chapter.querySelector("[data-story-run-total]")?.textContent?.replace(/,/g, "") || "0", 10) || 0;
|
|
if (detected > 0) {
|
|
return total + Math.min(0.95, 0.25 + ((completed / Math.max(1, detected)) * 0.7));
|
|
}
|
|
return total + 0.15;
|
|
}, 0);
|
|
const calculatedPercent = Math.floor((chapterProgress * 100) / Math.max(1, chapters.length));
|
|
const previousPercent = Number.parseInt(root.dataset.storyMaxProgressPercent || "0", 10) || 0;
|
|
const percent = Math.max(previousPercent, Math.max(0, Math.min(100, calculatedPercent)));
|
|
root.dataset.storyMaxProgressPercent = String(percent);
|
|
|
|
root.querySelectorAll("[data-story-overall-percent]").forEach((node) => {
|
|
node.textContent = `${Math.max(0, Math.min(100, percent))}%`;
|
|
});
|
|
root.querySelectorAll("[data-story-overall-progress-bar]").forEach((node) => {
|
|
node.style.width = `${Math.max(0, Math.min(100, percent))}%`;
|
|
});
|
|
root.querySelectorAll("[data-story-chapters-read-value]").forEach((node) => {
|
|
node.textContent = `${numberText(totals.completedChapters)} of ${numberText(chapters.length)}`;
|
|
});
|
|
root.querySelectorAll("[data-story-scenes-read-value]").forEach((node) => {
|
|
node.textContent = `${numberText(totals.completedScenes)} so far`;
|
|
});
|
|
root.querySelectorAll("[data-story-scenes-total]").forEach((node) => {
|
|
node.textContent = numberText(totals.totalScenes);
|
|
});
|
|
root.querySelectorAll("[data-story-failures]").forEach((node) => {
|
|
node.textContent = numberText(totals.failedChapters + totals.failedScenes);
|
|
});
|
|
|
|
const active = chapters.some((chapter) => {
|
|
const status = chapter.dataset.storyRawStatus || "";
|
|
return status === "Pending" || status === "Running";
|
|
});
|
|
root.dataset.storyIntelligenceHasActiveRuns = String(active);
|
|
root.querySelectorAll("[data-story-remaining]").forEach((node) => {
|
|
node.textContent = calculateRemaining(chapters, active);
|
|
});
|
|
applyAuthoritativeCursor(root);
|
|
|
|
if (hadActiveRuns && !active && root.dataset.reloadScheduled !== "true") {
|
|
root.dataset.reloadScheduled = "true";
|
|
window.setTimeout(() => window.location.reload(), 1200);
|
|
}
|
|
};
|
|
|
|
const applyRunProgress = (state) => {
|
|
const runId = field(state, "runID", "RunID") || field(state, "runId", "RunId");
|
|
if (!runId) {
|
|
return;
|
|
}
|
|
|
|
onboardingRoots.forEach((root) => {
|
|
const chapter = root.querySelector(`[data-story-run-id="${runId}"]`);
|
|
if (!chapter) {
|
|
return;
|
|
}
|
|
|
|
const status = field(state, "status", "Status") || "Pending";
|
|
const stage = field(state, "currentStage", "CurrentStage") || status;
|
|
const message = field(state, "currentMessage", "CurrentMessage") || "";
|
|
const completed = field(state, "completedScenes", "CompletedScenes");
|
|
const total = field(state, "totalDetectedScenes", "TotalDetectedScenes");
|
|
const failed = field(state, "failedScenes", "FailedScenes");
|
|
const tokens = field(state, "totalTokens", "TotalTokens");
|
|
const totalDurationMs = field(state, "totalDurationMs", "TotalDurationMs");
|
|
const elapsed = field(state, "elapsedTime", "ElapsedTime") || "0 sec";
|
|
const currentSceneNumber = field(state, "currentSceneNumber", "CurrentSceneNumber");
|
|
const updatedUtc = field(state, "updatedUtc", "UpdatedUtc");
|
|
const displayMessage = friendlyMessage(message, stage, status, currentSceneNumber);
|
|
const latestSummary = field(state, "latestSceneSummary", "LatestSceneSummary");
|
|
const discoveries = field(state, "recentDiscoveries", "RecentDiscoveries") || [];
|
|
const error = field(state, "errorMessage", "ErrorMessage");
|
|
|
|
chapter.querySelectorAll("[data-story-chapter-status-label]").forEach((node) => {
|
|
node.textContent = statusLabel(state);
|
|
});
|
|
chapter.dataset.storyRawStatus = status;
|
|
chapter.dataset.storyCurrentStage = stage;
|
|
chapter.dataset.storyCurrentSceneNumber = completed || "0";
|
|
if (updatedUtc) {
|
|
chapter.dataset.storyUpdatedUtc = updatedUtc;
|
|
}
|
|
if (totalDurationMs !== null) {
|
|
chapter.dataset.storyDurationMs = String(totalDurationMs);
|
|
}
|
|
chapter.querySelectorAll("[data-story-run-status]").forEach((node) => {
|
|
node.textContent = friendlyStatus(status);
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-raw-status]").forEach((node) => {
|
|
node.textContent = status;
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-raw-stage]").forEach((node) => {
|
|
node.textContent = stage;
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-message]").forEach((node) => {
|
|
node.textContent = displayMessage;
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-completed]").forEach((node) => {
|
|
if (completed !== null) {
|
|
node.textContent = numberText(completed);
|
|
}
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-total]").forEach((node) => {
|
|
if (total !== null) {
|
|
node.textContent = numberText(total);
|
|
}
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-failed]").forEach((node) => {
|
|
if (failed !== null) {
|
|
node.textContent = numberText(failed);
|
|
}
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-review-note]").forEach((node) => {
|
|
const failedCount = Number.parseInt(failed || "0", 10) || 0;
|
|
node.textContent = failedCount > 0 ? "Needs review after analysis completes." : "";
|
|
node.hidden = failedCount <= 0;
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-tokens]").forEach((node) => {
|
|
node.textContent = tokens === null ? "-" : numberText(tokens);
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-error]").forEach((node) => {
|
|
node.textContent = error || "";
|
|
node.hidden = !error;
|
|
});
|
|
chapter.querySelectorAll("[data-story-run-latest-summary]").forEach((node) => {
|
|
if (latestSummary) {
|
|
node.textContent = latestSummary;
|
|
}
|
|
});
|
|
|
|
const totalNumber = Number.parseInt(total || "0", 10) || 0;
|
|
const completedNumber = Number.parseInt(completed || "0", 10) || 0;
|
|
root.querySelectorAll("[data-story-chapter-progress-bar]").forEach((node) => {
|
|
const percent = totalNumber > 0 ? Math.floor((Math.min(completedNumber, totalNumber) * 100) / totalNumber) : 0;
|
|
node.style.width = `${Math.max(0, Math.min(100, percent))}%`;
|
|
});
|
|
root.querySelectorAll("[data-story-elapsed]").forEach((node) => {
|
|
node.textContent = elapsed;
|
|
});
|
|
const summaryNode = root.querySelector("[data-story-latest-summary]");
|
|
if (summaryNode && latestSummary) {
|
|
summaryNode.textContent = latestSummary;
|
|
summaryNode.hidden = false;
|
|
const emptyNode = root.querySelector("[data-story-latest-empty]");
|
|
if (emptyNode) {
|
|
emptyNode.hidden = true;
|
|
}
|
|
}
|
|
|
|
const feed = root.querySelector("[data-story-discovery-feed]");
|
|
[...discoveries].reverse().forEach((discovery) => addFeedItem(feed, discovery));
|
|
|
|
recalculateOnboardingTotals(root);
|
|
});
|
|
};
|
|
|
|
const connection = new signalR.HubConnectionBuilder()
|
|
.withUrl("/hubs/story-intelligence")
|
|
.withAutomaticReconnect()
|
|
.build();
|
|
|
|
connection.on("StoryIntelligenceProgressChanged", applyLegacyProgress);
|
|
connection.on("StoryIntelligenceRunProgressChanged", applyRunProgress);
|
|
connection.onreconnected(() => {
|
|
legacyJobIds.forEach((jobId) => connection.invoke("WatchStoryIntelligenceJob", jobId).then(applyLegacyProgress).catch(() => {}));
|
|
runIds.forEach((runId) => connection.invoke("WatchStoryIntelligenceRun", Number.parseInt(runId, 10)).then(applyRunProgress).catch(() => {}));
|
|
});
|
|
|
|
connection.start()
|
|
.then(() => Promise.all([
|
|
...legacyJobIds.map((jobId) => connection.invoke("WatchStoryIntelligenceJob", jobId)),
|
|
...runIds.map((runId) => connection.invoke("WatchStoryIntelligenceRun", Number.parseInt(runId, 10)))
|
|
]))
|
|
.then((states) => {
|
|
states.filter(Boolean).forEach((state) => {
|
|
if (field(state, "runID", "RunID") || field(state, "runId", "RunId")) {
|
|
applyRunProgress(state);
|
|
} else {
|
|
applyLegacyProgress(state);
|
|
}
|
|
});
|
|
})
|
|
.catch(() => {});
|
|
})();
|