492 lines
15 KiB
TypeScript
492 lines
15 KiB
TypeScript
import { dirname } from "@std/path";
|
|
import { validateDocuments } from "./src/data.ts";
|
|
import { resolvePdfPath } from "./src/paths.ts";
|
|
import type { BuyerDocument } from "./src/types.ts";
|
|
import {
|
|
type AppSettings,
|
|
clampWindowSize,
|
|
DEFAULTS,
|
|
readLegacyConfig,
|
|
resolveCacheDir,
|
|
resolveSettingsPath,
|
|
saveSettings as saveAppSettings,
|
|
} from "./src/settings.ts";
|
|
import { cacheOrGetPdf } from "./src/pdf_cache.ts";
|
|
import INDEX_HTML from "./web/index.html" with { type: "text" };
|
|
import APP_JS from "./web/app.js" with { type: "text" };
|
|
import STYLES_CSS from "./web/styles.css" with { type: "text" };
|
|
import SAMPLE_DOCUMENTS from "./sample-data/buyers_vision_anonymous.json" with {
|
|
type: "json",
|
|
};
|
|
|
|
const PREFIX = "[BizMatch QC]";
|
|
|
|
let settings: AppSettings = await initializeSettings();
|
|
let documents: BuyerDocument[] = [];
|
|
let loadError = "";
|
|
let dataSource: "sample" | "file" = "sample";
|
|
|
|
try {
|
|
const loaded = await loadDocumentsForMode();
|
|
documents = loaded.documents;
|
|
dataSource = loaded.source;
|
|
} catch (error) {
|
|
loadError = errorMessage(error);
|
|
console.error(`${PREFIX} Initial data load failed: ${loadError}`);
|
|
documents = validateDocuments(SAMPLE_DOCUMENTS);
|
|
dataSource = "sample";
|
|
}
|
|
|
|
async function initializeSettings(): Promise<AppSettings> {
|
|
const path = resolveSettingsPath();
|
|
console.log(`${PREFIX} Settings path: ${path}`);
|
|
|
|
let result: AppSettings;
|
|
let fileExisted = false;
|
|
|
|
try {
|
|
const content = await Deno.readTextFile(path);
|
|
result = JSON.parse(content) as unknown as AppSettings;
|
|
fileExisted = true;
|
|
} catch {
|
|
result = { ...DEFAULTS };
|
|
}
|
|
|
|
const validated = { ...DEFAULTS };
|
|
if (
|
|
fileExisted && result && typeof result === "object" &&
|
|
!Array.isArray(result)
|
|
) {
|
|
const obj = result as unknown as Record<string, unknown>;
|
|
if (typeof obj.jsonPath === "string") validated.jsonPath = obj.jsonPath;
|
|
if (typeof obj.pdfBaseDirectory === "string") {
|
|
validated.pdfBaseDirectory = obj.pdfBaseDirectory;
|
|
}
|
|
if (typeof obj.useAnonymousData === "boolean") {
|
|
validated.useAnonymousData = obj.useAnonymousData;
|
|
}
|
|
if (
|
|
typeof obj.windowWidth === "number" && !isNaN(obj.windowWidth) &&
|
|
obj.windowWidth >= 1100
|
|
) {
|
|
validated.windowWidth = obj.windowWidth;
|
|
}
|
|
if (
|
|
typeof obj.windowHeight === "number" && !isNaN(obj.windowHeight) &&
|
|
obj.windowHeight >= 700
|
|
) {
|
|
validated.windowHeight = obj.windowHeight;
|
|
}
|
|
console.log(`${PREFIX} Settings loaded successfully.`);
|
|
} else {
|
|
console.log(`${PREFIX} No existing settings file found. Using defaults.`);
|
|
}
|
|
|
|
if (!fileExisted) {
|
|
const legacy = await readLegacyConfig();
|
|
if (legacy) {
|
|
validated.jsonPath = validated.jsonPath || legacy.jsonPath;
|
|
validated.pdfBaseDirectory = validated.pdfBaseDirectory ||
|
|
legacy.pdfBaseDirectory;
|
|
await saveAppSettings(validated);
|
|
}
|
|
}
|
|
|
|
return validated;
|
|
}
|
|
|
|
function errorMessage(error: unknown): string {
|
|
return error instanceof Error ? error.message : String(error);
|
|
}
|
|
|
|
async function loadDocumentsFromFile(
|
|
jsonPath: string,
|
|
): Promise<{ documents: BuyerDocument[]; source: "file" }> {
|
|
let raw: string;
|
|
try {
|
|
raw = await Deno.readTextFile(jsonPath);
|
|
} catch (error) {
|
|
throw new Error(
|
|
`Cannot read JSON file "${jsonPath}": ${errorMessage(error)}`,
|
|
);
|
|
}
|
|
|
|
let parsed: unknown;
|
|
try {
|
|
parsed = JSON.parse(raw);
|
|
} catch (error) {
|
|
throw new Error(`Invalid JSON in "${jsonPath}": ${errorMessage(error)}`);
|
|
}
|
|
|
|
try {
|
|
return { documents: validateDocuments(parsed), source: "file" };
|
|
} catch (error) {
|
|
throw new Error(
|
|
`JSON validation failed for "${jsonPath}": ${errorMessage(error)}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
async function loadDocumentsForMode(): Promise<
|
|
{ documents: BuyerDocument[]; source: "sample" | "file" }
|
|
> {
|
|
if (settings.useAnonymousData) {
|
|
return { documents: validateDocuments(SAMPLE_DOCUMENTS), source: "sample" };
|
|
}
|
|
if (!settings.jsonPath.trim()) {
|
|
return { documents: validateDocuments(SAMPLE_DOCUMENTS), source: "sample" };
|
|
}
|
|
return await loadDocumentsFromFile(settings.jsonPath);
|
|
}
|
|
|
|
async function applySettings(
|
|
next: {
|
|
jsonPath?: string;
|
|
pdfBaseDirectory?: string;
|
|
useAnonymousData?: boolean;
|
|
},
|
|
): Promise<void> {
|
|
const newSettings: AppSettings = {
|
|
...settings,
|
|
jsonPath: next.jsonPath !== undefined
|
|
? next.jsonPath.trim()
|
|
: settings.jsonPath,
|
|
pdfBaseDirectory: next.pdfBaseDirectory !== undefined
|
|
? next.pdfBaseDirectory.trim()
|
|
: settings.pdfBaseDirectory,
|
|
useAnonymousData: next.useAnonymousData !== undefined
|
|
? next.useAnonymousData
|
|
: settings.useAnonymousData,
|
|
};
|
|
|
|
if (newSettings.useAnonymousData) {
|
|
const docs = validateDocuments(SAMPLE_DOCUMENTS);
|
|
settings = newSettings;
|
|
documents = docs;
|
|
dataSource = "sample";
|
|
loadError = "";
|
|
await saveAppSettings(settings);
|
|
console.log(
|
|
`${PREFIX} Switched to anonymized sample data (${docs.length} documents).`,
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (!newSettings.jsonPath.trim()) {
|
|
settings = newSettings;
|
|
documents = validateDocuments(SAMPLE_DOCUMENTS);
|
|
dataSource = "sample";
|
|
loadError = "";
|
|
await saveAppSettings(settings);
|
|
console.log(`${PREFIX} No JSON path configured; using sample data.`);
|
|
return;
|
|
}
|
|
|
|
const loaded = await loadDocumentsFromFile(newSettings.jsonPath);
|
|
|
|
if (newSettings.pdfBaseDirectory) {
|
|
try {
|
|
const stat = await Deno.stat(newSettings.pdfBaseDirectory);
|
|
if (!stat.isDirectory) {
|
|
throw new Error("Path exists but is not a directory.");
|
|
}
|
|
} catch (error) {
|
|
throw new Error(
|
|
`Cannot access PDF base directory "${newSettings.pdfBaseDirectory}": ${
|
|
errorMessage(error)
|
|
}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
await saveAppSettings(newSettings);
|
|
settings = newSettings;
|
|
documents = loaded.documents;
|
|
dataSource = loaded.source;
|
|
loadError = "";
|
|
console.log(
|
|
`${PREFIX} Loaded ${documents.length} documents from ${settings.jsonPath}.`,
|
|
);
|
|
if (settings.pdfBaseDirectory) {
|
|
console.log(`${PREFIX} PDF base directory: ${settings.pdfBaseDirectory}`);
|
|
}
|
|
}
|
|
|
|
function json(data: unknown, status = 200) {
|
|
return Response.json(data, {
|
|
status,
|
|
headers: { "cache-control": "no-store" },
|
|
});
|
|
}
|
|
|
|
function staticFile(pathname: string): Response {
|
|
const files: Record<string, { body: string; type: string }> = {
|
|
"/": { body: INDEX_HTML, type: "text/html; charset=utf-8" },
|
|
"/index.html": { body: INDEX_HTML, type: "text/html; charset=utf-8" },
|
|
"/app.js": { body: APP_JS, type: "text/javascript; charset=utf-8" },
|
|
"/styles.css": { body: STYLES_CSS, type: "text/css; charset=utf-8" },
|
|
};
|
|
const file = files[pathname];
|
|
if (!file) return new Response("Not found", { status: 404 });
|
|
return new Response(file.body, {
|
|
headers: { "content-type": file.type, "cache-control": "no-store" },
|
|
});
|
|
}
|
|
|
|
function syncSaveSettings() {
|
|
try {
|
|
const path = resolveSettingsPath();
|
|
Deno.mkdirSync(dirname(path), { recursive: true });
|
|
Deno.writeTextFileSync(path, JSON.stringify(settings, null, 2));
|
|
console.log(
|
|
`${PREFIX} Window size saved: ${settings.windowWidth}x${settings.windowHeight}`,
|
|
);
|
|
} catch (err) {
|
|
console.error(
|
|
`${PREFIX} Failed to save settings on close: ${errorMessage(err)}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
Deno.serve(async (request) => {
|
|
const url = new URL(request.url);
|
|
|
|
if (url.pathname === "/api/state" && request.method === "GET") {
|
|
const configForClient = {
|
|
jsonPath: settings.jsonPath,
|
|
pdfBaseDirectory: settings.pdfBaseDirectory,
|
|
useAnonymousData: settings.useAnonymousData,
|
|
};
|
|
return json({ config: configForClient, documents, loadError, dataSource });
|
|
}
|
|
|
|
if (url.pathname === "/api/config" && request.method === "POST") {
|
|
try {
|
|
interface ConfigBody {
|
|
jsonPath?: string;
|
|
pdfBaseDirectory?: string;
|
|
useAnonymousData?: boolean;
|
|
}
|
|
const body = await request.json() as ConfigBody;
|
|
await applySettings({
|
|
jsonPath: body.jsonPath ?? settings.jsonPath,
|
|
pdfBaseDirectory: body.pdfBaseDirectory ?? settings.pdfBaseDirectory,
|
|
useAnonymousData: body.useAnonymousData ?? settings.useAnonymousData,
|
|
});
|
|
return json({ ok: true, count: documents.length, dataSource });
|
|
} catch (error) {
|
|
const message = errorMessage(error);
|
|
loadError = message;
|
|
console.error(`${PREFIX} Settings rejected: ${message}`);
|
|
return json({ error: message }, 400);
|
|
}
|
|
}
|
|
|
|
if (url.pathname === "/api/window-size" && request.method === "POST") {
|
|
try {
|
|
const body = await request.json() as { width?: number; height?: number };
|
|
if (typeof body.width === "number" && typeof body.height === "number") {
|
|
settings.windowWidth = Math.max(1100, Math.round(body.width));
|
|
settings.windowHeight = Math.max(700, Math.round(body.height));
|
|
await saveAppSettings(settings);
|
|
console.log(
|
|
`${PREFIX} Window size saved (fallback): ${settings.windowWidth}x${settings.windowHeight}`,
|
|
);
|
|
}
|
|
return json({ ok: true });
|
|
} catch {
|
|
return json({ ok: true });
|
|
}
|
|
}
|
|
|
|
if (url.pathname === "/api/pdf" && request.method === "GET") {
|
|
const index = Number(url.searchParams.get("index"));
|
|
const doc = documents[index];
|
|
if (!Number.isInteger(index) || !doc) {
|
|
return json({ error: "Unknown document index." }, 404);
|
|
}
|
|
|
|
try {
|
|
const sourcePath = resolvePdfPath(settings.pdfBaseDirectory, doc);
|
|
const startTotal = performance.now();
|
|
|
|
const cacheResult = await cacheOrGetPdf(sourcePath);
|
|
const cacheLookupMs = Math.round(performance.now() - startTotal);
|
|
let fileSize: number;
|
|
|
|
try {
|
|
fileSize = (await Deno.stat(cacheResult.path)).size;
|
|
} catch {
|
|
throw new Error(`Cached file is not readable: "${cacheResult.path}"`);
|
|
}
|
|
|
|
const rangeHeader = request.headers.get("range");
|
|
|
|
if (rangeHeader) {
|
|
const match = rangeHeader.match(/^bytes=(\d+)-(\d*)$/);
|
|
if (match) {
|
|
const rangeStart = parseInt(match[1], 10);
|
|
const rangeEnd = match[2] ? parseInt(match[2], 10) : fileSize - 1;
|
|
const length = rangeEnd - rangeStart + 1;
|
|
|
|
if (
|
|
rangeStart < 0 || rangeEnd >= fileSize || rangeStart > rangeEnd
|
|
) {
|
|
return new Response(null, {
|
|
status: 416,
|
|
headers: {
|
|
"content-range": `bytes */${fileSize}`,
|
|
},
|
|
});
|
|
}
|
|
|
|
const file = await Deno.open(cacheResult.path, { read: true });
|
|
await file.seek(rangeStart, Deno.SeekMode.Start);
|
|
const buf = new Uint8Array(length);
|
|
let bytesRead = 0;
|
|
while (bytesRead < length) {
|
|
const n = await file.read(buf.subarray(bytesRead));
|
|
if (n === null) break;
|
|
bytesRead += n;
|
|
}
|
|
file.close();
|
|
|
|
const elapsed = Math.round(performance.now() - startTotal);
|
|
console.log(
|
|
`${PREFIX} PDF served (range ${rangeStart}-${rangeEnd}/${fileSize}): ${elapsed}ms, cache_lookup=${cacheLookupMs}ms`,
|
|
);
|
|
|
|
return new Response(buf.slice(0, bytesRead), {
|
|
status: 206,
|
|
headers: {
|
|
"content-type": "application/pdf",
|
|
"content-length": String(bytesRead),
|
|
"content-range": `bytes ${rangeStart}-${
|
|
rangeStart + bytesRead - 1
|
|
}/${fileSize}`,
|
|
"accept-ranges": "bytes",
|
|
"content-disposition": `inline; filename*=UTF-8''${
|
|
encodeURIComponent(doc.file_name)
|
|
}`,
|
|
...(cacheResult.stale
|
|
? { "x-bizmatch-cache-status": "stale" }
|
|
: {}),
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
const file = await Deno.open(cacheResult.path, { read: true });
|
|
const elapsed = Math.round(performance.now() - startTotal);
|
|
console.log(
|
|
`${PREFIX} PDF served (full ${fileSize}B): ${elapsed}ms, cache_lookup=${cacheLookupMs}ms`,
|
|
);
|
|
|
|
return new Response(file.readable, {
|
|
headers: {
|
|
"content-type": "application/pdf",
|
|
"content-length": String(fileSize),
|
|
"accept-ranges": "bytes",
|
|
"content-disposition": `inline; filename*=UTF-8''${
|
|
encodeURIComponent(doc.file_name)
|
|
}`,
|
|
...(cacheResult.stale ? { "x-bizmatch-cache-status": "stale" } : {}),
|
|
},
|
|
});
|
|
} catch (error) {
|
|
const message = errorMessage(error);
|
|
console.error(
|
|
`${PREFIX} PDF open failed for "${doc.file_name}": ${message}`,
|
|
);
|
|
return json({ error: message }, 404);
|
|
}
|
|
}
|
|
|
|
return staticFile(url.pathname);
|
|
});
|
|
|
|
console.log(`${PREFIX} Listening on http://127.0.0.1:42469/`);
|
|
console.log(`${PREFIX} Settings path: ${resolveSettingsPath()}`);
|
|
console.log(`${PREFIX} PDF cache directory: ${resolveCacheDir()}`);
|
|
console.log(
|
|
`${PREFIX} Data mode: ${
|
|
settings.useAnonymousData
|
|
? "anonymized sample"
|
|
: (settings.jsonPath ? `file (${settings.jsonPath})` : "embedded sample")
|
|
}`,
|
|
);
|
|
console.log(`${PREFIX} Documents loaded: ${documents.length}`);
|
|
if (loadError) console.error(`${PREFIX} ${loadError}`);
|
|
|
|
const clamped = clampWindowSize(settings);
|
|
console.log(
|
|
`${PREFIX} Restoring window size: ${clamped.windowWidth}x${clamped.windowHeight}`,
|
|
);
|
|
|
|
// Deno Desktop provides Deno.BrowserWindow at runtime but the standard
|
|
// Deno 2.9 type checker does not include desktop type declarations.
|
|
// The runtime `deno desktop` command also types this as a generic
|
|
// BrowserWindow<WindowBindings> without width/height properties.
|
|
// We use a local type assertion to narrow to the exact API we use.
|
|
// Remove this cast when official desktop types become available.
|
|
type _Win = {
|
|
readonly width: number;
|
|
readonly height: number;
|
|
onresize: ((event: Event) => void) | null;
|
|
onclose: ((event: Event) => void) | null;
|
|
show(): void;
|
|
};
|
|
const _WinCtor = (Deno as unknown as {
|
|
BrowserWindow: new (
|
|
opts?: { title?: string; width?: number; height?: number },
|
|
) => _Win;
|
|
}).BrowserWindow;
|
|
const win = new _WinCtor({
|
|
title: "BizMatch QC",
|
|
width: clamped.windowWidth,
|
|
height: clamped.windowHeight,
|
|
});
|
|
console.log(
|
|
`${PREFIX} Window initialized: ${clamped.windowWidth}x${clamped.windowHeight}`,
|
|
);
|
|
|
|
// Native resize tracking
|
|
let resizeTimer: ReturnType<typeof setTimeout> | undefined;
|
|
try {
|
|
win.onresize = () => {
|
|
if (resizeTimer !== undefined) clearTimeout(resizeTimer);
|
|
resizeTimer = setTimeout(() => {
|
|
const w = win.width;
|
|
const h = win.height;
|
|
if (w > 0 && h > 0) {
|
|
settings.windowWidth = w;
|
|
settings.windowHeight = h;
|
|
console.log(`${PREFIX} Window resized: ${w}x${h}`);
|
|
saveAppSettings(settings).catch((err) =>
|
|
console.error(
|
|
`${PREFIX} Failed to save window size: ${errorMessage(err)}`,
|
|
)
|
|
);
|
|
}
|
|
}, 500);
|
|
};
|
|
|
|
win.onclose = () => {
|
|
if (resizeTimer !== undefined) clearTimeout(resizeTimer);
|
|
const w = win.width;
|
|
const h = win.height;
|
|
if (w > 0 && h > 0) {
|
|
settings.windowWidth = w;
|
|
settings.windowHeight = h;
|
|
syncSaveSettings();
|
|
}
|
|
};
|
|
} catch (err) {
|
|
console.warn(
|
|
`${PREFIX} Native window-event binding unavailable: ${errorMessage(err)}`,
|
|
);
|
|
console.warn(`${PREFIX} Falling back to web-page resize tracking.`);
|
|
}
|
|
|
|
win.show();
|