// P4 Files (AK-P4a) ยง11 โ€” Files browser route. Loader builds the FileBrowserVM // once (server-side); the component only renders (DoD A). Module off -> locked // empty state (like walking-skeleton). Missing files.read_own -> 404. // // Interim-UI (AD-28): renders the ~/ui preview screen FilesBrowserPage; the loader // owns navigation for filter/view changes (server-side). Final Subframe optics land // as a tracked design-nachzug once David's D-P4 delta ships. import { useCallback, useState } from "react"; import { type LoaderFunctionArgs, useLoaderData, useNavigate, useRevalidator } from "react-router"; import { buildFileBrowserVM, type FileBrowserRow, type FileBrowserVM, type FileViewMode } from "@hivegrid/view-models"; import { getTranslations } from "~/locale/i18next.server"; import { loadFilesContext, notFoundResponse, requireFilesPermission } from "~/utils/integrations/fileAccess.server"; import { loadFileBrowserData } from "~/utils/integrations/fileService.server"; import { mediaVariantPath, filesDetailPath } from "~/utils/integrations/fileRoutePaths"; import { FilesBrowserPage, type FilesBrowserQuery } from "~/components/screens/files/FilesBrowserPage"; import type { FileUploadDisplayItem } from "~/components/screens/files/FileUploadPage"; import { uploadFileInChunks, UploadFileClientError } from "~/utils/files/uploadFileClient"; import ServerError from "~/components/ui/errors/ServerError"; type LoaderData = { title: string; vm: FileBrowserVM; tenantSlug: string; bulkZipAction: string }; export const loader = async ({ request, params }: LoaderFunctionArgs) => { const { t } = await getTranslations(request); const ctx = await loadFilesContext({ request, params }); const tenantSlug = params.tenant ?? ""; // Absolute (host-aware) URL โ€” a relative "bulk-zip" would resolve against the // //files base and drop the "files" segment (โ†’ 404). const bulkZipAction = `/${tenantSlug}/files/bulk-zip`; if (!ctx.hasModule) { // Locked connector state: render an empty VM (no rows, no write). const vm = buildFileBrowserVM({ rows: [], filter: { entityType: null, mimeGroup: null, tags: [], assignedToUserId: null, includeArchived: false, q: "" }, canWrite: false, canDelete: false, }); return Response.json({ title: `${t("files.browser.title")} | ${process.env.APP_NAME}`, vm, tenantSlug, bulkZipAction, } satisfies LoaderData); } try { requireFilesPermission(ctx, "files.read_own"); } catch { throw notFoundResponse(); } const url = new URL(request.url); const includeArchived = url.searchParams.get("archived") === "1"; const mimeGroup = url.searchParams.get("mime"); const entityType = url.searchParams.get("entity"); const tag = url.searchParams.get("tag"); const assignedToUserId = url.searchParams.get("assignee"); const q = url.searchParams.get("q") ?? ""; const pageParam = Number.parseInt(url.searchParams.get("page") ?? "1", 10); const viewMode: FileViewMode = url.searchParams.get("view") === "grid" ? "grid" : "table"; const { rows, total, page, pageCount, filterOptions } = await loadFileBrowserData({ tenantId: ctx.tenantId, ctx, filter: { includeArchived, mimeGroup, entityType, tags: tag ? [tag] : undefined, assignedToUserId, q }, page: Number.isFinite(pageParam) ? pageParam : 1, }); const canWrite = ctx.permissions.includes("files.write"); const canDelete = ctx.permissions.includes("files.delete"); const browserRows: FileBrowserRow[] = rows.map((file) => ({ id: file.id, displayName: file.displayName, mimeType: file.mimeType, sizeBytes: file.sizeBytes, createdAtIso: file.createdAt.toISOString(), tags: file.tags, source: file.source, previewStatus: file.previewStatus as FileBrowserRow["previewStatus"], scanStatus: file.scanStatus as FileBrowserRow["scanStatus"], thumbnailUrl: file.thumbnailStorageKey && file.previewStatus === "ready" ? mediaVariantPath(tenantSlug, file.id, "thumb") : null, detailHref: filesDetailPath(tenantSlug, file.id), linkedEntityLabelKey: null, })); const vm = buildFileBrowserVM({ viewMode, rows: browserRows, filter: { entityType, mimeGroup, tags: tag ? [tag] : [], assignedToUserId, includeArchived, q }, filterOptions, canWrite, canDelete, page, pageCount, total, }); return Response.json({ title: `${t("files.browser.title")} | ${process.env.APP_NAME}`, vm, tenantSlug, bulkZipAction } satisfies LoaderData); }; export default function FilesBrowserRoute() { const { vm, tenantSlug, bulkZipAction } = useLoaderData(); const navigate = useNavigate(); const revalidator = useRevalidator(); const [selectedIds, setSelectedIds] = useState([]); const [uploadItems, setUploadItems] = useState([]); const canWrite = vm.status === "ready" && vm.data.canWrite; function onToggleSelect(id: string) { setSelectedIds((prev) => (prev.includes(id) ? prev.filter((value) => value !== id) : [...prev, id])); } function onToggleSelectAll(ids: readonly string[], selectAll: boolean) { setSelectedIds(selectAll ? [...ids] : []); } // --- Upload pipeline of the browser's upload dialog --------------------- // Same chunked client as the former upload view (init -> chunk -> complete); // it lives here because the screen stays presentational. Every finished file // revalidates the loader, so the new file is in the list behind the dialog. const updateItem = useCallback((clientId: string, patch: Partial) => { setUploadItems((current) => current.map((item) => (item.clientId === clientId ? { ...item, ...patch } : item))); }, []); const uploadOne = useCallback( async (file: File, clientId: string) => { try { updateItem(clientId, { status: "uploading", progressPercent: 0 }); await uploadFileInChunks({ tenantSlug, file, onProgress: (percent) => updateItem(clientId, { progressPercent: percent }), onProcessing: () => updateItem(clientId, { status: "processing" }), }); updateItem(clientId, { status: "done", progressPercent: 100 }); revalidator.revalidate(); } catch (error) { updateItem(clientId, { status: "error", errorKey: error instanceof UploadFileClientError ? error.errorKey : "files.error.uploadIncomplete", }); } }, [revalidator, tenantSlug, updateItem], ); const onFiles = useCallback( (fileList: FileList | null) => { if (!fileList) return; const next: FileUploadDisplayItem[] = []; for (const file of Array.from(fileList)) { const clientId = `${file.name}-${file.size}-${file.lastModified}`; next.push({ clientId, filename: file.name, sizeBytes: file.size, status: "queued", progressPercent: 0, errorKey: null }); void uploadOne(file, clientId); } setUploadItems((current) => [...current, ...next]); }, [uploadOne], ); const clearUploadQueue = useCallback(() => setUploadItems([]), []); const uploading = uploadItems.some((item) => item.status === "queued" || item.status === "uploading" || item.status === "processing"); function buildSearch(query: FilesBrowserQuery, page: number): string { const params = new URLSearchParams(); if (query.mimeGroup) params.set("mime", query.mimeGroup); if (query.entityType) params.set("entity", query.entityType); if (query.tag) params.set("tag", query.tag); if (query.assignedToUserId) params.set("assignee", query.assignedToUserId); if (query.q.trim()) params.set("q", query.q.trim()); if (query.includeArchived) params.set("archived", "1"); if (query.viewMode === "grid") params.set("view", "grid"); if (page > 1) params.set("page", String(page)); return params.toString(); } function onApply(query: FilesBrowserQuery) { // Any filter/search/view change starts over at page 1: page 3 of the old // result set says nothing about the new one. navigate({ search: buildSearch(query, 1) }); } function onGoToPage(query: FilesBrowserQuery, page: number) { navigate({ search: buildSearch(query, page) }); } return ( ); } export function ErrorBoundary() { return ; }