Files
pages/static/js/content-viewer.js
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

1040 lines
47 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
(() => {
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 = `<p class="muted">${error.message}</p>`
} 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 = `<div class="children-loading" role="status">Loading…</div>`
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 => ({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[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 = '<div class="json-structure-loading">Loading…</div>'
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 = '<button type="button" class="json-structure-toggle" aria-expanded="false">▸</button><code class="json-structure-key">' + escapeJSONText(item.key) + '</code><span class="json-structure-kind">' + escapeJSONText(item.kind) + '</span><div class="json-structure-children" hidden></div>'
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 = '<span class="json-structure-spacer"></span><code class="json-structure-key">' + escapeJSONText(item.key) + '</code><span class="json-structure-value">' + escapeJSONText(item.preview) + '</span><span class="json-structure-kind">' + escapeJSONText(item.kind) + '</span>'
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})
})
})()