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.
1040 lines
47 KiB
JavaScript
1040 lines
47 KiB
JavaScript
(() => {
|
||
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 => ({"&":"&","<":"<",">":">",'"':""","'":"'"}[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})
|
||
})
|
||
})()
|