John O'Keefe
e1153b2c4b
- per-row Cancel button in the scan-progress card; listeners are bound after the TS island renders its rows (module scope has no inline handlers), and the button is removed once its job turns terminal - cancel-all icon button in the card header: resolves the server's active job list first, so it also covers scans this page never started (e.g. started before a refresh), then cancels each one - polling treats cancelled as terminal, averages overall progress only over jobs that can still advance (so the bar can reach 100%), and the results panel reports cancelled scans instead of claiming "Scan Complete!" - sidebar spinner resets on the scan_cancelled websocket event (same quiet handling as scan_error) - setup wizard shows "Cancelled" as a terminal status in its poller No new innerHTML assignment sites - rendering-ownership baseline unchanged.
656 lines
21 KiB
TypeScript
656 lines
21 KiB
TypeScript
import { Alpine } from "./alpine";
|
|
import { showToast } from "./toast";
|
|
|
|
async function scanAllLibraries(): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
|
|
try {
|
|
const libsResp = await fetch("/api/libraries", {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
|
|
if (!libsResp.ok) {
|
|
throw new Error("Failed to get libraries");
|
|
}
|
|
|
|
const libsData = await libsResp.json();
|
|
|
|
if (!libsData.data || libsData.data.length === 0) {
|
|
showToast("No libraries found. Please create a library first.", "error");
|
|
return;
|
|
}
|
|
|
|
const libraries = libsData.data;
|
|
|
|
const jobs: string[] = [];
|
|
const libraryNames: Record<string, string> = {};
|
|
|
|
for (const lib of libraries) {
|
|
const scanResp = await fetch(`/api/libraries/${lib.id}/scan`, {
|
|
method: "POST",
|
|
headers: {
|
|
Authorization: `Bearer ${token}`,
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: JSON.stringify({ force: true }),
|
|
});
|
|
|
|
if (scanResp.ok) {
|
|
const result = await scanResp.json();
|
|
jobs.push(result.job_id);
|
|
libraryNames[result.job_id] = lib.name;
|
|
} else {
|
|
console.error(`Failed to scan library: ${lib.name}`);
|
|
}
|
|
}
|
|
|
|
if (jobs.length === 0) {
|
|
showToast("Failed to start scan for any library", "error");
|
|
return;
|
|
}
|
|
|
|
showScanProgress(jobs, libraryNames);
|
|
} catch (error) {
|
|
console.error("Scan error:", error);
|
|
showToast("Failed to start scan: " + (error as Error).message, "error");
|
|
}
|
|
}
|
|
|
|
function showScanProgress(
|
|
jobIds: string[],
|
|
libraryNames: Record<string, string>,
|
|
): void {
|
|
const container = document.getElementById(
|
|
"scan-progress-container",
|
|
) as HTMLElement;
|
|
const list = document.getElementById("library-progress-list") as HTMLElement;
|
|
|
|
if (!container || !list) return;
|
|
|
|
container.classList.remove("hidden");
|
|
container.classList.remove("opacity-0", "-translate-y-2.5");
|
|
|
|
list.innerHTML = jobIds
|
|
.map(
|
|
(jobId) => `
|
|
<div id="progress-${jobId}" class="p-3 rounded border"
|
|
style="background-color: var(--bg-primary); border-color: var(--border);">
|
|
<div class="flex justify-between items-center mb-2">
|
|
<span class="font-medium" style="color: var(--text-primary)">
|
|
${libraryNames[jobId]}
|
|
</span>
|
|
<span class="flex items-center gap-2">
|
|
<span id="status-${jobId}" class="text-sm" style="color: var(--text-secondary)">
|
|
Pending...
|
|
</span>
|
|
<button data-cancel-job="${jobId}"
|
|
class="text-xs px-2 py-0.5 rounded border shrink-0"
|
|
style="color: var(--text-secondary); border-color: var(--border);"
|
|
title="Cancel this scan">Cancel</button>
|
|
</span>
|
|
</div>
|
|
<div class="w-full bg-gray-700 rounded-full h-2">
|
|
<div id="bar-${jobId}"
|
|
class="h-2 rounded-full transition-all duration-500"
|
|
style="width: 0%; background-color: var(--accent);">
|
|
</div>
|
|
</div>
|
|
</div>
|
|
`,
|
|
)
|
|
.join("");
|
|
|
|
// The rows are TS-rendered (sanctioned scan-progress island); bind the
|
|
// cancel buttons here since inline handlers can't reach module scope.
|
|
list.querySelectorAll<HTMLButtonElement>("[data-cancel-job]").forEach((btn) => {
|
|
btn.addEventListener("click", () => cancelScan(btn.dataset.cancelJob || ""));
|
|
});
|
|
|
|
setCancelAllVisible(true);
|
|
pollScanProgress(jobIds, libraryNames);
|
|
}
|
|
|
|
let scanPollInterval: ReturnType<typeof setInterval> | undefined = undefined;
|
|
|
|
function pollScanProgress(
|
|
jobIds: string[],
|
|
_libraryNames: Record<string, string>,
|
|
): void {
|
|
const token = localStorage.getItem("token");
|
|
const startTime = Date.now();
|
|
const cancelledJobs = new Set<string>();
|
|
|
|
scanPollInterval = setInterval(async () => {
|
|
let allComplete = true;
|
|
let totalProgress = 0;
|
|
let progressJobs = 0;
|
|
let totalFiles = 0;
|
|
let totalNewItems = 0;
|
|
let totalErrors = 0;
|
|
|
|
for (const jobId of jobIds) {
|
|
try {
|
|
const resp = await fetch(`/api/scanner/status/${jobId}`, {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
|
|
if (resp.ok) {
|
|
const status = await resp.json();
|
|
|
|
updateLibraryProgress(jobId, status);
|
|
|
|
totalFiles += status.files_scanned || 0;
|
|
totalNewItems += status.new_items || 0;
|
|
totalErrors += status.errors || 0;
|
|
|
|
// Cancelled jobs are terminal and keep their last real
|
|
// progress; average only jobs that can still advance so the
|
|
// bar can reach 100%.
|
|
if (status.status === "cancelled") {
|
|
cancelledJobs.add(jobId);
|
|
} else {
|
|
totalProgress += status.progress || 0;
|
|
progressJobs++;
|
|
}
|
|
|
|
if (
|
|
status.status !== "completed" &&
|
|
status.status !== "failed" &&
|
|
status.status !== "cancelled"
|
|
) {
|
|
allComplete = false;
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error(`Failed to poll job ${jobId}:`, error);
|
|
}
|
|
}
|
|
|
|
// status.progress arrives 0-1 from the server; render as percent.
|
|
const overallProgress =
|
|
progressJobs > 0 ? Math.round((totalProgress / progressJobs) * 100) : 0;
|
|
const progressBar = document.getElementById(
|
|
"scan-progress-bar",
|
|
) as HTMLElement;
|
|
const progressText = document.getElementById(
|
|
"scan-progress-text",
|
|
) as HTMLElement;
|
|
const statusText = document.getElementById("scan-status") as HTMLElement;
|
|
|
|
if (progressBar) progressBar.style.width = overallProgress + "%";
|
|
if (progressText) progressText.textContent = overallProgress + "%";
|
|
|
|
const elapsed = Math.round((Date.now() - startTime) / 1000);
|
|
if (!allComplete && statusText) {
|
|
statusText.textContent = `Scanning... ${elapsed}s elapsed • ${totalFiles} files processed`;
|
|
}
|
|
|
|
if (allComplete) {
|
|
clearInterval(scanPollInterval!);
|
|
setCancelAllVisible(false);
|
|
showScanResults(
|
|
jobIds.length,
|
|
totalFiles,
|
|
totalNewItems,
|
|
totalErrors,
|
|
elapsed,
|
|
cancelledJobs.size,
|
|
);
|
|
}
|
|
}, 2000);
|
|
}
|
|
|
|
function updateLibraryProgress(jobId: string, status: any): void {
|
|
const bar = document.getElementById(`bar-${jobId}`) as HTMLElement;
|
|
const statusText = document.getElementById(`status-${jobId}`) as HTMLElement;
|
|
|
|
// status.progress arrives 0-1 from the server; render as percent,
|
|
// otherwise the bar sits at sub-1% forever and never fills.
|
|
const percent = Math.round((status.progress || 0) * 100);
|
|
|
|
if (bar) {
|
|
bar.style.width = percent + "%";
|
|
}
|
|
|
|
if (statusText) {
|
|
const statusMessages: Record<string, string> = {
|
|
pending: "Pending...",
|
|
running: `Scanning... ${percent}%`,
|
|
completed: `✓ Complete (${status.new_items || 0} items)`,
|
|
failed: `✗ Failed`,
|
|
cancelled: `✗ Cancelled`,
|
|
};
|
|
statusText.textContent = statusMessages[status.status] || status.status;
|
|
}
|
|
|
|
// Terminal jobs no longer need their per-row cancel button.
|
|
if (
|
|
status.status === "completed" ||
|
|
status.status === "failed" ||
|
|
status.status === "cancelled"
|
|
) {
|
|
document.querySelector(`[data-cancel-job="${jobId}"]`)?.remove();
|
|
}
|
|
}
|
|
|
|
// Cancel one scan job (POST /api/scanner/cancel/:jobId). The server
|
|
// aborts the walk at its next context check and skips the archive pass,
|
|
// so cancelling never archives unvisited files.
|
|
async function cancelScan(jobId: string): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
|
|
const btn = document.querySelector<HTMLButtonElement>(
|
|
`[data-cancel-job="${jobId}"]`,
|
|
);
|
|
if (btn) {
|
|
btn.disabled = true;
|
|
btn.textContent = "Cancelling...";
|
|
}
|
|
|
|
try {
|
|
const resp = await fetch(`/api/scanner/cancel/${jobId}`, {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (!resp.ok) {
|
|
const err = await resp.json().catch(() => ({}));
|
|
throw new Error(err.error || "Failed to cancel scan");
|
|
}
|
|
showToast("Scan cancellation requested", "success");
|
|
} catch (e) {
|
|
showToast(
|
|
e instanceof Error ? e.message : "Failed to cancel scan",
|
|
"error",
|
|
);
|
|
if (btn) {
|
|
btn.disabled = false;
|
|
btn.textContent = "Cancel";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Cancel every active scan (admin): resolves the server's active job
|
|
// list so it also covers jobs this page never started (e.g. started
|
|
// before a refresh), then cancels each one.
|
|
async function cancelAllScans(): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
|
|
try {
|
|
const resp = await fetch("/api/scanner/active", {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (!resp.ok) {
|
|
throw new Error("Failed to list active scans");
|
|
}
|
|
const data = await resp.json();
|
|
const jobs = (data.jobs || []) as Array<{ job_id: string }>;
|
|
if (jobs.length === 0) return;
|
|
|
|
await Promise.allSettled(jobs.map((job) => cancelScan(job.job_id)));
|
|
} catch (e) {
|
|
showToast(
|
|
e instanceof Error ? e.message : "Failed to cancel scans",
|
|
"error",
|
|
);
|
|
}
|
|
}
|
|
|
|
function setCancelAllVisible(visible: boolean): void {
|
|
const btn = document.getElementById("scan-cancel-all-btn");
|
|
if (btn) btn.classList.toggle("hidden", !visible);
|
|
}
|
|
|
|
// On page load: if a scan is already running (started before this page
|
|
// was opened, or the page was refreshed mid-scan), surface the progress
|
|
// widget and re-attach polling. Websocket start-events only reach pages
|
|
// that were already open when the scan began.
|
|
async function checkActiveScans(): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
try {
|
|
const resp = await fetch("/api/scanner/active", {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (!resp.ok) return;
|
|
const data = await resp.json();
|
|
const jobs = (data.jobs || []) as Array<{
|
|
job_id: string;
|
|
library_id?: string;
|
|
}>;
|
|
if (jobs.length === 0) return;
|
|
|
|
// Label rows by library name where we can resolve one.
|
|
const libraryNames: Record<string, string> = {};
|
|
try {
|
|
const libsResp = await fetch("/api/libraries", {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (libsResp.ok) {
|
|
const libsData = await libsResp.json();
|
|
for (const lib of libsData.data || []) {
|
|
libraryNames[lib.id] = lib.name;
|
|
}
|
|
}
|
|
} catch {
|
|
// Names fall back to ids below.
|
|
}
|
|
|
|
const jobIds = jobs.map((job) => job.job_id);
|
|
const names: Record<string, string> = {};
|
|
for (const job of jobs) {
|
|
names[job.job_id] =
|
|
(job.library_id && libraryNames[job.library_id]) ||
|
|
`Library ${(job.library_id || job.job_id).slice(0, 8)}`;
|
|
}
|
|
showScanProgress(jobIds, names);
|
|
pollScanProgress(jobIds, names);
|
|
} catch (error) {
|
|
console.error("Failed to check for active scans:", error);
|
|
}
|
|
}
|
|
|
|
function showScanResults(
|
|
libCount: number,
|
|
files: number,
|
|
items: number,
|
|
errors: number,
|
|
elapsed: number,
|
|
cancelled: number,
|
|
): void {
|
|
const resultsDiv = document.getElementById("scan-results") as HTMLElement;
|
|
const contentDiv = document.getElementById(
|
|
"scan-results-content",
|
|
) as HTMLElement;
|
|
|
|
if (!resultsDiv || !contentDiv) return;
|
|
|
|
contentDiv.innerHTML = `
|
|
<p>• ${libCount} librar${libCount === 1 ? "y" : "ies"} scanned</p>
|
|
<p>• ${files} files processed</p>
|
|
<p>• ${items} new items added</p>
|
|
${cancelled > 0 ? `<p>• ${cancelled} scan${cancelled === 1 ? "" : "s"} cancelled</p>` : ""}
|
|
${errors > 0 ? `<p style="color: var(--accent);">• ${errors} errors</p>` : ""}
|
|
<p style="color: var(--text-secondary)">Completed in ${elapsed} seconds</p>
|
|
`;
|
|
|
|
resultsDiv.classList.remove("hidden");
|
|
|
|
const statusText = document.getElementById("scan-status") as HTMLElement;
|
|
if (statusText) {
|
|
statusText.textContent =
|
|
cancelled > 0
|
|
? "Scan finished (some scans were cancelled)"
|
|
: "Scan complete!";
|
|
}
|
|
}
|
|
|
|
function hideScanProgress(): void {
|
|
const container = document.getElementById(
|
|
"scan-progress-container",
|
|
) as HTMLElement;
|
|
if (container) container.classList.add("hidden");
|
|
setCancelAllVisible(false);
|
|
}
|
|
|
|
async function loadWatchStatus(): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
|
|
try {
|
|
const response = await fetch("/api/scanner/watch/status", {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (response.ok) {
|
|
const data = await response.json();
|
|
const countEl = document.getElementById("watch-count");
|
|
if (countEl) {
|
|
countEl.textContent = data.total_watching?.toString() || "0";
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error("Failed to load watch status:", error);
|
|
}
|
|
}
|
|
|
|
function stopScanStatusPolling(): void {
|
|
if (scanPollInterval !== undefined) {
|
|
clearInterval(scanPollInterval);
|
|
scanPollInterval = undefined;
|
|
}
|
|
}
|
|
|
|
// Purge all archived items (files missing from disk for 2+ scans). Exposed on
|
|
// window for the library admin page's inline button; reading history is
|
|
// deleted with the rows, so a confirm dialog guards it.
|
|
async function purgeArchivedItems(): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
|
|
if (
|
|
!window.confirm(
|
|
"Permanently delete all archived items? Their reading progress, notes, and highlights will be lost.",
|
|
)
|
|
) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const resp = await fetch("/api/media-items/purge-archived", {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (!resp.ok) {
|
|
const err = await resp.json().catch(() => ({}));
|
|
throw new Error(err.error || "Failed to purge archived items");
|
|
}
|
|
const data = await resp.json();
|
|
showToast(
|
|
`Purged ${data.purged} archived item${data.purged === 1 ? "" : "s"}`,
|
|
"success",
|
|
);
|
|
setTimeout(() => window.location.reload(), 700);
|
|
} catch (e) {
|
|
showToast(
|
|
e instanceof Error ? e.message : "Failed to purge archived items",
|
|
"error",
|
|
);
|
|
}
|
|
}
|
|
|
|
(window as any).purgeArchivedItems = purgeArchivedItems;
|
|
|
|
// Restore a hidden/archived item to library visibility without waiting for
|
|
// its file to return (POST /api/media-items/:id/unarchive). If the file is
|
|
// still gone the next scan hides it again.
|
|
async function unarchiveItem(id: string): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
try {
|
|
const resp = await fetch(`/api/media-items/${id}/unarchive`, {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (!resp.ok) {
|
|
const err = await resp.json().catch(() => ({}));
|
|
throw new Error(err.error || "Failed to restore item");
|
|
}
|
|
showToast("Item restored to libraries", "success");
|
|
setTimeout(() => window.location.reload(), 500);
|
|
} catch (e) {
|
|
showToast(e instanceof Error ? e.message : "Failed to restore item", "error");
|
|
}
|
|
}
|
|
|
|
// Permanently delete one archived item and its reading history
|
|
// (DELETE /api/media-items/:id).
|
|
async function deleteArchivedItem(id: string): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
if (
|
|
!window.confirm(
|
|
"Permanently delete this item? Its reading progress, notes, and highlights will be lost.",
|
|
)
|
|
) {
|
|
return;
|
|
}
|
|
try {
|
|
const resp = await fetch(`/api/media-items/${id}`, {
|
|
method: "DELETE",
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (!resp.ok) {
|
|
const err = await resp.json().catch(() => ({}));
|
|
throw new Error(err.error || "Failed to delete item");
|
|
}
|
|
showToast("Item deleted", "success");
|
|
setTimeout(() => window.location.reload(), 500);
|
|
} catch (e) {
|
|
showToast(e instanceof Error ? e.message : "Failed to delete item", "error");
|
|
}
|
|
}
|
|
|
|
// Merge an archived item's reading data into its active duplicate with the
|
|
// same content hash (POST /api/media-items/:id/merge), then remove the
|
|
// archived entry. Covers copy-then-delete-later moves between libraries.
|
|
async function mergeArchivedItem(sourceId: string, targetId: string): Promise<void> {
|
|
const token = localStorage.getItem("token");
|
|
if (!token) return;
|
|
if (
|
|
!window.confirm(
|
|
"Merge this archived copy's reading progress, notes, and highlights into the active copy? The archived entry is removed.",
|
|
)
|
|
) {
|
|
return;
|
|
}
|
|
try {
|
|
const resp = await fetch(`/api/media-items/${sourceId}/merge`, {
|
|
method: "POST",
|
|
headers: {
|
|
Authorization: `Bearer ${token}`,
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: JSON.stringify({ target_id: targetId }),
|
|
});
|
|
if (!resp.ok) {
|
|
const err = await resp.json().catch(() => ({}));
|
|
throw new Error(err.error || "Failed to merge item");
|
|
}
|
|
showToast("Reading data merged into active copy", "success");
|
|
setTimeout(() => window.location.reload(), 500);
|
|
} catch (e) {
|
|
showToast(e instanceof Error ? e.message : "Failed to merge item", "error");
|
|
}
|
|
}
|
|
|
|
// The archived-items page renders per-row buttons with data attributes
|
|
// (escaping-safe); bind them here. Module scripts run after DOM parse.
|
|
document.querySelectorAll<HTMLElement>("[data-unarchive]").forEach((el) => {
|
|
el.addEventListener("click", () => unarchiveItem(el.dataset.unarchive || ""));
|
|
});
|
|
document.querySelectorAll<HTMLElement>("[data-delete-archived]").forEach((el) => {
|
|
el.addEventListener("click", () =>
|
|
deleteArchivedItem(el.dataset.deleteArchived || ""),
|
|
);
|
|
});
|
|
document.querySelectorAll<HTMLElement>("[data-merge-source]").forEach((el) => {
|
|
el.addEventListener("click", () =>
|
|
mergeArchivedItem(el.dataset.mergeSource || "", el.dataset.mergeTarget || ""),
|
|
);
|
|
});
|
|
|
|
export {
|
|
checkActiveScans,
|
|
hideScanProgress,
|
|
loadWatchStatus,
|
|
scanAllLibraries,
|
|
stopScanStatusPolling,
|
|
};
|
|
|
|
// Library admin page helpers (rendering-ownership: these orchestrate htmx
|
|
// swaps and modal visibility on server-rendered DOM; they render nothing).
|
|
function toggleLibraryPanel(btn: HTMLElement): void {
|
|
const libId = btn.dataset.libId || "";
|
|
const panel = document.getElementById(`library-panel-${libId}`);
|
|
if (!panel) return;
|
|
if (panel.innerHTML.trim() !== "") {
|
|
panel.innerHTML = "";
|
|
} else {
|
|
window.htmx.ajax("GET", `/admin/library/${libId}/panel`, {
|
|
target: `#library-panel-${libId}`,
|
|
swap: "innerHTML",
|
|
});
|
|
}
|
|
}
|
|
|
|
function openEditModal(id: string, name: string, description: string): void {
|
|
const form = document.getElementById("edit-library-form");
|
|
if (!form) return;
|
|
form.setAttribute("hx-put", `/admin/library/${id}`);
|
|
const nameInput = document.getElementById("edit-library-name");
|
|
if (nameInput) (nameInput as HTMLInputElement).value = name;
|
|
const descInput = document.getElementById("edit-library-desc");
|
|
if (descInput) (descInput as HTMLInputElement).value = description;
|
|
window.htmx.process(form);
|
|
document.getElementById("edit-library-modal")?.classList.remove("hidden");
|
|
}
|
|
|
|
function openDeleteModal(id: string, name: string): void {
|
|
const btn = document.getElementById("delete-library-confirm");
|
|
if (!btn) return;
|
|
btn.setAttribute("hx-delete", `/admin/library/${id}`);
|
|
btn.setAttribute("hx-target", "#libraries-container");
|
|
btn.setAttribute("hx-swap", "innerHTML");
|
|
const nameEl = document.getElementById("delete-library-name");
|
|
if (nameEl) nameEl.textContent = name;
|
|
window.htmx.process(btn);
|
|
document.getElementById("delete-library-modal")?.classList.remove("hidden");
|
|
}
|
|
|
|
function openFolderBrowser(targetInputId: string, libraryId: string): void {
|
|
const content = document.getElementById("folder-browser-content");
|
|
if (!content) return;
|
|
content.setAttribute("hx-get", "/admin/library/browse");
|
|
content.setAttribute(
|
|
"hx-vals",
|
|
JSON.stringify({ target_input: targetInputId, library_id: libraryId }),
|
|
);
|
|
content.setAttribute("hx-trigger", "load");
|
|
window.htmx.process(content);
|
|
document.getElementById("folder-browser-modal")?.classList.remove("hidden");
|
|
}
|
|
|
|
// Close the delete-library modal after a successful delete: the htmx swap
|
|
// already removes the deleted row from the libraries list, but the modal
|
|
// lives outside the swapped container and would otherwise stay open.
|
|
function bindDeleteLibraryModalClose(): void {
|
|
document
|
|
.getElementById("delete-library-confirm")
|
|
?.addEventListener("htmx:afterRequest", function (evt) {
|
|
const detail = (evt as CustomEvent).detail as { successful?: boolean };
|
|
if (detail.successful) {
|
|
document
|
|
.getElementById("delete-library-modal")
|
|
?.classList.add("hidden");
|
|
}
|
|
});
|
|
}
|
|
|
|
Alpine.data("admin", () => ({
|
|
init() {
|
|
bindDeleteLibraryModalClose();
|
|
},
|
|
cancelAllScans,
|
|
checkActiveScans,
|
|
hideScanProgress,
|
|
loadWatchStatus,
|
|
scanAllLibraries,
|
|
stopScanStatusPolling,
|
|
openDeleteModal,
|
|
openEditModal,
|
|
openFolderBrowser,
|
|
toggleLibraryPanel,
|
|
}));
|