@ncukondo/reference-manager 0.24.1 → 0.26.0

package/dist/chunks/{index-zafRwZEZ.js → index-k67fQbe4.js}

@@ -1,5 +1,5 @@
-import { a } from "./index-DWAtvFtp.js";
-import { d, g, l, o, s } from "./index-JA964gjc.js";
+import { a } from "./index-of6eJn8N.js";
+import { d, g, l, o, s } from "./index-BEQ4YIXx.js";
 export {
   a as addAttachment,
   d as detachAttachment,
@@ -8,4 +8,4 @@ export {
   o as openAttachment,
   s as syncAttachments
 };
-//# sourceMappingURL=index-zafRwZEZ.js.map
+//# sourceMappingURL=index-k67fQbe4.js.map

package/dist/chunks/index-k67fQbe4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-k67fQbe4.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/chunks/{index-DWAtvFtp.js → index-of6eJn8N.js}

@@ -11342,6 +11342,12 @@ async function fetchIsbn(isbn) {
     };
   }
 }
+const fetcher = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  fetchDoi,
+  fetchIsbn,
+  fetchPmids
+}, Symbol.toStringTag, { value: "Module" }));
 function parseBibtex(content) {
   return parseWithCitationJs(content, "bibtex");
 }
@@ -12064,6 +12070,183 @@ function createAddRoute(library, config) {
   });
   return route;
 }
+const CHECK_CONCURRENCY = 5;
+async function checkReferences(library, options) {
+  const { checkReference } = await import("./checker-CKfdG8Ia.js");
+  const save = options.save !== false;
+  const skipDays = options.skipDays ?? 7;
+  const items = await resolveItems(library, options);
+  const tasks = items.map((item, index) => ({
+    index,
+    item,
+    skip: shouldSkipRecentCheck(item, skipDays)
+  }));
+  const results = new Array(items.length);
+  fillSkippedResults(tasks, results);
+  const toCheck = tasks.filter((t) => !t.skip);
+  const checkConfig = {
+    ...options.config,
+    ...options.metadata !== void 0 ? { metadata: options.metadata } : {}
+  };
+  await checkInParallel(toCheck, results, checkReference, checkConfig);
+  if (save) {
+    await saveAllResults(library, toCheck, results);
+  }
+  return { results, summary: computeSummary(results) };
+}
+function fillSkippedResults(tasks, results) {
+  for (const task of tasks) {
+    if (task.skip) {
+      results[task.index] = {
+        id: task.item.id,
+        uuid: task.item.custom?.uuid ?? "",
+        status: "skipped",
+        findings: [],
+        checkedAt: task.item.custom?.check?.checked_at,
+        checkedSources: []
+      };
+    }
+  }
+}
+async function checkInParallel(tasks, results, checkFn, config) {
+  for (let i = 0; i < tasks.length; i += CHECK_CONCURRENCY) {
+    const chunk = tasks.slice(i, i + CHECK_CONCURRENCY);
+    const settled = await Promise.allSettled(chunk.map((task) => checkFn(task.item, config)));
+    for (const [j, task] of chunk.entries()) {
+      const outcome = settled[j];
+      results[task.index] = outcome?.status === "fulfilled" ? outcome.value : buildFallbackResult(task.item);
+    }
+  }
+}
+function buildFallbackResult(item) {
+  return {
+    id: item.id,
+    uuid: item.custom?.uuid ?? "",
+    status: "ok",
+    findings: [],
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checkedSources: []
+  };
+}
+async function saveAllResults(library, tasks, results) {
+  for (const task of tasks) {
+    const result = results[task.index];
+    if (result.status !== "skipped") {
+      await saveCheckResult(library, task.item, result);
+    }
+  }
+  if (results.some((r) => r.status !== "skipped")) {
+    await library.save();
+  }
+}
+async function resolveItems(library, options) {
+  if (options.all) {
+    return library.getAll();
+  }
+  if (options.searchQuery) {
+    const { searchReferences: searchReferences2 } = await Promise.resolve().then(() => search);
+    const result = await searchReferences2(library, { query: options.searchQuery });
+    return result.items;
+  }
+  if (options.identifiers && options.identifiers.length > 0) {
+    const idType = options.idType ?? "id";
+    const items = [];
+    for (const identifier of options.identifiers) {
+      const item = await library.find(identifier, { idType });
+      if (!item) {
+        throw new Error(`Reference not found: ${identifier}`);
+      }
+      items.push(item);
+    }
+    return items;
+  }
+  return [];
+}
+function shouldSkipRecentCheck(item, skipDays) {
+  if (skipDays <= 0) return false;
+  const check2 = item.custom?.check;
+  if (!check2?.checked_at) return false;
+  const checkedAt = new Date(check2.checked_at);
+  const now = /* @__PURE__ */ new Date();
+  const daysSince = (now.getTime() - checkedAt.getTime()) / (1e3 * 60 * 60 * 24);
+  return daysSince < skipDays;
+}
+async function saveCheckResult(library, item, result) {
+  const checkData = {
+    checked_at: result.checkedAt,
+    status: result.status === "warning" ? result.findings[0]?.type ?? "warning" : result.status,
+    findings: result.findings.map((f) => ({
+      type: f.type,
+      message: f.message,
+      ...f.details ? { details: snakeCaseKeys(f.details) } : {}
+    }))
+  };
+  const existingCustom = item.custom ?? {};
+  await library.update(item.id, {
+    custom: { ...existingCustom, check: checkData }
+  });
+}
+function snakeCaseKeys(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    result[snakeKey] = value;
+  }
+  return result;
+}
+function computeSummary(results) {
+  return {
+    total: results.length,
+    ok: results.filter((r) => r.status === "ok").length,
+    warnings: results.filter((r) => r.status === "warning").length,
+    skipped: results.filter((r) => r.status === "skipped").length
+  };
+}
+const check = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  checkReferences
+}, Symbol.toStringTag, { value: "Module" }));
+const CheckRequestSchema = z.object({
+  identifiers: z.array(z.string()).optional(),
+  idType: z.enum(["id", "uuid"]).optional(),
+  all: z.boolean().optional(),
+  searchQuery: z.string().optional(),
+  skipDays: z.number().optional(),
+  save: z.boolean().optional(),
+  metadata: z.boolean().optional()
+}).refine((data) => data.identifiers?.length || data.all || data.searchQuery, {
+  message: "Must provide identifiers, all, or searchQuery"
+});
+function buildCheckOptions(data) {
+  const options = {};
+  if (data.identifiers?.length) options.identifiers = data.identifiers;
+  if (data.idType) options.idType = data.idType;
+  if (data.all) options.all = true;
+  if (data.searchQuery) options.searchQuery = data.searchQuery;
+  if (data.skipDays !== void 0) options.skipDays = data.skipDays;
+  if (data.save !== void 0) options.save = data.save;
+  if (data.metadata !== void 0) options.metadata = data.metadata;
+  return options;
+}
+function createCheckRoute(library) {
+  const route = new Hono();
+  route.post("/", async (c) => {
+    let rawBody;
+    try {
+      rawBody = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    const parseResult = CheckRequestSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+      const errorMessage = parseResult.error.issues[0]?.message ?? "Invalid request body";
+      return c.json({ error: errorMessage }, 400);
+    }
+    const result = await checkReferences(library, buildCheckOptions(parseResult.data));
+    return c.json(result);
+  });
+  return route;
+}
 function shouldUseFallback(style, hasCustomXml) {
   if (hasCustomXml) {
     return false;
@@ -12506,6 +12689,8 @@ function createServer(library, config) {
   app.route("/api/list", listRoute);
   const searchRoute = createSearchRoute(library);
   app.route("/api/search", searchRoute);
+  const checkRoute = createCheckRoute(library);
+  app.route("/api/check", checkRoute);
   return app;
 }
 async function startServerWithFileWatcher(libraryPath, config) {
@@ -12534,34 +12719,37 @@ async function startServerWithFileWatcher(libraryPath, config) {
   };
 }
 export {
-  search as A,
+  check as A,
   BUILTIN_STYLES as B,
+  cite as C,
+  list as D,
+  search as E,
   RESERVED_ROLES as R,
   addAttachment as a,
-  findFulltextFiles as b,
-  findFulltextFile as c,
+  generateFilename as b,
+  findFulltextFiles as c,
   deleteDirectoryIfEmpty as d,
   ensureDirectory as e,
   formatBibliographyCSL as f,
-  generateFilename as g,
-  extensionToFormat as h,
+  getRateLimiter as g,
+  findFulltextFile as h,
   isReservedRole as i,
-  fulltextAttach as j,
-  fulltextGet as k,
-  fulltextDiscover as l,
-  fulltextFetch as m,
+  extensionToFormat as j,
+  fulltextAttach as k,
+  fulltextGet as l,
+  fulltextDiscover as m,
   normalizePathForOutput as n,
-  fulltextConvert as o,
+  fulltextFetch as o,
   parseFilename as p,
-  getExtension as q,
-  getDefaultExportFromCjs as r,
-  getFulltextAttachmentTypes as s,
-  startServerWithFileWatcher as t,
-  createServer as u,
-  fetch$1 as v,
-  remove as w,
-  add as x,
-  cite as y,
-  list as z
+  fulltextConvert as q,
+  getExtension as r,
+  getDefaultExportFromCjs as s,
+  getFulltextAttachmentTypes as t,
+  startServerWithFileWatcher as u,
+  createServer as v,
+  fetch$1 as w,
+  remove as x,
+  fetcher as y,
+  add as z
 };
-//# sourceMappingURL=index-DWAtvFtp.js.map
+//# sourceMappingURL=index-of6eJn8N.js.map