cry-vetzdravila 1.0.0

package/src/register/parseRegister.ts

@@ -0,0 +1,464 @@
+/**
+ * Parsanje xlsx datoteke registra veterinarskih zdravil
+ */
+
+import * as XLSX from "xlsx";
+import { Register } from "./types/RegisterRaw";
+import { Zdravilo, XLSX_COLUMNS } from "./types/Zdravilo";
+import { UcinkovinaZdravila } from "./types/UcinkovinaZdravila";
+import { PotUporabeZdravila } from "./types/PotUporabeZdravila";
+import { KarencaZdravila } from "./types/KarencaZdravila";
+import { ZivalskeVrste } from "./types/ZivalskeVrste";
+import { MozneKarenceZa } from "cry-klikvet-logic";
+import { findNadrejenaVrsta, normalizeVrsta } from "./helper/poisciZivalskoVrsto";
+import { zdraviloJeVakcinaZa } from "./zdraviloJeVakcinaZa";
+import { hashString } from "./helper/hashString";
+
+type XlsxRow = (string | number | undefined)[];
+
+/**
+ * Parsanje niza z ločilom "-N\" kjer je N številka
+ * Primer: " -1\vrednost1  -2\vrednost2" => ["vrednost1", "vrednost2"]
+ */
+function parseNumberedList(value: string | undefined): string[] {
+	if (!value || typeof value !== "string") return [];
+
+	const items: string[] = [];
+	// Poišči vse vrednosti med -N\ in naslednjim -N\ ali koncem niza
+	const regex = /-\d+\\([^-]*?)(?=-\d+\\|$)/g;
+	let match;
+
+	while ((match = regex.exec(value)) !== null) {
+		const item = match[1].trim();
+		if (item && item !== "null") {
+			items.push(item);
+		}
+	}
+
+	return items;
+}
+
+/**
+ * Parsanje učinkovin iz stolpcev xlsx
+ */
+function parseUcinkovine(
+	ucinkovineStr: string | undefined,
+	kolicineStr: string | undefined,
+	dodatneInfoStr: string | undefined
+): UcinkovinaZdravila[] {
+	const ucinkovine: UcinkovinaZdravila[] = [];
+
+	if (!ucinkovineStr) return ucinkovine;
+
+	// Parsiraj vse tri stolpce
+	const ucinkList = parseNumberedList(ucinkovineStr);
+	const kolList = parseNumberedList(kolicineStr);
+	const dodatneList = parseNumberedList(dodatneInfoStr);
+
+	for (let i = 0; i < ucinkList.length; i++) {
+		const ucinkovina = ucinkList[i];
+		const kolicinaRaw = kolList[i] || "";
+		const dodatneInfo = dodatneList[i];
+
+		// Parsiraj količino in enoto (npr. "200,0 mg" => 200.0, "mg")
+		const kolMatch = kolicinaRaw.match(/^([\d,\.]+)\s*(.*)$/);
+		let kolicina: number | undefined;
+		let enota = "";
+
+		if (kolMatch) {
+			// Zamenjaj vejico s piko za decimalno število
+			kolicina = parseFloat(kolMatch[1].replace(",", "."));
+			enota = kolMatch[2].trim();
+		}
+
+		ucinkovine.push({
+			ucinkovina,
+			kolicina,
+			enota,
+			dodatneInformacije: dodatneInfo && dodatneInfo !== "null" ? dodatneInfo : undefined,
+		});
+	}
+
+	return ucinkovine;
+}
+
+/**
+ * Slovar za preslikavo ključnih besed v kodo poti uporabe
+ */
+const POTI_KODE_MAP: Record<string, string> = {
+	subkutana: "SC",
+	intramuskularna: "IM",
+	intravenska: "IV",
+	peroralna: "PO",
+	dermalna: "TOP",
+	kožna: "TOP",
+	"v vodo za pitje": "PO",
+	intramamilarna: "IMM",
+	intramamarna: "IMM",
+	inhalacijska: "INH",
+	okularna: "OC",
+	"v oko": "OC",
+	rektalna: "REC",
+	intrauterina: "IU",
+	intranazalna: "IN",
+	"v nos": "IN",
+	lokalna: "LOC",
+	transdermalna: "TD",
+};
+
+/**
+ * Izlušči kode iz opisa poti uporabe
+ * Primer: "Intramuskularna/subkutana uporaba" => ["IM", "SC"]
+ */
+function extractKodeFromOpis(opis: string): string[] {
+	const kode: string[] = [];
+	const opisLower = opis.toLowerCase();
+
+	for (const [keyword, koda] of Object.entries(POTI_KODE_MAP)) {
+		if (opisLower.includes(keyword)) {
+			if (!kode.includes(koda)) {
+				kode.push(koda);
+			}
+		}
+	}
+
+	return kode;
+}
+
+/**
+ * Parsanje poti uporabe
+ * Primer: "-1082\Intramuskularna/subkutana uporaba" => { sifra: 1082, opis: "Intramuskularna/subkutana uporaba", koda: ["IM", "SC"] }
+ */
+function parsePotiUporabe(value: string | undefined): PotUporabeZdravila[] {
+	if (!value || typeof value !== "string") return [];
+
+	const poti: PotUporabeZdravila[] = [];
+	// Format: -SIFRA\Opis
+	const regex = /-(\d+)\\([^-]*?)(?=-\d+\\|$)/g;
+	let match;
+
+	while ((match = regex.exec(value)) !== null) {
+		const sifra = parseInt(match[1]);
+		const opis = match[2].trim();
+
+		poti.push({
+			sifra,
+			opis,
+			koda: extractKodeFromOpis(opis),
+		});
+	}
+
+	return poti;
+}
+
+
+/**
+ * Parsanje ciljnih živalskih vrst
+ * Primer: " -1\ #Govedo  -2\ #Prašiči" => ["govedo", "prašiči"]
+ */
+function parseCiljneVrste(value: string | undefined): string[] {
+	const vrste = parseNumberedList(value);
+	return [...new Set(vrste.map(normalizeVrsta))]; // Unikatne vrednosti
+}
+
+/**
+ * Parsanje ene karence
+ * Format: "507-piščanci (matične jate)\60-meso in organi\28,0\dni\null"
+ * ali: "-#Govedo\60-meso in organi\89,0\dni\null"
+ */
+function parseKarenca(value: string | undefined): KarencaZdravila | null {
+	if (!value || typeof value !== "string" || value.trim() === "") return null;
+
+	const parts = value.split("\\");
+	if (parts.length < 3) return null;
+
+	// Prvi del: vrsta (lahko s šifro, npr. "507-piščanci" ali "-#Govedo")
+	const vrstaPart = parts[0];
+	let vrsta = vrstaPart;
+
+	// Odstrani morebitno šifro na začetku (npr. "507-" ali "-#")
+	const vrstaMatch = vrstaPart.match(/^-?#?(\d*-)?(.+)$/);
+	if (vrstaMatch) {
+		vrsta = vrstaMatch[2];
+	}
+	vrsta = normalizeVrsta(vrsta);
+
+	// Drugi del: karenca za (npr. "60-meso in organi" ali "30-mleko")
+	const karencaZaPart = parts[1];
+	const karencaMatch = karencaZaPart.match(/^(\d+)-(.+)$/);
+
+	if (!karencaMatch) return null;
+
+	const karencaZaKoda = karencaMatch[1];
+	const karencaZaOpis = karencaMatch[2];
+
+	// Tretji del: vrednost (npr. "28,0" ali "null")
+	const vrednostStr = parts[2];
+	if (vrednostStr === "null" || vrednostStr.trim() === "") return null;
+
+	const vrednost = parseFloat(vrednostStr.replace(",", "."));
+	if (isNaN(vrednost)) return null;
+
+	// Preslikaj karencaZa v ustrezen ključ
+	const karencaZaMap: Record<string, MozneKarenceZa> = {
+		"meso in organi": "meso",
+		meso: "meso",
+		mleko: "mleko",
+		jajca: "jajca",
+		med: "med",
+	};
+
+	const karencaZa = karencaZaMap[karencaZaOpis.toLowerCase()] || ("meso" as MozneKarenceZa);
+
+	// Poskusi najti vrsto v ZivalskeVrste
+	// ZivalskeVrste je objekt z objekti, ki imajo lastnost "vrsta" in "_match" regex
+	const vrstaKey = Object.keys(ZivalskeVrste).find((k) => {
+		const vrstaDef = ZivalskeVrste[k as keyof typeof ZivalskeVrste];
+		if (!vrstaDef) return false;
+
+		// Preveri po ključu
+		if (k.toLowerCase() === vrsta) return true;
+
+		// Preveri po regex _match če obstaja
+		if (vrstaDef._match && vrstaDef._match.test(vrsta)) return true;
+
+		// Preveri po lastnosti vrsta
+		if (typeof vrstaDef.vrsta === "string" && vrstaDef.vrsta.toLowerCase() === vrsta) return true;
+
+		return false;
+	});
+
+	return {
+		vrsta: (vrstaKey as keyof typeof ZivalskeVrste) || (vrsta as keyof typeof ZivalskeVrste),
+		karence: {
+			[karencaZa]: vrednost,
+		},
+	};
+}
+
+
+/**
+ * Združi karence za isto vrsto in dodaj nadrejene vrste
+ */
+function mergeKarence(karence: (KarencaZdravila | null)[]): KarencaZdravila[] {
+	const merged = new Map<string, KarencaZdravila>();
+
+	for (const k of karence) {
+		if (!k) continue;
+
+		const key = `${k.vrsta}-${k.pot || ""}`;
+		const existing = merged.get(key);
+
+		if (existing) {
+			// Združi karence
+			existing.karence = { ...existing.karence, ...k.karence };
+		} else {
+			merged.set(key, { ...k });
+		}
+	}
+
+	// Dodaj nadrejene vrste
+	const result = Array.from(merged.values());
+	const toAdd: KarencaZdravila[] = [];
+
+	for (const karenca of result) {
+		const nadrejena = findNadrejenaVrsta(karenca.vrsta);
+		if (nadrejena) {
+			const nadrejenaKey = `${nadrejena}-${karenca.pot || ""}`;
+			// Dodaj nadrejeno samo če še ne obstaja
+			if (!merged.has(nadrejenaKey)) {
+				toAdd.push({
+					vrsta: nadrejena as keyof typeof ZivalskeVrste,
+					pot: karenca.pot,
+					karence: { ...karenca.karence },
+				});
+				merged.set(nadrejenaKey, toAdd[toAdd.length - 1]);
+			} else {
+				// Združi karence z obstoječo nadrejeno vrsto
+				const existing = merged.get(nadrejenaKey)!;
+				existing.karence = { ...existing.karence, ...karenca.karence };
+			}
+		}
+	}
+
+	return [...result, ...toAdd];
+}
+
+/**
+ * Parsanje pomožnih snovi
+ */
+function parsePomocneSnovi(value: string | undefined): string[] {
+	if (!value || typeof value !== "string") return [];
+
+	// Format: -1\snov1-2\snov2
+	const snovi: string[] = [];
+	const regex = /-\d+\\([^-]*?)(?=-\d+\\|$)/g;
+	let match;
+
+	while ((match = regex.exec(value)) !== null) {
+		const snov = match[1].trim();
+		if (snov) {
+			snovi.push(snov);
+		}
+	}
+
+	return snovi;
+}
+
+/**
+ * Parsanje Excel datuma (serijsko število) v string YYYY-MM-DD
+ */
+function parseExcelDate(value: number | string | undefined): string | null {
+	if (value === undefined || value === null) return null;
+
+	let date: Date | null = null;
+
+	if (typeof value === "number") {
+		// Excel serijski datum (dni od 1. januarja 1900)
+		const excelEpoch = new Date(1899, 11, 30); // 30. december 1899
+		date = new Date(excelEpoch.getTime() + value * 24 * 60 * 60 * 1000);
+	} else if (typeof value === "string") {
+		date = new Date(value);
+		if (isNaN(date.getTime())) return null;
+	}
+
+	if (!date) return null;
+
+	// Format YYYY-MM-DD
+	const year = date.getFullYear();
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	return `${year}-${month}-${day}`;
+}
+
+/**
+ * Parsanje ene vrstice xlsx v Zdravilo objekt
+ */
+function parseRow(row: XlsxRow): Zdravilo {
+	const getString = (idx: number): string => {
+		const val = row[idx];
+		return typeof val === "string" ? val.trim() : String(val ?? "");
+	};
+
+	// Parsiraj karence (stolpci 16-54)
+	const karenceRaw: (KarencaZdravila | null)[] = [];
+	for (let i = XLSX_COLUMNS.KARENCA_START; i <= XLSX_COLUMNS.KARENCA_END; i++) {
+		karenceRaw.push(parseKarenca(getString(i)));
+	}
+
+	const zdravilo: Zdravilo = {
+		id: hashString(getString(XLSX_COLUMNS.IME_ZDRAVILA))!,
+		ime: getString(XLSX_COLUMNS.IME_ZDRAVILA),
+		imetnikDovoljenja: getString(XLSX_COLUMNS.IMETNIK_DOVOLJENJA),
+		sproscanjeZdravila: getString(XLSX_COLUMNS.SPROSCANJE_ZDRAVILA),
+		stevilkaDovoljenja: getString(XLSX_COLUMNS.STEVILKA_DZP),
+		datumVeljavnosti: parseExcelDate(row[XLSX_COLUMNS.DATUM_VELJAVNOSTI]),
+		rezimIzdaje: getString(XLSX_COLUMNS.REZIM_IZDAJE),
+		atcKoda: getString(XLSX_COLUMNS.ATC),
+		potiUporabe: parsePotiUporabe(getString(XLSX_COLUMNS.POTI_UPORABE)),
+		farmacevtskaOblika: getString(XLSX_COLUMNS.FARMACEVTSKA_OBLIKA),
+		pakiranja: getString(XLSX_COLUMNS.PAKIRANJA),
+		enotaKolicine: getString(XLSX_COLUMNS.ENOTA_KOLICINE),
+		ucinkovine: parseUcinkovine(
+			getString(XLSX_COLUMNS.UCINKOVINE),
+			getString(XLSX_COLUMNS.KOLICINE_UCINKOVIN),
+			getString(XLSX_COLUMNS.UCINKOVINE_DODATNE_INFO)
+		),
+		pomocneSnovi: parsePomocneSnovi(getString(XLSX_COLUMNS.POMOCNE_SNOVI)),
+		ciljneVrste: parseCiljneVrste(getString(XLSX_COLUMNS.CILJNE_VRSTE)),
+		karence: mergeKarence(karenceRaw),
+	};
+
+	// Izpolni polje vakcinaZa če je zdravilo vakcina
+	const vakcinaZa = zdraviloJeVakcinaZa(zdravilo);
+	if (vakcinaZa) {
+		zdravilo.vakcinaZa = vakcinaZa;
+	}
+
+	return zdravilo;
+}
+
+/**
+ * Izlušči datum iz imena datoteke
+ * Primer: "20-11-2025.xlsx" => Date(2025, 10, 20)
+ */
+function parseDateFromFilename(filepath: string): Date {
+	const filename = filepath.split("/").pop() || "";
+	const match = filename.match(/(\d{1,2})-(\d{1,2})-(\d{4})\.xlsx/);
+
+	if (match) {
+		const [, day, month, year] = match;
+		return new Date(parseInt(year), parseInt(month) - 1, parseInt(day));
+	}
+
+	return new Date();
+}
+
+/**
+ * Glavna funkcija za parsanje xlsx datoteke v Register objekt
+ */
+export function parseRegister(filepath: string): Register {
+	console.log(`Parsiram datoteko: ${filepath}`);
+
+	const workbook = XLSX.readFile(filepath);
+	const sheetName = workbook.SheetNames[0];
+	const sheet = workbook.Sheets[sheetName];
+
+	const data = XLSX.utils.sheet_to_json<XlsxRow>(sheet, { header: 1 });
+
+	// Preskoči naslovno vrstico
+	const rows = data.slice(1);
+
+	console.log(`Najdenih ${rows.length} zdravil`);
+
+	const zdravila: Zdravilo[] = [];
+
+	for (const row of rows) {
+		// Preskoči prazne vrstice
+		if (!row[0]) continue;
+
+		try {
+			const zdravilo = parseRow(row);
+			zdravila.push(zdravilo);
+		} catch (error) {
+			console.error(`Napaka pri parsanju vrstice: ${row[0]}`, error);
+		}
+	}
+
+	console.log(`Uspešno parsanih ${zdravila.length} zdravil`);
+
+	return {
+		datumDatoteke: parseDateFromFilename(filepath),
+		datumParsanja: new Date(),
+		izvornaDateteka: filepath,
+		zdravila,
+		steviloZdravil: zdravila.length,
+	};
+}
+
+/**
+ * Shrani register v JSON datoteko
+ */
+export async function saveRegisterToJson(register: Register, outputPath: string): Promise<void> {
+	const json = JSON.stringify(register, null, 2);
+	await Bun.write(outputPath, json);
+	console.log(`Register shranjen v: ${outputPath}`);
+}
+
+// Če se izvaja direktno
+if (import.meta.main) {
+	const filepath = process.argv[2] || "./data/register.xlsx";
+
+	try {
+		const register = parseRegister(filepath);
+		console.log(`\nStatistika:`);
+		console.log(`  Število zdravil: ${register.steviloZdravil}`);
+		console.log(`  Datum datoteke: ${register.datumDatoteke.toLocaleDateString("sl-SI")}`);
+
+		// Shrani v JSON
+		await saveRegisterToJson(register, "./data/register.json");
+	} catch (error) {
+		console.error("Napaka:", error);
+		process.exit(1);
+	}
+}

package/src/register/podobnaZdravilaPoATC.ts

@@ -0,0 +1,71 @@
+import { seznamZdravil } from "../generated/seznamZdravil";
+import type { Zdravilo } from "./types/Zdravilo";
+import { uganiZdraviloInUtemelji } from "./uganiZdravilo";
+
+/**
+ * Dolžina ATCvet kode za vsak nivo
+ */
+const NIVO_DOLZINA: Record<number, number> = {
+	1: 2,  // QA
+	2: 4,  // QA01
+	3: 5,  // QA01A
+	4: 7,  // QA01AA
+	5: 8,  // QA01AA01
+};
+
+/**
+ * Vrne seznam zdravil, ki so na istem ATC nivoju `nivo` kot dano zdravilo.
+ *
+ * Vrnjeni seznam ne vsebuje zdravila samega.
+ *
+ * @param zdravilo Zdravilo, za katerega iščemo podobna zdravila
+ * @param nivo ATCvet nivo za primerjavo (1-5), privzeto 5 (kemijska učinkovina)
+ * @returns Seznam zdravil z enako ATCvet kodo na danem nivoju
+ * @example
+ * ```typescript
+ * // Poišči vsa zdravila z enako kemijsko podskupino (nivo 4)
+ * const podobna = podobnaZdravilaPoATC(mojeZdravilo, 4);
+ * ```
+ */
+export function podobnaZdravilaPoATC(zdravilo: Zdravilo, nivo = 5): Zdravilo[] {
+	const dolzina = NIVO_DOLZINA[nivo];
+	if (!dolzina) {
+		return [];
+	}
+
+	// Če zdravilo nima dovolj dolge ATC kode, vrni prazen seznam
+	if (!zdravilo.atcKoda || zdravilo.atcKoda.length < dolzina) {
+		return [];
+	}
+
+	const mojPrefiks = zdravilo.atcKoda.substring(0, dolzina);
+	const rezultat: Zdravilo[] = [];
+
+	for (const kandidat of seznamZdravil) {
+		// Preskoči isto zdravilo
+		if (kandidat.stevilkaDovoljenja === zdravilo.stevilkaDovoljenja) {
+			continue;
+		}
+
+		// Preveri ali ima kandidat enak prefiks
+		if (kandidat.atcKoda &&
+			kandidat.atcKoda.length >= dolzina &&
+			kandidat.atcKoda.substring(0, dolzina) === mojPrefiks) {
+			rezultat.push(kandidat);
+		}
+	}
+
+	// Uredi po podobnosti z vhodnim zdravilom
+	if (rezultat.length === 0) {
+		return [];
+	}
+
+	const isciMed = rezultat.map(z => z.id);
+	const urejeni = uganiZdraviloInUtemelji(zdravilo.ime, {
+		minOcena: 0,
+		isciMed,
+		limit: rezultat.length
+	});
+
+	return urejeni.map(r => r.zdravilo);
+}

package/src/register/podobnaZdravilaPoUcinkovinah.ts

@@ -0,0 +1,136 @@
+import { AtcVet } from "../generated/AtcVet";
+import { seznamZdravil } from "../generated/seznamZdravil";
+import type { Zdravilo } from "./types/Zdravilo";
+import { uganiZdraviloInUtemelji } from "./uganiZdravilo";
+
+/**
+ * Cache za ATCvet kode na nivoju 5 (kemijska učinkovina)
+ */
+let atcvetNivo5Cache: Map<string, string> | null = null;
+
+/**
+ * Pripravi cache ATCvet kod na nivoju 5
+ * Ključ je ATCvet koda, vrednost je slovenski opis (učinkovina)
+ */
+function pripraviAtcvetCache(): Map<string, string> {
+	if (atcvetNivo5Cache !== null) {
+		return atcvetNivo5Cache;
+	}
+
+	atcvetNivo5Cache = new Map();
+	for (const row of AtcVet) {
+		if (row.level === 5) {
+			atcvetNivo5Cache.set(row.code, row.desc_si.toLowerCase());
+		}
+	}
+
+	return atcvetNivo5Cache;
+}
+
+/**
+ * Normalizira ime učinkovine za primerjavo
+ */
+function normalizirajUcinkovino(ucinkovina: string): string {
+	return ucinkovina
+		.toLowerCase()
+		.trim()
+		.replace(/\s+/g, " ");
+}
+
+/**
+ * Vrne množico učinkovin za zdravilo iz registra
+ */
+function ucinkovineIzRegistra(zdravilo: Zdravilo): Set<string> {
+	const ucinkovine = new Set<string>();
+	for (const u of zdravilo.ucinkovine) {
+		ucinkovine.add(normalizirajUcinkovino(u.ucinkovina));
+	}
+	return ucinkovine;
+}
+
+/**
+ * Vrne učinkovino iz ATCvet kode na nivoju 5 (kemijska učinkovina)
+ */
+function ucinkovinaIzAtcvet(atcKoda: string): string | null {
+	const cache = pripraviAtcvetCache();
+	if (!atcKoda || atcKoda.length < 8) {
+		return null;
+	}
+	const koda = atcKoda.substring(0, 8);
+	const ucinkovina = cache.get(koda);
+	return ucinkovina ? normalizirajUcinkovino(ucinkovina) : null;
+}
+
+/**
+ * Vrne seznam zdravil, ki imajo vsaj eno učinkovino enako kot dano zdravilo.
+ *
+ * Podatek o učinkovinah pridobimo iz zdravila samega in mu dodamo učinkovine
+ * po nivoju 5 ATC tega zdravila. Enako storimo z vsemi zdravili Registra.
+ *
+ * Vrnjeni seznam ne vsebuje zdravila samega.
+ *
+ * @param zdravilo Zdravilo, za katerega iščemo zdravila s podobnimi učinkovinami.
+ * @returns Seznam zdravil z vsaj eno skupno učinkovino
+ * @example
+ * ```typescript
+ * // Poišči vsa zdravila z enako učinkovino
+ * const podobna = podobnaZdravilaPoUcinkovinah(mojeZdravilo);
+ * ```
+ */
+export function podobnaZdravilaPoUcinkovinah(zdravilo: Zdravilo): Zdravilo[] {
+	// Zberi učinkovine iz vhodnega zdravila
+	const mojeUcinkovine = ucinkovineIzRegistra(zdravilo);
+
+	// Dodaj učinkovino iz ATCvet kode (nivo 5)
+	const atcvetUcinkovina = ucinkovinaIzAtcvet(zdravilo.atcKoda);
+	if (atcvetUcinkovina) {
+		mojeUcinkovine.add(atcvetUcinkovina);
+	}
+
+	if (mojeUcinkovine.size === 0) {
+		return [];
+	}
+
+	const rezultat: Zdravilo[] = [];
+
+	for (const kandidat of seznamZdravil) {
+		// Preskoči isto zdravilo
+		if (kandidat.stevilkaDovoljenja === zdravilo.stevilkaDovoljenja) {
+			continue;
+		}
+
+		// Zberi učinkovine kandidata
+		const kandidatUcinkovine = ucinkovineIzRegistra(kandidat);
+		const kandidatAtcvetUcinkovina = ucinkovinaIzAtcvet(kandidat.atcKoda);
+		if (kandidatAtcvetUcinkovina) {
+			kandidatUcinkovine.add(kandidatAtcvetUcinkovina);
+		}
+
+		// Preveri ali ima kandidat vsaj eno skupno učinkovino
+		let imaSkupno = false;
+		for (const ucinkovina of mojeUcinkovine) {
+			if (kandidatUcinkovine.has(ucinkovina)) {
+				imaSkupno = true;
+				break;
+			}
+		}
+
+		if (imaSkupno) {
+			rezultat.push(kandidat);
+		}
+	}
+
+	// Uredi po podobnosti z vhodnim zdravilom
+	if (rezultat.length === 0) {
+		return [];
+	}
+
+	const isciMed = rezultat.map(z => z.id);
+	const urejeni = uganiZdraviloInUtemelji(zdravilo.ime, {
+		minOcena: 0,
+		isciMed,
+		limit: rezultat.length
+	});
+
+	return urejeni.map(r => r.zdravilo);
+}

package/src/register/registerZdravil.ts

@@ -0,0 +1,22 @@
+/**
+ * Seznam veterinarskih zdravil registriranih v Sloveniji
+ *
+ * Generirano: 2026-01-02T17:40:16.336Z
+ * Število zdravil: 879
+ */
+
+import type { RegisterZdravil } from "..";
+import type { Zdravilo } from "./types/Zdravilo";
+import { seznamZdravil } from "../generated/seznamZdravil";
+
+const registerZdravil: RegisterZdravil = new Map<number, Zdravilo>();
+seznamZdravil.forEach(z => {
+	if (registerZdravil.has(z.id)) {
+		throw new Error(`registerZdravil: podvojen id zdravila ${z.id}`);
+	}
+	registerZdravil.set(z.id, z)
+});
+
+export { registerZdravil };
+
+