cry-vetzdravila 1.0.0

package/src/atcvet/parseAtcvetPdf.ts

@@ -0,0 +1,215 @@
+/**
+ * Parsanje ATCVet PDF dokumenta
+ *
+ * Bere data/atcvet.pdf in ustvari data/atcvet.json
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import * as pdfjsLib from "pdfjs-dist/legacy/build/pdf.mjs";
+import type { AtcvetRow, AtcvetFile } from "./types/AtcvetFile";
+
+type TextItem = {
+  str: string;
+  transform: number[]; // [a,b,c,d,e,f] where e=x, f=y
+};
+
+function normalizeSpaces(s: string): string {
+  return s.replace(/\s+/g, " ").trim();
+}
+
+function isFooterOrNoise(line: string): boolean {
+  const t = normalizeSpaces(line);
+  // common noise patterns found in this PDF export
+  if (!t) return true;
+  if (t === "ATC 2025") return true;
+  if (t.startsWith("Stran ")) return true; // e.g. "Stran 2 of 139ATC 2025"
+  if (t === "ATCCode ATCDescription ATCDescriptionSI") return true;
+  return false;
+}
+
+// Heuristic: ATCvet codes start with Q and then letters/digits; in this doc examples are like QA, QA01, QA01A, QA01AA, QA01AA01
+// QA01AA01 has 8 chars total, so we need {1,7} after Q
+const CODE_RE = /^Q[A-Z0-9]{1,7}$/;
+
+function inferLevel(code: string): 1 | 2 | 3 | 4 | 5 {
+  // Typical lengths in this doc:
+  // 2: QA (level 1)
+  // 4: QA01 (level 2)
+  // 5: QA01A (level 3)
+  // 6: QA01AA (level 4)
+  // 8: QA01AA01 (level 5)
+  const len = code.length;
+  if (len <= 2) return 1;
+  if (len === 4) return 2;
+  if (len === 5) return 3;
+  if (len === 6) return 4;
+  return 5;
+}
+
+function inferParent(code: string): string | undefined {
+  const level = inferLevel(code);
+  if (level === 1) return undefined;
+  if (level === 2) return code.slice(0, 2);
+  if (level === 3) return code.slice(0, 4);
+  if (level === 4) return code.slice(0, 5);
+  return code.slice(0, 6);
+}
+
+function groupByLine(items: TextItem[]): Map<number, TextItem[]> {
+  // group by rounded Y coordinate (PDF uses floats)
+  const map = new Map<number, TextItem[]>();
+  for (const it of items) {
+    const x = it.transform[4];
+    const y = it.transform[5];
+    const yKey = Math.round(y * 2) / 2; // 0.5 precision
+    const arr = map.get(yKey) ?? [];
+    arr.push({ ...it, transform: [0,0,0,0,x,y] });
+    map.set(yKey, arr);
+  }
+  // sort each line by X
+  for (const [k, arr] of map.entries()) {
+    arr.sort((a, b) => a.transform[4] - b.transform[4]);
+    map.set(k, arr);
+  }
+  return map;
+}
+
+export async function parseAtcvetPdf(pdfPath: string): Promise<AtcvetRow[]> {
+  const data = new Uint8Array(fs.readFileSync(pdfPath));
+  const doc = await pdfjsLib.getDocument({ data }).promise;
+
+  const out: AtcvetRow[] = [];
+  let lastRow: AtcvetRow | null = null;
+
+  for (let p = 1; p <= doc.numPages; p++) {
+    const page = await doc.getPage(p);
+    const content = await page.getTextContent();
+    const rawItems = content.items as unknown as TextItem[];
+
+    // Find header on this page to detect column X positions.
+    // We look for "ATCCode", "ATCDescription", "ATCDescriptionSI"
+    const headerItems = rawItems
+      .filter(i => ["ATCCode", "ATCDescription", "ATCDescriptionSI"].includes(i.str.trim()));
+
+    // Fallback column boundaries if header not found (should usually be found)
+    // PDF has: ATCCode ~19, ATCDescription ~79, ATCDescriptionSI ~624
+    let xCodeMax = 70;
+    let xEnMax = 600;
+
+    if (headerItems.length >= 3) {
+      const xs = headerItems
+        .map(i => ({ s: i.str.trim(), x: i.transform[4] }))
+        .sort((a, b) => a.x - b.x);
+
+      const xEn = xs.find(v => v.s === "ATCDescription")?.x;
+      const xSi = xs.find(v => v.s === "ATCDescriptionSI")?.x;
+
+      // boundaries are just before the next column starts
+      if (typeof xEn === "number") {
+        xCodeMax = xEn - 5;
+      }
+      if (typeof xSi === "number") {
+        xEnMax = xSi - 5;
+      }
+    }
+
+    const byLine = groupByLine(rawItems);
+
+    // Sort lines top-to-bottom by Y (PDF y increases upwards; we want descending)
+    const yKeys = Array.from(byLine.keys()).sort((a, b) => b - a);
+
+    for (const y of yKeys) {
+      const lineItems = byLine.get(y)!;
+
+      // Build 3 column strings based on x boundaries
+      let colCode = "";
+      let colEn = "";
+      let colSi = "";
+
+      for (const it of lineItems) {
+        const s = it.str;
+        if (!s || !s.trim()) continue;
+        const x = it.transform[4];
+
+        if (x <= xCodeMax) colCode += s;
+        else if (x <= xEnMax) colEn += (colEn ? " " : "") + s;
+        else colSi += (colSi ? " " : "") + s;
+      }
+
+      colCode = normalizeSpaces(colCode);
+      colEn = normalizeSpaces(colEn);
+      colSi = normalizeSpaces(colSi);
+
+      const joinedForNoise = normalizeSpaces([colCode, colEn, colSi].filter(Boolean).join(" "));
+      if (isFooterOrNoise(joinedForNoise)) continue;
+
+      // Some footers can end up in colCode area; filter them
+      if (colCode.startsWith("Stran ")) continue;
+
+      // If we have a code -> new row; else treat as continuation and append
+      if (colCode && CODE_RE.test(colCode)) {
+        const row: AtcvetRow = {
+          code: colCode,
+          desc_en: colEn,
+          desc_si: colSi,
+          level: inferLevel(colCode),
+          parent: inferParent(colCode),
+        };
+        if (!row.parent) delete row.parent;
+
+        out.push(row);
+        lastRow = row;
+      } else if (lastRow) {
+        // continuation line (rare, but can happen if long descriptions wrap)
+        // append whichever columns are populated
+        if (colEn) lastRow.desc_en = normalizeSpaces(`${lastRow.desc_en} ${colEn}`);
+        if (colSi) lastRow.desc_si = normalizeSpaces(`${lastRow.desc_si} ${colSi}`);
+      }
+    }
+  }
+
+  // final cleanup: drop duplicates (if any) by code, keep first
+  const seen = new Set<string>();
+  const dedup: AtcvetRow[] = [];
+  for (const r of out) {
+    if (seen.has(r.code)) continue;
+    seen.add(r.code);
+    // ensure required fields
+    r.desc_en = normalizeSpaces(r.desc_en);
+    r.desc_si = normalizeSpaces(r.desc_si);
+    dedup.push(r);
+  }
+
+  return dedup;
+}
+
+const DEFAULT_PDF_PATH = "./data/atcvet.pdf";
+const DEFAULT_JSON_PATH = "./data/atcvet.json";
+
+async function main() {
+  const pdfIn = process.argv[2] || DEFAULT_PDF_PATH;
+  const jsonOut = process.argv[3] || DEFAULT_JSON_PATH;
+
+  console.log(`Parsam: ${pdfIn}`);
+  const rows = await parseAtcvetPdf(pdfIn);
+
+  const payload: AtcvetFile = {
+    meta: {
+      source: path.basename(pdfIn),
+      generatedAt: new Date().toISOString(),
+      count: rows.length,
+    },
+    rows,
+  };
+
+  fs.writeFileSync(jsonOut, JSON.stringify(payload, null, 2), "utf8");
+  console.log(`Zapisano ${rows.length} vrstic v ${jsonOut}`);
+}
+
+if (import.meta.main) {
+  main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });
+}

package/src/atcvet/podatkiATCvetKode.ts

@@ -0,0 +1,34 @@
+import { opisATCvetKode, izracunajNivoje, type RazlagaATCvetKode } from "./opisATCvetKode";
+
+export type { RazlagaATCvetKode };
+
+/**
+ * Funkcija vrne opise vseh nivojev za dano ATCvet kodo, urejene po nivoju
+ * @param koda ATCvet koda (npr. "QA01AA01")
+ * @returns Seznam razlag za vse nivoje kode
+ * @example
+ * ```typescript
+ * const rezultat = podatkiATCvetKode("QA01AC03");
+ * // Vrne:
+ * // [
+ * //   { nivo: 0, pomenNivoja: "veterinarska uporaba", opisNivoja: "Veterinarska zdravila" },
+ * //   { nivo: 1, pomenNivoja: "anatomska glavna skupina", opisNivoja: "ZDRAVILA ZA BOLEZNI PREBAVIL IN PRESNOVE" },
+ * //   { nivo: 2, pomenNivoja: "terapevtska podskupina", opisNivoja: "ZDRAVILA V ZOBOZDRAVSTVU" },
+ * //   { nivo: 3, pomenNivoja: "farmakološka podskupina", opisNivoja: "Zdravila v zobozdravstvu" },
+ * //   { nivo: 5, pomenNivoja: "kemijska učinkovina", opisNivoja: "hidrokortizon" }
+ * // ]
+ * ```
+ */
+export function podatkiATCvetKode(koda: string): RazlagaATCvetKode[] {
+	const nivoji = izracunajNivoje(koda);
+	const rezultati: RazlagaATCvetKode[] = [];
+
+	for (const nivoKoda of nivoji) {
+		const opis = opisATCvetKode(nivoKoda);
+		if (opis) {
+			rezultati.push(opis);
+		}
+	}
+
+	return rezultati;
+}

package/src/atcvet/pomeniNivojevATCvet.ts

@@ -0,0 +1,8 @@
+export const pomeniNivojevATCvet: Array<[nivo: number, pomen: string]> = [
+  [0, "veterinarska uporaba"],
+  [1, "anatomska glavna skupina"],
+  [2, "terapevtska podskupina"],
+  [3, "farmakološka podskupina"],
+  [4, "kemijska podskupina"],
+  [5, "kemijska učinkovina"]
+];

package/src/atcvet/types/AtcvetFile.ts

@@ -0,0 +1,22 @@
+/**
+ * Tipizacija za ATCVet JSON datoteko
+ */
+
+export interface AtcvetRow {
+	code: string;
+	desc_en: string;
+	desc_si: string;
+	level: 1 | 2 | 3 | 4 | 5;
+	parent?: string;
+}
+
+export interface AtcvetMeta {
+	source: string;
+	generatedAt: string;
+	count: number;
+}
+
+export interface AtcvetFile {
+	meta: AtcvetMeta;
+	rows: AtcvetRow[];
+}

package/src/generate.ts

@@ -0,0 +1,111 @@
+/**
+ * Generiranje TypeScript datotek iz JSON podatkov
+ *
+ * Generira:
+ * - generated/seznamZdravil.ts - seznam zdravil
+ * - generated/AtcVet.ts - ATCVet klasifikacija
+ */
+
+import fs from "node:fs";
+import type { RegisterRaw } from "./register/types/RegisterRaw";
+import type { AtcvetFile } from "./atcvet/types/AtcvetFile";
+import { Zdravilo } from "./register/types/Zdravilo";
+
+const GENERATED_DIR = "./src/generated";
+const REGISTER_JSON = "./data/register.json";
+const ATCVET_JSON = "./data/atcvet.json";
+
+/**
+ * Ustvari direktorij če ne obstaja
+ */
+export function ensureGeneratedDir(): void {
+	if (!fs.existsSync(GENERATED_DIR)) {
+		fs.mkdirSync(GENERATED_DIR, { recursive: true });
+	}
+}
+
+/**
+ * Generiraj RegisterZdravil.ts
+ */
+export function generateRegisterZdravil(): void {
+	console.log("Generiram RegisterZdravil.ts...");
+
+	const registerData = JSON.parse(fs.readFileSync(REGISTER_JSON, "utf8")) as RegisterRaw;
+	const registerZdravil = new Map<number, Zdravilo>();
+
+	for (let zdravilo of registerData.zdravila) {
+		registerZdravil.set(zdravilo.id,zdravilo)
+	}
+
+	const content = `/**
+ * Seznam veterinarskih zdravil registriranih v Sloveniji
+ *
+ * Generirano: ${new Date().toISOString()}
+ * Število zdravil: ${registerData.steviloZdravil}
+ */
+
+import type { Zdravilo } from "../register/types/Zdravilo";
+
+export const seznamZdravil: Zdravilo[] = ${JSON.stringify(registerData.zdravila, null, 2)};
+`;
+
+	fs.writeFileSync(`${GENERATED_DIR}/seznamZdravil.ts`, content, "utf8");
+	console.log(`  Zapisano: ${GENERATED_DIR}/seznamZdravil.ts (${registerData.steviloZdravil} zdravil)`);
+}
+
+/**
+ * Generiraj AtcVet.ts
+ */
+export function generateAtcVet(): void {
+	console.log("Generiram AtcVet.ts...");
+
+	const atcvetData = JSON.parse(fs.readFileSync(ATCVET_JSON, "utf8")) as AtcvetFile;
+
+	const content = `/**
+ * ATCVet klasifikacija
+ *
+ * Generirano: ${new Date().toISOString()}
+ * Število kod: ${atcvetData.meta.count}
+ * Vir: ${atcvetData.meta.source}
+ */
+
+import type { AtcvetRow } from "../atcvet/types/AtcvetFile";
+
+export const AtcVet: AtcvetRow[] = ${JSON.stringify(atcvetData.rows, null, 2)};
+`;
+
+	fs.writeFileSync(`${GENERATED_DIR}/AtcVet.ts`, content, "utf8");
+	console.log(`  Zapisano: ${GENERATED_DIR}/AtcVet.ts (${atcvetData.meta.count} kod)`);
+}
+
+async function main() {
+	console.log("═══════════════════════════════════════════════════════════════");
+	console.log("              GENERIRANJE TYPESCRIPT DATOTEK");
+	console.log("═══════════════════════════════════════════════════════════════\n");
+
+	// Preveri, da JSON datoteke obstajajo
+	if (!fs.existsSync(REGISTER_JSON)) {
+		console.error(`Napaka: ${REGISTER_JSON} ne obstaja. Najprej izvedi 'bun run import:all'.`);
+		process.exit(1);
+	}
+	if (!fs.existsSync(ATCVET_JSON)) {
+		console.error(`Napaka: ${ATCVET_JSON} ne obstaja. Najprej izvedi 'bun run import:all'.`);
+		process.exit(1);
+	}
+
+	ensureGeneratedDir();
+
+	generateRegisterZdravil();
+	generateAtcVet();
+
+	console.log("\n═══════════════════════════════════════════════════════════════");
+	console.log("                         KONČANO");
+	console.log("═══════════════════════════════════════════════════════════════\n");
+}
+
+if (import.meta.main) {
+	main().catch((e) => {
+		console.error("Napaka:", e);
+		process.exit(1);
+	});
+}