fix: …

src/pages/annotations-index.json.ts

@@ -0,0 +1,197 @@
+import type { APIRoute } from "astro";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { parse as parseYAML } from "yaml";
+
+const CWD = process.cwd();
+const ANNO_DIR = path.join(CWD, "src", "annotations");
+
+// Strict en CI (ou override explicite)
+const STRICT =
+  process.env.ANNOTATIONS_STRICT === "1" ||
+  process.env.CI === "1" ||
+  process.env.CI === "true";
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function walk(dir: string): Promise<string[]> {
+  const out: string[] = [];
+  const ents = await fs.readdir(dir, { withFileTypes: true });
+  for (const e of ents) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) out.push(...(await walk(p)));
+    else out.push(p);
+  }
+  return out;
+}
+
+function isPlainObject(x: unknown): x is Record<string, unknown> {
+  return !!x && typeof x === "object" && !Array.isArray(x);
+}
+
+function normalizePageKey(s: unknown): string {
+  return String(s ?? "")
+    .replace(/^\/+/, "")
+    .replace(/\/+$/, "")
+    .trim();
+}
+
+function inferPageKeyFromFile(inDirAbs: string, fileAbs: string): string {
+  const rel = path.relative(inDirAbs, fileAbs).replace(/\\/g, "/");
+  return rel.replace(/\.(ya?ml|json)$/i, "");
+}
+
+function parseDoc(raw: string, fileAbs: string): unknown {
+  if (/\.json$/i.test(fileAbs)) return JSON.parse(raw);
+  return parseYAML(raw);
+}
+
+function hardFailOrCollect(errors: string[], msg: string): void {
+  if (STRICT) throw new Error(msg);
+  errors.push(msg);
+}
+
+function sanitizeEntry(
+  fileRel: string,
+  paraId: string,
+  entry: unknown,
+  errors: string[]
+): Record<string, unknown> {
+  if (entry == null) return {};
+
+  if (!isPlainObject(entry)) {
+    hardFailOrCollect(errors, `${fileRel}: paras.${paraId} must be an object`);
+    return {};
+  }
+
+  const e: Record<string, unknown> = { ...entry };
+
+  const arrayFields = [
+    "refs",
+    "authors",
+    "quotes",
+    "media",
+    "comments_editorial",
+  ] as const;
+
+  for (const k of arrayFields) {
+    if (e[k] == null) continue;
+    if (!Array.isArray(e[k])) {
+      errors.push(`${fileRel}: paras.${paraId}.${k} must be an array (coerced to [])`);
+      e[k] = [];
+    }
+  }
+
+  return e;
+}
+
+export const GET: APIRoute = async () => {
+  if (!(await exists(ANNO_DIR))) {
+    const out = {
+      schema: 1,
+      generatedAt: new Date().toISOString(),
+      pages: {},
+      stats: { pages: 0, paras: 0, errors: 0 },
+      errors: [] as string[],
+    };
+
+    return new Response(JSON.stringify(out), {
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+      },
+    });
+  }
+
+  const files = (await walk(ANNO_DIR)).filter((p) => /\.(ya?ml|json)$/i.test(p));
+
+  const pages: Record<string, { paras: Record<string, Record<string, unknown>> }> =
+    Object.create(null);
+
+  const errors: string[] = [];
+  let paraCount = 0;
+
+  for (const f of files) {
+    const fileRel = path.relative(CWD, f).replace(/\\/g, "/");
+    const pageKey = normalizePageKey(inferPageKeyFromFile(ANNO_DIR, f));
+
+    if (!pageKey) {
+      hardFailOrCollect(errors, `${fileRel}: cannot infer page key`);
+      continue;
+    }
+
+    let doc: unknown;
+    try {
+      const raw = await fs.readFile(f, "utf8");
+      doc = parseDoc(raw, f);
+    } catch (e) {
+      hardFailOrCollect(errors, `${fileRel}: parse failed: ${String((e as any)?.message ?? e)}`);
+      continue;
+    }
+
+    if (!isPlainObject(doc) || (doc as any).schema !== 1) {
+      hardFailOrCollect(errors, `${fileRel}: schema must be 1`);
+      continue;
+    }
+
+    if ((doc as any).page != null) {
+      const declared = normalizePageKey((doc as any).page);
+      if (declared !== pageKey) {
+        hardFailOrCollect(
+          errors,
+          `${fileRel}: page mismatch (page="${declared}" vs path="${pageKey}")`
+        );
+      }
+    }
+
+    const parasAny = (doc as any).paras;
+    if (!isPlainObject(parasAny)) {
+      hardFailOrCollect(errors, `${fileRel}: missing object key "paras"`);
+      continue;
+    }
+
+    if (pages[pageKey]) {
+      hardFailOrCollect(errors, `${fileRel}: duplicate page "${pageKey}" (only one file per page)`);
+      continue;
+    }
+
+    const parasOut: Record<string, Record<string, unknown>> = Object.create(null);
+
+    for (const [paraId, entry] of Object.entries(parasAny)) {
+      if (!/^p-\d+-/i.test(paraId)) {
+        hardFailOrCollect(errors, `${fileRel}: invalid para id "${paraId}"`);
+        continue;
+      }
+      parasOut[paraId] = sanitizeEntry(fileRel, paraId, entry, errors);
+    }
+
+    pages[pageKey] = { paras: parasOut };
+    paraCount += Object.keys(parasOut).length;
+  }
+
+  const out = {
+    schema: 1,
+    generatedAt: new Date().toISOString(),
+    pages,
+    stats: {
+      pages: Object.keys(pages).length,
+      paras: paraCount,
+      errors: errors.length,
+    },
+    errors,
+  };
+
+  return new Response(JSON.stringify(out), {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": "no-store",
+    },
+  });
+};