@osca16/slnic 0.1.0

package/README.md

@@ -0,0 +1,16 @@
+# Welcome to the my Package
+
+This Package Contains Sri Lankan NIC Validiator..If you wish to add Sri Lankan NIC validation to your web site or node.js base development this is for you.
+
+Prerequisites
+#Ensure Your minimum node enviroment upto 18+
+#Ensure your development language is javascript (typescript available soon).
+#if you have any error or additiones please let me know from my git or following my social accounts.
+#enjoy the package
+
+installation and usage
+
+#npm install or npm init -y
+#npm install @srilanka-nic-validator/slnic-js (for install package)
+
+Thankyou!

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@osca16/slnic",
+  "version": "0.1.0",
+  "description": "Sri Lankan NIC parser + optional OCR & PDF417 barcode verification (Sinhala/Tamil/English) – pure JavaScript",
+  "keywords": ["sri lanka", "nic", "ocr", "pdf417", "barcode", "sinhala", "tamil"],
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./src/index.js"
+    }
+  },
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "files": ["src", "README.md", "LICENSE"],
+  "sideEffects": false,
+  "scripts": {
+    "test": "node -e \"import('./src/index.js').then(m=>console.log('OK', Object.keys(m)))\"",
+    "prepublishOnly": "node -e \"console.log('building… (no build step for JS)')\""
+  }
+}

package/src/barcode.js

@@ -0,0 +1,73 @@
+import { BrowserPDF417Reader, HTMLCanvasElementLuminanceSource, HybridBinarizer, BinaryBitmap } from "@zxing/library";
+
+async function toCanvas(input) {
+  if (input instanceof HTMLCanvasElement) return input;
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+
+  let bitmap;
+  if (input instanceof Blob) {
+    bitmap = await createImageBitmap(input);
+  } else {
+    bitmap = await createImageBitmap(input);
+  }
+  canvas.width = bitmap.width;
+  canvas.height = bitmap.height;
+  ctx.drawImage(bitmap, 0, 0);
+  return canvas;
+}
+
+export async function decodeBackBarcode(image) {
+  const reader = new BrowserPDF417Reader();
+  const canvas = await toCanvas(image);
+
+  try {
+    const source = new HTMLCanvasElementLuminanceSource(canvas);
+    const bitmap = new BinaryBitmap(new HybridBinarizer(source));
+    const result = reader.decodeBitmap(bitmap);
+
+    const raw = result.getText();
+    return { decoded: true, raw, fields: parseKeyValues(raw) };
+  } catch {
+    // Try fallback decodeFromImage if available
+    try {
+      const result = await reader.decodeFromImage(undefined, canvas);
+      const raw = result.getText();
+      return { decoded: true, raw, fields: parseKeyValues(raw) };
+    } catch {
+      return { decoded: false };
+    }
+  }
+}
+
+function parseKeyValues(raw) {
+  const fields = {};
+  (raw || "")
+    .split(/\r?\n|;|\|/)
+    .map((s) => s.trim())
+    .forEach((line) => {
+      const m = line.match(/^([A-Za-z_]+)\s*[:=]\s*(.+)$/);
+      if (m) fields[m[1].toLowerCase()] = m[2];
+    });
+  return fields;
+}
+
+function normalizeNic(s) {
+  return (s || "").toUpperCase().replace(/\s+/g, "");
+}
+
+/** Compare decoded barcode fields vs parsed NIC object { nic, birthDateISO } */
+export function compareBarcodeAndParsed(barcode, parsed) {
+  if (!barcode || !barcode.decoded) return false;
+  const fields = barcode.fields || {};
+
+  const nicFromBarcode = normalizeNic(fields.nic || fields.id || fields.nid);
+  const nicMatch = nicFromBarcode ? nicFromBarcode === normalizeNic(parsed.nic) : true;
+
+  const dobFromBarcode = fields.dob || fields.dateofbirth || fields.birthdate;
+  const dobMatch = dobFromBarcode
+    ? [dobFromBarcode, dobFromBarcode.replaceAll("/", "-")].some((v) => (parsed.birthDateISO || "").startsWith(v))
+    : true;
+
+  return nicMatch && dobMatch;
+}

package/src/face.js

@@ -0,0 +1,5 @@
+// Later: plug in onnxruntime-web + ArcFace embeddings.
+// For now we return undefined similarity so it doesn't block verification.
+export async function compareFaces(_frontImage, _selfieImage) {
+  return { similarity: undefined, livenessPassed: false };
+}

package/src/index.js

@@ -0,0 +1,73 @@
+export { parseSriLankaNIC, formatNicDetails } from "./validators.js";
+export { ocrNicFromImage } from "./ocr.js";
+export { decodeBackBarcode, compareBarcodeAndParsed } from "./barcode.js";
+export { compareFaces } from "./face.js";
+
+/**
+ * High-level helper (front/back/selfie are optional; returns best-effort).
+ * frontImage/backImage/selfieImage: Blob | HTMLImageElement | HTMLCanvasElement
+ * languages: ["en-LK","si-LK","ta-LK"]
+ */
+export async function verifyNicFromImages(opts = {}) {
+  const { frontImage, backImage, selfieImage, languages = ["en-LK", "si-LK", "ta-LK"] } = opts;
+
+  const reasons = [];
+  const result = { decision: "insufficient", reasons };
+
+  // 1) OCR + parse
+  if (frontImage) {
+    try {
+      const ocr = await (await import("./ocr.js")).ocrNicFromImage(frontImage, languages);
+      result.ocr = ocr;
+      if (ocr.nicText) {
+        const parsed = (await import("./validators.js")).parseSriLankaNIC(ocr.nicText);
+        result.nic = parsed;
+        if (!parsed.valid) reasons.push("NIC pattern/DOB invalid");
+      } else {
+        reasons.push("Could not read NIC number via OCR");
+      }
+    } catch (e) {
+      reasons.push("OCR failed");
+    }
+  }
+
+  // 2) Barcode decode + compare
+  if (backImage) {
+    try {
+      const barcode = await (await import("./barcode.js")).decodeBackBarcode(backImage);
+      result.barcode = barcode;
+      if (barcode.decoded && result.nic) {
+        const ok = (await import("./barcode.js")).compareBarcodeAndParsed(barcode, result.nic);
+        if (!ok) reasons.push("Barcode data does not match OCR/parsed NIC");
+      } else if (!barcode.decoded) {
+        reasons.push("Could not decode NIC barcode");
+      }
+    } catch {
+      reasons.push("Barcode decode failed");
+    }
+  }
+
+  // 3) Face compare (placeholder)
+  if (frontImage && selfieImage) {
+    try {
+      const face = await (await import("./face.js")).compareFaces(frontImage, selfieImage);
+      result.face = face;
+      if (typeof face.similarity === "number" && face.similarity < 0.4) {
+        reasons.push("Face similarity below threshold");
+      }
+    } catch {
+      reasons.push("Face compare failed");
+    }
+  }
+
+  // Decision
+  const nicValid = result.nic && result.nic.valid;
+  const barcodeOK = result.barcode?.decoded ? !reasons.includes("Barcode data does not match OCR/parsed NIC") : true;
+  const faceOK = result.face?.similarity === undefined || result.face.similarity >= 0.4;
+
+  if (nicValid && barcodeOK && faceOK) result.decision = "verified";
+  else if (reasons.length > 0) result.decision = "mismatch";
+  else result.decision = "insufficient";
+
+  return result;
+}

package/src/ocr.js

@@ -0,0 +1,48 @@
+import Tesseract from "tesseract.js";
+
+async function toCanvas(input) {
+  if (input instanceof HTMLCanvasElement) return input;
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+
+  let bitmap;
+  if (input instanceof Blob) {
+    bitmap = await createImageBitmap(input);
+  } else {
+    // HTMLImageElement
+    bitmap = await createImageBitmap(input);
+  }
+  canvas.width = bitmap.width;
+  canvas.height = bitmap.height;
+  ctx.drawImage(bitmap, 0, 0);
+  return canvas;
+}
+
+/**
+ * languages: array of locales ["en-LK","si-LK","ta-LK"]
+ */
+export async function ocrNicFromImage(image, languages = ["en-LK", "si-LK", "ta-LK"]) {
+  const canvas = await toCanvas(image);
+  const langMap = { "en-LK": "eng", "si-LK": "sin", "ta-LK": "tam" };
+  const langs = languages.map((l) => langMap[l]).join("+");
+
+  const { data } = await Tesseract.recognize(canvas, langs, {
+    tessedit_char_whitelist: "0123456789VvXxABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/-. :"
+  });
+
+  const text = (data.text || "").replace(/\s+/g, " ").trim();
+
+  const nicMatch =
+    text.match(/\b\d{12}\b/) ||      // new
+    text.match(/\b\d{9}[VvXx]\b/);   // old
+
+  const nameMatch = text.match(/Name[:\s]+([A-Za-z .]+)/i);
+  const dobMatch = text.match(/(DOB|Date of Birth)[:\s]+([0-9]{4}-[0-9]{2}-[0-9]{2}|[0-9]{2}[-/][0-9]{2}[-/][0-9]{4})/i);
+
+  return {
+    nicText: nicMatch ? nicMatch[0] : undefined,
+    name: nameMatch ? nameMatch[1].trim() : undefined,
+    dobText: dobMatch ? dobMatch[2] : undefined,
+    confidence: data.confidence
+  };
+}

package/src/validators.js

@@ -0,0 +1,53 @@
+const OLD_RE = /^(\d{2})(\d{3})(\d{3})(\d)([VvXx])$/; // YY DDD SSS C L
+const NEW_RE = /^(\d{4})(\d{3})(\d{4})(\d)$/;         // YYYY DDD SSSS C
+
+function isLeapYear(y) {
+  return (y % 4 === 0 && y % 100 !== 0) || (y % 400 === 0);
+}
+function dayOfYearToDate(year, doy) {
+  if (doy < 1 || doy > (isLeapYear(year) ? 366 : 365)) return null;
+  const d = new Date(Date.UTC(year, 0, 1));
+  d.setUTCDate(d.getUTCDate() + (doy - 1));
+  return d.toISOString().slice(0, 10);
+}
+
+export function parseSriLankaNIC(input) {
+  const nic = (input || "").toString().replace(/\s+/g, "");
+  let m = nic.match(NEW_RE);
+  if (m) {
+    const year = parseInt(m[1], 10);
+    let ddd = parseInt(m[2], 10);
+    const female = ddd >= 500;
+    if (female) ddd -= 500;
+    const birthISO = dayOfYearToDate(year, ddd);
+    if (!birthISO) return { valid: false, format: "new", nic, message: "Invalid day-of-year." };
+    return { valid: true, format: "new", nic, gender: female ? "female" : "male", birthDateISO: birthISO, birthYear: year, dayOfYear: ddd };
+  }
+  m = nic.match(OLD_RE);
+  if (m) {
+    const year = 1900 + parseInt(m[1], 10);
+    let ddd = parseInt(m[2], 10);
+    const female = ddd >= 500;
+    if (female) ddd -= 500;
+    const birthISO = dayOfYearToDate(year, ddd);
+    if (!birthISO) return { valid: false, format: "old", nic, message: "Invalid day-of-year." };
+    return { valid: true, format: "old", nic, gender: female ? "female" : "male", birthDateISO: birthISO, birthYear: year, dayOfYear: ddd };
+  }
+  return { valid: false, format: null, nic, message: "Does not match old or new NIC patterns." };
+}
+
+export function formatNicDetails(details, locale = "en-LK") {
+  if (!details || !details.valid || !details.birthDateISO) return details;
+  const dt = new Date(details.birthDateISO + "T00:00:00Z");
+  const df = new Intl.DateTimeFormat(locale, { year: "numeric", month: "long", day: "numeric" });
+  const genderLabels = {
+    "en-LK": { male: "Male", female: "Female" },
+    "si-LK": { male: "පුරුෂ", female: "ස්ත්‍රී" },
+    "ta-LK": { male: "ஆண்", female: "பெண்" }
+  };
+  return {
+    ...details,
+    birthDateLocalized: df.format(dt),
+    genderLocalized: details.gender ? genderLabels[locale][details.gender] : undefined
+  };
+}