(() => { const connection = navigator.connection || {} const previewConcurrency = connection.saveData || /(^|-)2g$/.test(connection.effectiveType || "") ? 1 : 2 const previewQueue = [] const previewControllers = new Set() let activePreviews = 0 let previewsStopped = false const scheduleIdle = callback => { if ("requestIdleCallback" in window) { window.requestIdleCallback(callback, { timeout: 1200 }) } else { window.setTimeout(callback, 32) } } const runPreviewQueue = () => { if ( previewsStopped || document.visibilityState === "hidden" || activePreviews >= previewConcurrency || !previewQueue.length ) return const task = previewQueue.shift() activePreviews++ scheduleIdle(async () => { try { if (!previewsStopped) await task() } finally { activePreviews-- runPreviewQueue() } }) if (activePreviews < previewConcurrency) runPreviewQueue() } const enqueuePreview = task => { if (previewsStopped) return previewQueue.push(task) runPreviewQueue() } const renderExcalidrawThumbnail = async canvas => { const controller = new AbortController() previewControllers.add(controller) try { const response = await fetch(canvas.dataset.previewSrc, { credentials: "same-origin", cache: "force-cache", signal: controller.signal, headers: { "X-PagesWiki-Priority": "background" } }) if (!response.ok) return const scene = await response.json() const elements = (scene.elements || []).filter(element => !element.isDeleted) if (!elements.length) return const width = canvas.clientWidth || 160 const height = canvas.clientHeight || 112 const ratio = window.devicePixelRatio || 1 canvas.width = Math.round(width * ratio) canvas.height = Math.round(height * ratio) const context = canvas.getContext("2d") context.scale(ratio, ratio) const minX = Math.min(...elements.map(element => element.x || 0)) const minY = Math.min(...elements.map(element => element.y || 0)) const maxX = Math.max(...elements.map(element => (element.x || 0) + Math.abs(element.width || 1))) const maxY = Math.max(...elements.map(element => (element.y || 0) + Math.abs(element.height || 1))) const scale = Math.min((width - 12) / Math.max(1, maxX - minX), (height - 12) / Math.max(1, maxY - minY)) context.translate(6 - minX * scale, 6 - minY * scale) context.scale(scale, scale) context.lineWidth = 1.5 / Math.max(scale, .1) elements.slice(0, 500).forEach(element => { const x = element.x || 0 const y = element.y || 0 const w = element.width || 0 const h = element.height || 0 context.strokeStyle = element.strokeColor || "#555" context.fillStyle = element.backgroundColor && element.backgroundColor !== "transparent" ? element.backgroundColor : "transparent" context.beginPath() if (element.type === "ellipse") { context.ellipse(x + w / 2, y + h / 2, Math.abs(w / 2), Math.abs(h / 2), 0, 0, Math.PI * 2) } else if (element.type === "line" || element.type === "arrow") { const points = element.points || [[0, 0], [w, h]] points.forEach((point, index) => { if (index) context.lineTo(x + point[0], y + point[1]) else context.moveTo(x + point[0], y + point[1]) }) } else if (element.type === "text") { context.font = `${element.fontSize || 20}px sans-serif` context.fillStyle = element.strokeColor || "#555" context.fillText((element.text || "").slice(0, 80), x, y + (element.fontSize || 20)) return } else { context.rect(x, y, w, h) } if (context.fillStyle !== "transparent") context.fill() context.stroke() }) canvas.closest(".children-preview") ?.classList.replace("children-preview-pending", "children-preview-ready") } catch (_) { // The format icon and EX badge remain as the safe fallback. } finally { previewControllers.delete(controller) } } const initializeExcalidrawViewer = viewer => { if (viewer.dataset.excalidrawInitialized) return viewer.dataset.excalidrawInitialized = "true" const canvas = viewer.querySelector("[data-excalidraw-canvas]") const source = viewer.querySelector("[data-excalidraw-source]") if (!canvas || !source) return let scene try { scene = JSON.parse(source.value) } catch (_) { return } const elements = (scene.elements || []).filter(element => !element.isDeleted && Number.isFinite(element.x) && Number.isFinite(element.y) ) const context = canvas.getContext("2d") if (!context) return const camera = { x: 0, y: 0, scale: 1 } let dragging = false let previousX = 0 let previousY = 0 const elementBounds = element => { const points = Array.isArray(element.points) ? element.points : [] const width = Math.abs(Number(element.width) || 0) const height = Math.abs(Number(element.height) || 0) let minPointX = 0 let minPointY = 0 let maxPointX = width let maxPointY = height points.forEach(point => { const x = Number(point?.[0]) || 0 const y = Number(point?.[1]) || 0 minPointX = Math.min(minPointX, x) minPointY = Math.min(minPointY, y) maxPointX = Math.max(maxPointX, x) maxPointY = Math.max(maxPointY, y) }) return { minX: (Number(element.x) || 0) + minPointX, minY: (Number(element.y) || 0) + minPointY, maxX: (Number(element.x) || 0) + maxPointX, maxY: (Number(element.y) || 0) + maxPointY } } const bounds = () => { if (!elements.length) return { minX: 0, minY: 0, maxX: 1, maxY: 1 } const boxes = elements.map(elementBounds) return { minX: Math.min(...boxes.map(box => box.minX)), minY: Math.min(...boxes.map(box => box.minY)), maxX: Math.max(...boxes.map(box => box.maxX)), maxY: Math.max(...boxes.map(box => box.maxY)) } } const drawElement = element => { const x = Number(element.x) || 0 const y = Number(element.y) || 0 const width = Number(element.width) || 0 const height = Number(element.height) || 0 const stroke = element.strokeColor || "#1b1b1f" const fill = element.backgroundColor || "transparent" context.save() context.globalAlpha = Math.max(0, Math.min(1, Number(element.opacity ?? 100) / 100)) context.strokeStyle = stroke context.fillStyle = fill context.lineWidth = Math.max(1, Number(element.strokeWidth) || 1) / camera.scale context.lineCap = "round" context.lineJoin = "round" context.beginPath() if (element.type === "text") { const size = Math.max(4, Number(element.fontSize) || 20) context.fillStyle = stroke context.font = `${size}px sans-serif` context.textBaseline = "top" String(element.text || "").split("\n").slice(0, 200).forEach((line, index) => { context.fillText(line, x, y + index * (Number(element.lineHeight) || 1.25) * size) }) context.restore() return } if (element.type === "ellipse") { context.ellipse(x + width / 2, y + height / 2, Math.abs(width / 2), Math.abs(height / 2), 0, 0, Math.PI * 2) } else if (element.type === "diamond") { context.moveTo(x + width / 2, y) context.lineTo(x + width, y + height / 2) context.lineTo(x + width / 2, y + height) context.lineTo(x, y + height / 2) context.closePath() } else if (["line", "arrow", "freedraw"].includes(element.type)) { const points = Array.isArray(element.points) ? element.points : [[0, 0], [width, height]] points.forEach((point, index) => { const px = x + (Number(point?.[0]) || 0) const py = y + (Number(point?.[1]) || 0) if (index) context.lineTo(px, py) else context.moveTo(px, py) }) } else { context.rect(x, y, width, height) } if (fill !== "transparent" && !["line", "arrow", "freedraw"].includes(element.type)) context.fill() context.stroke() context.restore() } const render = () => { const ratio = window.devicePixelRatio || 1 const width = Math.max(1, canvas.clientWidth) const height = Math.max(1, canvas.clientHeight) const pixelWidth = Math.round(width * ratio) const pixelHeight = Math.round(height * ratio) if (canvas.width !== pixelWidth || canvas.height !== pixelHeight) { canvas.width = pixelWidth canvas.height = pixelHeight } context.setTransform(ratio, 0, 0, ratio, 0, 0) context.clearRect(0, 0, width, height) context.fillStyle = scene.appState?.viewBackgroundColor || "#ffffff" context.fillRect(0, 0, width, height) context.translate(camera.x, camera.y) context.scale(camera.scale, camera.scale) elements.forEach(drawElement) } const fit = () => { const box = bounds() const width = Math.max(1, canvas.clientWidth) const height = Math.max(1, canvas.clientHeight) const sceneWidth = Math.max(1, box.maxX - box.minX) const sceneHeight = Math.max(1, box.maxY - box.minY) camera.scale = Math.max(.02, Math.min(20, Math.min((width - 48) / sceneWidth, (height - 48) / sceneHeight))) camera.x = (width - sceneWidth * camera.scale) / 2 - box.minX * camera.scale camera.y = (height - sceneHeight * camera.scale) / 2 - box.minY * camera.scale render() } canvas.addEventListener("pointerdown", event => { dragging = true previousX = event.clientX previousY = event.clientY canvas.setPointerCapture(event.pointerId) }) canvas.addEventListener("pointermove", event => { if (!dragging) return camera.x += event.clientX - previousX camera.y += event.clientY - previousY previousX = event.clientX previousY = event.clientY render() }) canvas.addEventListener("pointerup", () => { dragging = false }) canvas.addEventListener("pointercancel", () => { dragging = false }) canvas.addEventListener("wheel", event => { event.preventDefault() const rect = canvas.getBoundingClientRect() const x = event.clientX - rect.left const y = event.clientY - rect.top const next = Math.max(.02, Math.min(20, camera.scale * Math.exp(-event.deltaY * .0015))) camera.x = x - (x - camera.x) * next / camera.scale camera.y = y - (y - camera.y) * next / camera.scale camera.scale = next render() }, { passive: false }) viewer.querySelector("[data-excalidraw-fit]")?.addEventListener("click", fit) new ResizeObserver(render).observe(canvas) requestAnimationFrame(fit) } const activatePreview = async element => { if (element.dataset.previewLoaded) return element.dataset.previewLoaded = "true" const kind = element.dataset.previewKind if (kind === "excalidraw") { await renderExcalidrawThumbnail(element) return } await new Promise(resolve => { const eventName = kind === "video" ? "loadeddata" : "load" const done = () => { window.clearTimeout(timeout) element.closest(".children-preview") ?.classList.replace("children-preview-pending", "children-preview-ready") resolve() } const timeout = window.setTimeout(resolve, 30000) element.addEventListener(eventName, done, { once: true }) element.addEventListener("error", () => { window.clearTimeout(timeout) resolve() }, { once: true }) if (kind === "image") element.fetchPriority = "low" element.src = element.dataset.previewSrc if (kind === "video") element.load() }) } const previewObserver = new IntersectionObserver(entries => { entries.forEach(entry => { if (!entry.isIntersecting) return previewObserver.unobserve(entry.target) // Allow the icon grid and labels to paint before media I/O starts. requestAnimationFrame(() => requestAnimationFrame(() => { enqueuePreview(() => activatePreview(entry.target)) })) }) }, { rootMargin: "250px 0px" }) const pollPreviewCache = async placeholder => { if (previewsStopped || !placeholder.isConnected) return const controller = new AbortController() previewControllers.add(controller) try { const response = await fetch(placeholder.dataset.previewCache, { method: "HEAD", cache: "no-store", credentials: "same-origin", signal: controller.signal, headers: { "X-PagesWiki-Priority": "background" } }) if (response.ok) { const image = document.createElement("img") image.alt = "" image.dataset.previewKind = "image" image.dataset.previewSrc = placeholder.dataset.previewCache const badge = placeholder.dataset.previewBadge placeholder.replaceChildren(image) if (badge) { const label = document.createElement("span") label.className = "children-preview-badge" label.textContent = badge placeholder.append(label) } placeholder.classList.remove("children-preview-placeholder") delete placeholder.dataset.previewCache previewObserver.observe(image) return } } catch (_) { if (previewsStopped) return } finally { previewControllers.delete(controller) } const attempts = Number.parseInt(placeholder.dataset.previewAttempts || "0", 10) + 1 placeholder.dataset.previewAttempts = String(attempts) if (attempts < 24) { window.setTimeout(() => enqueuePreview( () => pollPreviewCache(placeholder) ), Math.min(15000, 2500 + attempts * 500)) } } const cacheObserver = new IntersectionObserver(entries => { entries.forEach(entry => { if (!entry.isIntersecting) return cacheObserver.unobserve(entry.target) enqueuePreview(() => pollPreviewCache(entry.target)) }) }, { rootMargin: "250px 0px" }) document.addEventListener("visibilitychange", () => { if (document.visibilityState === "visible") runPreviewQueue() }) window.addEventListener("pagehide", () => { previewsStopped = true previewQueue.length = 0 previewControllers.forEach(controller => controller.abort()) document.querySelectorAll("[data-preview-loaded]").forEach(element => { if ("pause" in element) element.pause() element.removeAttribute("src") }) }, { once: true }) const fetchNextChildren = async sentinel => { if (sentinel.dataset.childrenFetching) return sentinel.dataset.childrenFetching = "true" try { const response = await fetch(sentinel.dataset.childrenNext, { credentials: "same-origin", headers: { "X-Requested-With": "PagesWikiChildren" } }) if (!response.ok) throw new Error(`HTTP ${response.status}`) const range = document.createRange() const fragment = range.createContextualFragment(await response.text()) initializeChildren(fragment) sentinel.replaceWith(fragment) } catch (error) { sentinel.dataset.childrenFetching = "" sentinel.setAttribute("aria-label", error.message) } } const nextObserver = new IntersectionObserver(entries => { entries.forEach(entry => { if (!entry.isIntersecting) return nextObserver.unobserve(entry.target) fetchNextChildren(entry.target) }) }, { rootMargin: "800px 0px" }) const initializeChildren = root => { const previews = [] const sentinels = [] const pendingCaches = [] if (root.matches?.("[data-preview-src]")) previews.push(root) if (root.matches?.("[data-children-next]")) sentinels.push(root) if (root.matches?.("[data-preview-cache]")) pendingCaches.push(root) root.querySelectorAll?.("[data-preview-src]").forEach(item => previews.push(item)) root.querySelectorAll?.("[data-children-next]").forEach(item => sentinels.push(item)) root.querySelectorAll?.("[data-preview-cache]").forEach(item => pendingCaches.push(item)) previews.forEach(preview => previewObserver.observe(preview)) sentinels.forEach(sentinel => nextObserver.observe(sentinel)) pendingCaches.forEach(item => cacheObserver.observe(item)) } const childrenModeKey = "pageswiki.children.view" const validChildrenMode = mode => mode === "icon" || mode === "detail" || mode === "list" const currentChildrenMode = () => { const saved = localStorage.getItem(childrenModeKey) return validChildrenMode(saved) ? saved : "list" } const childrenSource = (container, mode, offset = 0) => { const query = new URLSearchParams() query.set("path", container.dataset.childrenPath || location.pathname) query.set("view", mode) if (container.dataset.childrenExclude) { query.set("exclude", container.dataset.childrenExclude) } if (offset) query.set("offset", String(offset)) return `/v/children?${query}` } const updateChildrenSwitcher = mode => { const switcher = document.querySelector("[data-children-view-switcher]") if (!switcher) return switcher.hidden = !document.querySelector( "[data-children-src], [data-search-view]" ) switcher.querySelectorAll("[data-children-view]").forEach(button => { const active = button.dataset.childrenView === mode button.classList.toggle("active", active) button.setAttribute("aria-pressed", String(active)) }) } const loadChildren = root => { const containers = [] if (root.matches?.("[data-children-src]")) containers.push(root) root.querySelectorAll?.("[data-children-src]").forEach(item => containers.push(item)) containers.forEach(async container => { if (container.dataset.childrenLoading) return container.dataset.childrenLoading = "true" const mode = currentChildrenMode() container.dataset.childrenSrc = childrenSource(container, mode) updateChildrenSwitcher(mode) try { const response = await fetch(container.dataset.childrenSrc, { credentials: "same-origin", headers: { "X-Requested-With": "PagesWikiChildren" } }) if (!response.ok) throw new Error(`HTTP ${response.status}`) container.innerHTML = await response.text() initializeChildren(container) } catch (error) { container.innerHTML = `

${error.message}

` } finally { delete container.dataset.childrenLoading } }) } // Dynamic projections such as the Editor preview must be able to start // loading immediately instead of depending only on MutationObserver timing. window.PagesWikiLoadChildren = loadChildren document.addEventListener("click", event => { const viewButton = event.target.closest("[data-children-view]") if (viewButton) { const mode = viewButton.dataset.childrenView if (!validChildrenMode(mode)) return localStorage.setItem(childrenModeKey, mode) document.querySelectorAll("[data-search-view]").forEach(results => { results.dataset.searchView = mode }) document.querySelectorAll("[data-children-src]").forEach(container => { container.innerHTML = `
Loading…
` container.dataset.childrenSrc = childrenSource(container, mode) }) updateChildrenSwitcher(mode) loadChildren(document) return } const entry = event.target.closest(".children-entry") if (entry && (event.ctrlKey || event.metaKey)) { event.preventDefault() entry.classList.toggle("children-selected") return } const menu = document.querySelector("[data-children-context-menu]") if (menu && !event.target.closest("[data-children-context-menu]")) { menu.hidden = true } }) document.addEventListener("contextmenu", event => { const entry = event.target.closest(".children-entry") if (!entry) return event.preventDefault() if (!entry.classList.contains("children-selected")) { document.querySelectorAll(".children-entry.children-selected") .forEach(item => item.classList.remove("children-selected")) entry.classList.add("children-selected") } const menu = document.querySelector("[data-children-context-menu]") if (!menu) return menu.hidden = false menu.dataset.activePath = entry.dataset.childPath || "" refreshAdapterActions(menu, menu.dataset.activePath) const width = menu.offsetWidth const height = menu.offsetHeight menu.style.left = `${Math.min(event.clientX, innerWidth - width - 8)}px` menu.style.top = `${Math.min(event.clientY, innerHeight - height - 8)}px` }) const selectedChildrenPaths = () => { const paths = Array.from(new Set(Array.from( document.querySelectorAll(".children-entry.children-selected") ).map(item => item.dataset.childPath).filter(Boolean))).sort( (left, right) => left.length - right.length || left.localeCompare(right) ) // Moving or deleting a selected directory already includes descendants. return paths.filter((path, index) => !paths.slice(0, index).some( parent => path.startsWith(`${parent}/`) )) } const postJSON = async (url, body) => { const response = await fetch(url, { method: "POST", credentials: "same-origin", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }) if (!response.ok) throw new Error((await response.text()).trim() || `HTTP ${response.status}`) } const pathBasename = path => path.replace(/\/+$/, "").split("/").pop() const pathDirname = path => { const clean = path.replace(/\/+$/, "") return clean.slice(0, clean.lastIndexOf("/")) || "/" } const copyBasename = name => { const dot = name.lastIndexOf(".") return dot > 0 ? `${name.slice(0, dot)} (copy)${name.slice(dot)}` : `${name} (copy)` } const joinSemanticPath = (directory, name) => `${directory === "/" ? "" : directory}/${name}`.replace(/\/+/g, "/") const refreshAdapterActions = async (menu, path) => { const target = menu.querySelector("[data-adapter-actions]") const group = menu.querySelector("[data-adapter-group]") if (!target || !group) return target.replaceChildren() group.hidden = true if (!path || selectedChildrenPaths().length !== 1) return try { const response = await fetch( `/_/api/v1/adapter?path=${encodeURIComponent(path)}`, {credentials: "same-origin", cache: "no-store"} ) if (!response.ok) return const data = await response.json() for (const action of data.actions || []) { const link = document.createElement("a") link.href = action.open_url link.textContent = action.default ? `★ ${action.name}` : action.name link.dataset.adapterMode = action.mode if (action.new_tab) { link.target = "_blank" link.rel = "noopener" } if (action.mode === "native") link.rel = "external" target.append(link) } group.hidden = !target.children.length } catch (_) { group.hidden = true } } document.querySelector("[data-children-open]")?.addEventListener("click", () => { const paths = selectedChildrenPaths() if (paths.length === 1) location.href = paths[0] }) document.querySelector("[data-children-rename]")?.addEventListener("click", async () => { const menu = document.querySelector("[data-children-context-menu]") const paths = selectedChildrenPaths() if (paths.length !== 1) return const oldPath = paths[0] const newPath = prompt(menu.dataset.renamePrompt || "New path", oldPath) if (!newPath || newPath === oldPath) return try { await postJSON("/_/api/v1/path/rename", { old_path: oldPath, new_path: newPath, recursive: true }) location.reload() } catch (error) { alert(`${menu.dataset.operationFailed || "Operation failed"}: ${error.message}`) } }) document.querySelector("[data-children-copy]")?.addEventListener("click", () => { const paths = selectedChildrenPaths() if (!paths.length) return localStorage.setItem("pageswiki.fileClipboard", JSON.stringify({ operation: "copy", paths, created_at: Date.now() })) }) document.querySelector("[data-children-paste]")?.addEventListener("click", async () => { const menu = document.querySelector("[data-children-context-menu]") let clipboard try { clipboard = JSON.parse(localStorage.getItem("pageswiki.fileClipboard") || "null") } catch (_) { clipboard = null } if (!clipboard?.paths?.length) return const directory = menu.dataset.activePath ? pathDirname(menu.dataset.activePath) : (menu.dataset.contextPath || "/") menu.hidden = true try { for (const sourcePath of clipboard.paths) { const basename = pathBasename(sourcePath) const destinationName = pathDirname(sourcePath) === directory ? copyBasename(basename) : basename await postJSON("/_/api/v1/path/copy", { source_path: sourcePath, destination_path: joinSemanticPath(directory, destinationName), recursive: true }) } location.reload() } catch (error) { alert(`${menu.dataset.operationFailed || "Operation failed"}: ${error.message}`) } }) document.querySelector("[data-children-move]")?.addEventListener("click", async () => { const menu = document.querySelector("[data-children-context-menu]") const paths = selectedChildrenPaths() if (!paths.length) return const target = prompt(menu.dataset.movePrompt || "Destination directory", "/") if (!target) return const directory = `/${target}`.replace(/\/+/g, "/").replace(/\/$/, "") || "/" const names = paths.map(path => path.slice(path.lastIndexOf("/") + 1)) if (new Set(names).size !== names.length) { alert(`${menu.dataset.operationFailed || "Operation failed"}: duplicate destination name`) return } menu.hidden = true try { for (const oldPath of paths) { const basename = oldPath.slice(oldPath.lastIndexOf("/") + 1) const newPath = directory === "/" ? `/${basename}` : `${directory}/${basename}` await postJSON("/_/api/v1/path/rename", { old_path: oldPath, new_path: newPath, recursive: true }) } location.reload() } catch (error) { alert(`${menu.dataset.operationFailed || "Operation failed"}: ${error.message}`) } }) document.querySelector("[data-children-delete]")?.addEventListener("click", async () => { const menu = document.querySelector("[data-children-context-menu]") const paths = selectedChildrenPaths() if (!paths.length) return if (!confirm(menu.dataset.deleteConfirm || "Delete selected paths?")) return menu.hidden = true try { await postJSON("/_/api/v1/path/remove", { paths, recursive: true }) location.reload() } catch (error) { alert(`${menu.dataset.operationFailed || "Operation failed"}: ${error.message}`) } }) // Server-rendered listings (for example /v/browser) already contain // preview nodes, so register them before handling async children macros. initializeChildren(document) loadChildren(document) document.querySelectorAll("[data-search-view]").forEach(results => { results.dataset.searchView = currentChildrenMode() }) updateChildrenSwitcher(currentChildrenMode()) new MutationObserver(records => { records.forEach(record => { record.addedNodes.forEach(node => { if (node.nodeType === Node.ELEMENT_NODE) loadChildren(node) }) }) }).observe(document.documentElement, { childList: true, subtree: true }) const formatTime = value => { if (!Number.isFinite(value)) return "0:00" const seconds = Math.max(0, Math.floor(value)) const hours = Math.floor(seconds / 3600) const minutes = Math.floor((seconds % 3600) / 60) const rest = String(seconds % 60).padStart(2, "0") return hours ? `${hours}:${String(minutes).padStart(2, "0")}:${rest}` : `${minutes}:${rest}` } document.querySelectorAll("[data-lightbox-open]").forEach(trigger => { const dialog = trigger.nextElementSibling if (!dialog || !dialog.matches("[data-lightbox]")) return trigger.addEventListener("click", () => dialog.showModal()) dialog.querySelector("[data-lightbox-close]") ?.addEventListener("click", () => dialog.close()) dialog.addEventListener("click", event => { if (event.target === dialog) dialog.close() }) }) document.querySelectorAll("[data-media-player]").forEach(player => { const media = player.querySelector("audio, video") const rate = player.querySelector("[data-playback-rate]") const time = player.querySelector("[data-media-time]") if (!media) return const updateTime = () => { if (time) { time.textContent = `${formatTime(media.currentTime)} / ${formatTime(media.duration)}` } } media.addEventListener("loadedmetadata", updateTime) media.addEventListener("timeupdate", updateTime) rate?.addEventListener("change", () => { media.playbackRate = Number.parseFloat(rate.value) || 1 }) player.querySelector("[data-media-fullscreen]") ?.addEventListener("click", () => { if (document.fullscreenElement) { document.exitFullscreen() } else { player.requestFullscreen() } }) const pip = player.querySelector("[data-media-pip]") if (!document.pictureInPictureEnabled || !media.requestPictureInPicture) { pip?.remove() } else { pip?.addEventListener("click", async () => { if (document.pictureInPictureElement) { await document.exitPictureInPicture() } else { await media.requestPictureInPicture() } }) } }) const pluginFrames = Array.from(document.querySelectorAll("[data-excalidraw-plugin]")) const activateExcalidrawFallback = frame => { if (frame.dataset.excalidrawFallbackActive) return frame.dataset.excalidrawFallbackActive = "true" frame.hidden = true const fallback = frame.closest("[data-excalidraw-plugin-host]") ?.querySelector("[data-excalidraw-fallback]") if (!fallback) return fallback.hidden = false initializeExcalidrawViewer(fallback) } pluginFrames.forEach(frame => { const timeout = window.setTimeout(() => activateExcalidrawFallback(frame), 15000) frame.addEventListener("error", () => activateExcalidrawFallback(frame), { once: true }) const receive = event => { if (event.origin !== window.location.origin || event.source !== frame.contentWindow || event.data?.source !== "pageswiki-excalidraw") return if (event.data.type === "ready") { window.clearTimeout(timeout) } else if (event.data.type === "error") { window.clearTimeout(timeout) activateExcalidrawFallback(frame) } } window.addEventListener("message", receive) window.addEventListener("pagehide", () => { window.clearTimeout(timeout) window.removeEventListener("message", receive) }, { once: true }) }) document.querySelectorAll("[data-excalidraw-viewer]:not([data-excalidraw-fallback])") .forEach(initializeExcalidrawViewer) const initializeComicViewer = viewer => { if (viewer.dataset.comicInitialized) return const pages = Array.from(viewer.querySelectorAll("[data-comic-page]")) if (!pages.length) return viewer.dataset.comicInitialized = "true" const status = viewer.querySelector("[data-comic-status]") const layoutButton = viewer.querySelector("[data-comic-layout]") let index = 0 let spread = false const render = () => { const count = spread ? 2 : 1 index = Math.max(0, Math.min(index, Math.max(0, pages.length - 1))) pages.forEach((page, pageIndex) => { const visible = pageIndex >= index && pageIndex < index + count page.hidden = !visible if (visible && !page.src) page.src = page.dataset.src }) viewer.dataset.layout = spread ? "spread" : "single" if (status) { const end = Math.min(pages.length, index + count) status.textContent = pages.length ? `${index + 1}–${end} / ${pages.length}` : "0 / 0" } } const move = direction => { index += direction * (spread ? 2 : 1) render() } viewer.querySelector("[data-comic-prev]") ?.addEventListener("click", () => move(-1)) viewer.querySelector("[data-comic-next]") ?.addEventListener("click", () => move(1)) layoutButton?.addEventListener("click", () => { spread = !spread layoutButton.textContent = spread ? viewer.dataset.singleLabel || "Single page" : viewer.dataset.spreadLabel || "Two-page spread" render() }) viewer.querySelector("[data-comic-fit]")?.addEventListener("click", async () => { if (document.fullscreenElement === viewer) { await document.exitFullscreen() } else { await viewer.requestFullscreen() } }) document.addEventListener("keydown", event => { if (!viewer.isConnected || event.altKey || event.ctrlKey || event.metaKey) return if (event.key === "ArrowLeft") { event.preventDefault() move(-1) } else if (event.key === "ArrowRight") { event.preventDefault() move(1) } }) render() } document.querySelectorAll("[data-comic-viewer]").forEach(initializeComicViewer) // These are small, authorization-checked metadata reads. Decoders run only // in the durable scheduler; polling pauses in hidden tabs and has a budget. const watchMetadata = (element, ready) => { const endpoint = element.dataset.metadataUrl if (!endpoint) return const status = element.querySelector("[data-projection-status]") || element.previousElementSibling?.querySelector("[data-projection-status]") const retry = element.querySelector("[data-projection-retry]") || element.previousElementSibling?.querySelector("[data-projection-retry]") const loadingLabel = element.dataset.loadingLabel || "Loading…" const failedLabel = element.dataset.failedLabel || "Metadata unavailable" const unavailableLabel = element.dataset.unavailableLabel || failedLabel let timer, controller, attempts = 0, stopped = false, complete = false const load = async () => { window.clearTimeout(timer) if (stopped || !element.isConnected) return if (document.visibilityState === "hidden") { timer = window.setTimeout(load, 5000) return } attempts++ if (retry) { retry.hidden = true; retry.disabled = true } if (status) status.textContent = loadingLabel controller?.abort() controller = new AbortController() const timeout = window.setTimeout(() => controller.abort(), 15000) try { const response = await fetch(endpoint, { credentials: "same-origin", cache: "no-store", signal: controller.signal }) if (!response.headers.get("content-type")?.includes("application/json")) throw new Error(failedLabel) const data = await response.json() if (response.status === 202 && data.status === "pending") { if (attempts >= 60) { if (retry) { retry.hidden = false; retry.disabled = false } return } const delay = Math.min(10000, Math.max(2000, Number(response.headers.get("Retry-After") || "2") * 1000, attempts * 500)) timer = window.setTimeout(load, delay) return } if (!response.ok || data.status !== "ready") throw new Error(data.status === "unavailable" ? unavailableLabel : failedLabel) if (status) status.textContent = "" ready(data, status) complete = true } catch (error) { if (stopped) return if (status) status.textContent = error.message === unavailableLabel ? unavailableLabel : failedLabel if (retry) { retry.hidden = false; retry.disabled = false } } finally { window.clearTimeout(timeout) } } retry?.addEventListener("click", () => { attempts = 0; load() }) window.addEventListener("pagehide", () => { stopped = true; controller?.abort(); window.clearTimeout(timer) }) window.addEventListener("pageshow", event => { if (event.persisted && !complete) { stopped = false; attempts = 0; load() } }) load() } document.querySelectorAll("[data-archive-metadata]").forEach(viewer => { if (viewer.dataset.metadataStatus === "ready") return watchMetadata(viewer, (data, status) => { const entries = Array.isArray(data.entries) ? data.entries.slice(0, 2000) : [] const table = viewer.querySelector("[data-archive-entries]") const comic = viewer.querySelector("[data-comic-viewer]") const pages = comic?.querySelector("[data-comic-pages]") const fragment = document.createDocumentFragment() for (const entry of entries) { let href try { const url = new URL(entry.url || "", location.href) if (url.origin !== location.origin || url.pathname !== "/v/archive") continue href = url.href } catch { continue } if (table) { const row = document.createElement("tr"), name = document.createElement("td"), size = document.createElement("td") if (entry.is_dir) name.textContent = entry.name else { const link = document.createElement("a"); link.href = href; link.textContent = entry.name; name.append(link) } size.textContent = String(entry.size ?? 0) row.append(name, size); fragment.append(row) } else if (pages && entry.is_image) { const image = document.createElement("img") image.dataset.comicPage = ""; image.dataset.src = href; image.alt = entry.name; image.hidden = true fragment.append(image) } } if (table) table.replaceChildren(fragment) else if (pages) { pages.replaceChildren(fragment); initializeComicViewer(comic) } viewer.dataset.metadataStatus = "ready" if (status) status.textContent = data.truncated ? `${entries.length} · ${viewer.dataset.truncatedLabel || "…"}` : entries.length ? "" : "0" }) }) document.querySelectorAll("[data-pdf-viewer]").forEach(viewer => { const image = viewer.querySelector("[data-pdf-image]") const toolbar = viewer.previousElementSibling const status = toolbar?.querySelector("[data-pdf-status]") let total = Number.parseInt(viewer.dataset.pages || "0", 10) let page = 1 const render = () => { image.src = `/v/pdf-page?rev=${encodeURIComponent(viewer.dataset.revision)}&page=${page}` if (status) status.textContent = `${page} / ${total || "?"}` viewer.scrollTo({ top: 0, behavior: "instant" }) } let retries = 0 image?.addEventListener("error", () => { if (retries >= 90) return retries += 1 window.setTimeout(render, 1000) }) image?.addEventListener("load", () => { retries = 0 }) const move = direction => { const next = page + direction if (next < 1 || (total && next > total)) return page = next render() } toolbar?.querySelector("[data-pdf-prev]") ?.addEventListener("click", () => move(-1)) toolbar?.querySelector("[data-pdf-next]") ?.addEventListener("click", () => move(1)) if (!total) watchMetadata(viewer, data => { total = Math.max(0, Math.min(10000, Number(data.pdf_pages) || 0)) viewer.dataset.pages = String(total) if (total && page > total) { page = total; render() } else if (status) status.textContent = `${page} / ${total || "?"}` }) }) const escapeJSONText = value => String(value ?? "").replace(/[&<>"']/g, character => ({"&":"&","<":"<",">":">",'"':""","'":"'"}[character])) document.querySelectorAll("[data-json-viewer]").forEach(viewer => { const root = viewer.querySelector("[data-json-root]") const status = viewer.querySelector("[data-json-status]") const endpoint = viewer.dataset.jsonUrl if (!root || !endpoint) return const load = async (container, pointer = "", offset = 0, append = false) => { const url = new URL(endpoint, location.href) url.searchParams.set("pointer", pointer);url.searchParams.set("offset", String(offset));url.searchParams.set("limit", "100") if (!append) container.innerHTML = '
Loading…
' const response = await fetch(url, {credentials:"same-origin"}) if (!response.ok) throw new Error(await response.text()) const page = await response.json() if (!append) container.innerHTML = "" for (const item of page.items || []) { const row = document.createElement("div");row.className = "json-structure-item json-kind-" + item.kind if (item.expandable) { row.innerHTML = '' + escapeJSONText(item.key) + '' + escapeJSONText(item.kind) + '' const button=row.querySelector("button"),children=row.querySelector(".json-structure-children") button.addEventListener("click",async()=>{const open=button.getAttribute("aria-expanded")==="true";button.setAttribute("aria-expanded",String(!open));button.textContent=open?"▸":"▾";children.hidden=open;if(!open&&!children.dataset.loaded){children.dataset.loaded="true";try{await load(children,item.path)}catch(error){children.textContent=error.message}}}) } else row.innerHTML = '' + escapeJSONText(item.key) + '' + escapeJSONText(item.preview) + '' + escapeJSONText(item.kind) + '' container.appendChild(row) } if(page.truncated){const more=document.createElement("button");more.type="button";more.className="json-structure-more";more.textContent="Load more";more.addEventListener("click",async()=>{more.remove();await load(container,pointer,page.next_offset,true)});container.appendChild(more)} if(status)status.textContent=page.kind+(page.truncated?" · bounded":"") } load(root).catch(error=>{if(status)status.textContent=error.message}) }) })()