indycheck 0.2.0 → 0.2.1

package/dist/native.d.ts

@@ -0,0 +1,122 @@
+/**
+ * indycheck — optional native (napi-rs) backend.
+ *
+ * Same public API as the pure-TypeScript mirror in `./index`, but the
+ * validation itself runs in the compiled Rust core through the
+ * napi-rs addon in `crates/indycheck-napi` instead of the TypeScript
+ * re-implementation. The addon is optional: when it is not built (or
+ * cannot be loaded) every function below falls back to `./index`
+ * silently, so the package works with no native code at all.
+ *
+ * How it loads: `isNativeAvailable()` tries, in order,
+ *  1. `INDYCHECK_NATIVE_PATH` — a path to the addon's `index.js` (or
+ *     directly to a `.node` file), when the env var is set;
+ *  2. `crates/indycheck-napi/index.js` relative to this file (works
+ *     from both `src/` under vitest and `dist/`);
+ *  3. the same path found by walking up from the current working
+ *     directory to a repo checkout.
+ * The `.node` binary itself is never committed to the repo — build it
+ * with `npm run build` in `crates/indycheck-napi` (see its README).
+ *
+ * Shape note: the Rust wrappers return JSON strings (see
+ * `crates/indycheck-napi/src/lib.rs`); they are parsed here into the
+ * same `{ valid, code, reason_en, reason_hi, parsed }` objects the
+ * TypeScript implementation returns. `detect` in Rust returns only
+ * the type string ("pan" | "aadhaar" | ... | "unknown"), so the
+ * `ValidationResult<DetectParsed>` shape is rebuilt here from the
+ * native type + the matching native validator, exactly like
+ * `detect` in `./index`. `validateMany` in Rust returns a bare
+ * `ValidationResult[]` (one per input, in order); the
+ * `input` / `type` / totals wrapper is rebuilt here with the same
+ * `VALID` / `SOME_INVALID` codes and reason strings as `./index`.
+ * The `*WithOptions` variants have no native equivalent (the Rust
+ * core's options live behind different entry points), so they always
+ * use the TypeScript implementation.
+ *
+ * Every function here never throws on bad input, like `./index`.
+ */
+import type { AadhaarParsed, CinParsed, DetectParsed, GstinParsed, IfscParsed, LlpinParsed, MobileParsed, PincodeParsed, TanParsed, UpiParsed, ValidateManyParsed, ValidationResult, VehicleParsed, VoterParsed } from "./index";
+import * as tsImpl from "./index";
+import type { PanParsed } from "./index";
+/** `true` when the native addon loaded and can be used. */
+export declare function isNativeAvailable(): boolean;
+/** Which backend the functions below are currently using. */
+export declare function backend(): "native" | "typescript";
+export declare function validatePan(input: unknown): ValidationResult<PanParsed>;
+export declare function validateAadhaar(input: unknown): ValidationResult<AadhaarParsed>;
+export declare function validateGstin(input: unknown): ValidationResult<GstinParsed>;
+export declare function validateIfsc(input: unknown): ValidationResult<IfscParsed>;
+export declare function validateUpi(input: unknown): ValidationResult<UpiParsed>;
+export declare function validateMobile(input: unknown): ValidationResult<MobileParsed>;
+export declare function validatePincode(input: unknown): ValidationResult<PincodeParsed>;
+export declare function validateTan(input: unknown): ValidationResult<TanParsed>;
+export declare function validateCin(input: unknown): ValidationResult<CinParsed>;
+export declare function validateLlpin(input: unknown): ValidationResult<LlpinParsed>;
+export declare function validateVoterId(input: unknown): ValidationResult<VoterParsed>;
+/** Alias for `validateVoterId`: EPIC is the name printed on the card. */
+export declare function validateEpic(input: unknown): ValidationResult<VoterParsed>;
+export declare function validateVehicle(input: unknown): ValidationResult<VehicleParsed>;
+/** Alias for `validateVehicle`. */
+export declare function validateVehicleRegistration(input: unknown): ValidationResult<VehicleParsed>;
+/** The Rust `detect` string for a trimmed input. */
+export declare function detectType(input: string): string;
+export declare function detect(input: unknown): ValidationResult<DetectParsed>;
+export declare function validateMany(inputs: unknown): ValidationResult<ValidateManyParsed>;
+export declare function formatMobile(input: unknown): ValidationResult<MobileParsed>;
+export declare function formatPan(input: unknown): string | null;
+export declare function formatGstin(input: unknown): string | null;
+export declare function maskAadhaar(input: unknown): ValidationResult<AadhaarParsed>;
+export declare function maskPan(input: unknown): string;
+export declare function maskMobile(input: unknown): string;
+export declare function generatePan(entity?: unknown): string;
+export declare function generateAadhaar(): string;
+export declare function generateGstin(stateCode?: unknown): string;
+export declare function generateMobile(): string;
+export declare const validateMobileWithOptions: typeof tsImpl.validateMobileWithOptions;
+export declare const validatePanWithOptions: typeof tsImpl.validatePanWithOptions;
+export declare const validateAadhaarWithOptions: typeof tsImpl.validateAadhaarWithOptions;
+export declare const validateGstinWithOptions: typeof tsImpl.validateGstinWithOptions;
+export declare const formatMobileWithOptions: typeof tsImpl.formatMobileWithOptions;
+export declare const defaultOptions: typeof tsImpl.defaultOptions;
+export declare const lenientOptions: typeof tsImpl.lenientOptions;
+export declare const noSpacesHyphensOptions: typeof tsImpl.noSpacesHyphensOptions;
+declare const _default: {
+    backend: typeof backend;
+    isNativeAvailable: typeof isNativeAvailable;
+    validateMobile: typeof validateMobile;
+    validatePan: typeof validatePan;
+    validateAadhaar: typeof validateAadhaar;
+    validateGstin: typeof validateGstin;
+    validateIfsc: typeof validateIfsc;
+    validateUpi: typeof validateUpi;
+    validatePincode: typeof validatePincode;
+    validateTan: typeof validateTan;
+    validateCin: typeof validateCin;
+    validateLlpin: typeof validateLlpin;
+    validateVoterId: typeof validateVoterId;
+    validateEpic: typeof validateEpic;
+    validateVehicle: typeof validateVehicle;
+    validateVehicleRegistration: typeof validateVehicleRegistration;
+    validateMobileWithOptions: typeof tsImpl.validateMobileWithOptions;
+    validatePanWithOptions: typeof tsImpl.validatePanWithOptions;
+    validateAadhaarWithOptions: typeof tsImpl.validateAadhaarWithOptions;
+    validateGstinWithOptions: typeof tsImpl.validateGstinWithOptions;
+    formatMobile: typeof formatMobile;
+    formatMobileWithOptions: typeof tsImpl.formatMobileWithOptions;
+    formatPan: typeof formatPan;
+    formatGstin: typeof formatGstin;
+    maskAadhaar: typeof maskAadhaar;
+    maskPan: typeof maskPan;
+    maskMobile: typeof maskMobile;
+    generatePan: typeof generatePan;
+    generateAadhaar: typeof generateAadhaar;
+    generateGstin: typeof generateGstin;
+    generateMobile: typeof generateMobile;
+    defaultOptions: typeof tsImpl.defaultOptions;
+    lenientOptions: typeof tsImpl.lenientOptions;
+    noSpacesHyphensOptions: typeof tsImpl.noSpacesHyphensOptions;
+    detect: typeof detect;
+    detectType: typeof detectType;
+    validateMany: typeof validateMany;
+};
+export default _default;

package/dist/native.js

@@ -0,0 +1,518 @@
+"use strict";
+/**
+ * indycheck — optional native (napi-rs) backend.
+ *
+ * Same public API as the pure-TypeScript mirror in `./index`, but the
+ * validation itself runs in the compiled Rust core through the
+ * napi-rs addon in `crates/indycheck-napi` instead of the TypeScript
+ * re-implementation. The addon is optional: when it is not built (or
+ * cannot be loaded) every function below falls back to `./index`
+ * silently, so the package works with no native code at all.
+ *
+ * How it loads: `isNativeAvailable()` tries, in order,
+ *  1. `INDYCHECK_NATIVE_PATH` — a path to the addon's `index.js` (or
+ *     directly to a `.node` file), when the env var is set;
+ *  2. `crates/indycheck-napi/index.js` relative to this file (works
+ *     from both `src/` under vitest and `dist/`);
+ *  3. the same path found by walking up from the current working
+ *     directory to a repo checkout.
+ * The `.node` binary itself is never committed to the repo — build it
+ * with `npm run build` in `crates/indycheck-napi` (see its README).
+ *
+ * Shape note: the Rust wrappers return JSON strings (see
+ * `crates/indycheck-napi/src/lib.rs`); they are parsed here into the
+ * same `{ valid, code, reason_en, reason_hi, parsed }` objects the
+ * TypeScript implementation returns. `detect` in Rust returns only
+ * the type string ("pan" | "aadhaar" | ... | "unknown"), so the
+ * `ValidationResult<DetectParsed>` shape is rebuilt here from the
+ * native type + the matching native validator, exactly like
+ * `detect` in `./index`. `validateMany` in Rust returns a bare
+ * `ValidationResult[]` (one per input, in order); the
+ * `input` / `type` / totals wrapper is rebuilt here with the same
+ * `VALID` / `SOME_INVALID` codes and reason strings as `./index`.
+ * The `*WithOptions` variants have no native equivalent (the Rust
+ * core's options live behind different entry points), so they always
+ * use the TypeScript implementation.
+ *
+ * Every function here never throws on bad input, like `./index`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSpacesHyphensOptions = exports.lenientOptions = exports.defaultOptions = exports.formatMobileWithOptions = exports.validateGstinWithOptions = exports.validateAadhaarWithOptions = exports.validatePanWithOptions = exports.validateMobileWithOptions = void 0;
+exports.isNativeAvailable = isNativeAvailable;
+exports.backend = backend;
+exports.validatePan = validatePan;
+exports.validateAadhaar = validateAadhaar;
+exports.validateGstin = validateGstin;
+exports.validateIfsc = validateIfsc;
+exports.validateUpi = validateUpi;
+exports.validateMobile = validateMobile;
+exports.validatePincode = validatePincode;
+exports.validateTan = validateTan;
+exports.validateCin = validateCin;
+exports.validateLlpin = validateLlpin;
+exports.validateVoterId = validateVoterId;
+exports.validateEpic = validateEpic;
+exports.validateVehicle = validateVehicle;
+exports.validateVehicleRegistration = validateVehicleRegistration;
+exports.detectType = detectType;
+exports.detect = detect;
+exports.validateMany = validateMany;
+exports.formatMobile = formatMobile;
+exports.formatPan = formatPan;
+exports.formatGstin = formatGstin;
+exports.maskAadhaar = maskAadhaar;
+exports.maskPan = maskPan;
+exports.maskMobile = maskMobile;
+exports.generatePan = generatePan;
+exports.generateAadhaar = generateAadhaar;
+exports.generateGstin = generateGstin;
+exports.generateMobile = generateMobile;
+const node_module_1 = require("node:module");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const tsImpl = __importStar(require("./index"));
+const nativeRequire = (0, node_module_1.createRequire)((0, node_path_1.join)(process.cwd(), "package.json"));
+function bindingCandidates() {
+    const envPath = process.env.INDYCHECK_NATIVE_PATH;
+    // An explicit path is authoritative: if it cannot be loaded, the
+    // addon is treated as absent (TypeScript fallback) instead of
+    // silently loading a different binary.
+    if (envPath)
+        return [envPath];
+    const candidates = [];
+    // CommonJS: relative to this file (dist/ or src/ under packages/js).
+    if (typeof __dirname !== "undefined") {
+        candidates.push((0, node_path_1.join)(__dirname, "..", "..", "..", "crates", "indycheck-napi", "index.js"));
+    }
+    // Walk up from the working directory to a repo checkout (covers
+    // vitest, where __dirname is not defined, and `npm test` from anywhere).
+    let dir = process.cwd();
+    for (let i = 0; i < 6; i++) {
+        candidates.push((0, node_path_1.join)(dir, "crates", "indycheck-napi", "index.js"));
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return [...new Set(candidates)].filter((c) => (0, node_fs_1.existsSync)(c));
+}
+let binding = null;
+let attempted = false;
+function loadBinding() {
+    if (attempted)
+        return binding;
+    attempted = true;
+    for (const candidate of bindingCandidates()) {
+        try {
+            const mod = nativeRequire(candidate);
+            if (mod &&
+                typeof mod.validatePan === "function" &&
+                typeof mod.validateVehicle === "function" &&
+                typeof mod.detect === "function" &&
+                typeof mod.validateMany === "function") {
+                binding = mod;
+                break;
+            }
+        }
+        catch {
+            // Not built / not loadable here — try the next candidate.
+        }
+    }
+    return binding;
+}
+/** `true` when the native addon loaded and can be used. */
+function isNativeAvailable() {
+    return loadBinding() !== null;
+}
+/** Which backend the functions below are currently using. */
+function backend() {
+    return loadBinding() !== null ? "native" : "typescript";
+}
+// ---------------------------------------------------------------------------
+// Call helpers
+// ---------------------------------------------------------------------------
+/** Rust `ValidationResult::err` omits `parsed` from the JSON entirely
+ *  (serde `skip_serializing_if`), while the TS mirror sets it to
+ *  `null` — normalise so both backends return identical shapes. */
+function normalizeResult(r) {
+    if (r.parsed === undefined)
+        r.parsed = null;
+    return r;
+}
+/** Run a native call that returns a JSON `ValidationResult`; on any
+ *  failure (missing addon, bad JSON) use the TypeScript fallback. */
+function callJson(fn, fallback) {
+    const b = loadBinding();
+    if (b === null)
+        return fallback();
+    try {
+        return normalizeResult(JSON.parse(fn(b)));
+    }
+    catch {
+        return fallback();
+    }
+}
+/** Run a native call returning a plain value; fall back on any failure. */
+function callPlain(fn, fallback) {
+    const b = loadBinding();
+    if (b === null)
+        return fallback();
+    try {
+        return fn(b);
+    }
+    catch {
+        return fallback();
+    }
+}
+/** Native validator for a `detect` type string, or null for "unknown". */
+function validateByNativeType(b, type, input) {
+    let json;
+    switch (type) {
+        case "pan":
+            json = b.validatePan(input);
+            break;
+        case "aadhaar":
+            json = b.validateAadhaar(input);
+            break;
+        case "gstin":
+            json = b.validateGstin(input);
+            break;
+        case "ifsc":
+            json = b.validateIfsc(input);
+            break;
+        case "upi":
+            json = b.validateUpi(input);
+            break;
+        case "mobile":
+            json = b.validateMobile(input);
+            break;
+        case "pincode":
+            json = b.validatePincode(input);
+            break;
+        case "tan":
+            json = b.validateTan(input);
+            break;
+        case "cin":
+            json = b.validateCin(input);
+            break;
+        case "llpin":
+            json = b.validateLlpin(input);
+            break;
+        case "voter":
+            json = b.validateVoterId(input);
+            break;
+        case "vehicle":
+            json = b.validateVehicle(input);
+            break;
+        default:
+            return null;
+    }
+    return normalizeResult(JSON.parse(json));
+}
+// ---------------------------------------------------------------------------
+// Validators — native when available, TypeScript otherwise
+// ---------------------------------------------------------------------------
+function validatePan(input) {
+    if (typeof input !== "string")
+        return tsImpl.validatePan(input);
+    return callJson((b) => b.validatePan(input), () => tsImpl.validatePan(input));
+}
+function validateAadhaar(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateAadhaar(input);
+    return callJson((b) => b.validateAadhaar(input), () => tsImpl.validateAadhaar(input));
+}
+function validateGstin(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateGstin(input);
+    return callJson((b) => b.validateGstin(input), () => tsImpl.validateGstin(input));
+}
+function validateIfsc(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateIfsc(input);
+    return callJson((b) => b.validateIfsc(input), () => tsImpl.validateIfsc(input));
+}
+function validateUpi(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateUpi(input);
+    return callJson((b) => b.validateUpi(input), () => tsImpl.validateUpi(input));
+}
+function validateMobile(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateMobile(input);
+    return callJson((b) => b.validateMobile(input), () => tsImpl.validateMobile(input));
+}
+function validatePincode(input) {
+    if (typeof input !== "string")
+        return tsImpl.validatePincode(input);
+    return callJson((b) => b.validatePincode(input), () => tsImpl.validatePincode(input));
+}
+function validateTan(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateTan(input);
+    return callJson((b) => b.validateTan(input), () => tsImpl.validateTan(input));
+}
+function validateCin(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateCin(input);
+    return callJson((b) => b.validateCin(input), () => tsImpl.validateCin(input));
+}
+function validateLlpin(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateLlpin(input);
+    return callJson((b) => b.validateLlpin(input), () => tsImpl.validateLlpin(input));
+}
+function validateVoterId(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateVoterId(input);
+    return callJson((b) => b.validateVoterId(input), () => tsImpl.validateVoterId(input));
+}
+/** Alias for `validateVoterId`: EPIC is the name printed on the card. */
+function validateEpic(input) {
+    return validateVoterId(input);
+}
+function validateVehicle(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateVehicle(input);
+    return callJson((b) => b.validateVehicle(input), () => tsImpl.validateVehicle(input));
+}
+/** Alias for `validateVehicle`. */
+function validateVehicleRegistration(input) {
+    return validateVehicle(input);
+}
+// ---------------------------------------------------------------------------
+// detect / validateMany — shapes rebuilt from the native primitives
+// ---------------------------------------------------------------------------
+/** The Rust `detect` string for a trimmed input. */
+function detectType(input) {
+    const b = loadBinding();
+    if (b === null)
+        return tsImpl.detectType(input);
+    try {
+        return b.detect(input);
+    }
+    catch {
+        return tsImpl.detectType(input);
+    }
+}
+function detect(input) {
+    if (typeof input !== "string")
+        return tsImpl.detect(input);
+    const b = loadBinding();
+    if (b === null)
+        return tsImpl.detect(input);
+    try {
+        const type = b.detect(input);
+        const trimmed = input.trim();
+        if (type === "unknown") {
+            return {
+                valid: false,
+                code: "UNKNOWN_TYPE",
+                reason_en: "Could not detect the type of this input",
+                reason_hi: "Is input ka type pehchana nahi ja saka",
+                parsed: { type: "unknown", value: trimmed, result: null },
+            };
+        }
+        const result = validateByNativeType(b, type, input);
+        if (result === null)
+            return tsImpl.detect(input);
+        return {
+            valid: result.valid,
+            code: result.code,
+            reason_en: result.reason_en,
+            reason_hi: result.reason_hi,
+            parsed: { type, value: trimmed, result },
+        };
+    }
+    catch {
+        return tsImpl.detect(input);
+    }
+}
+function validateMany(inputs) {
+    if (!Array.isArray(inputs) || inputs.length === 0) {
+        return tsImpl.validateMany(inputs);
+    }
+    if (!inputs.every((item) => typeof item === "string")) {
+        // Typed `{ value, type }` entries and non-strings are a
+        // TypeScript-wrapper feature — the native batch takes strings only.
+        return tsImpl.validateMany(inputs);
+    }
+    const b = loadBinding();
+    if (b === null)
+        return tsImpl.validateMany(inputs);
+    try {
+        const results = JSON.parse(b.validateMany(inputs));
+        const items = inputs.map((item, i) => {
+            const result = normalizeResult(results[i]);
+            const type = b.detect(item);
+            return {
+                input: item,
+                type: type === "unknown" ? null : type,
+                valid: result.valid,
+                code: result.code,
+                reason_en: result.reason_en,
+                reason_hi: result.reason_hi,
+                parsed: result.parsed,
+            };
+        });
+        const validCount = items.filter((r) => r.valid).length;
+        const invalidCount = items.length - validCount;
+        const parsed = {
+            results: items,
+            total: items.length,
+            validCount,
+            invalidCount,
+        };
+        if (invalidCount === 0) {
+            return {
+                valid: true,
+                code: "VALID",
+                reason_en: "All inputs are valid.",
+                reason_hi: "Saare input sahi hain.",
+                parsed,
+            };
+        }
+        return {
+            valid: false,
+            code: "SOME_INVALID",
+            reason_en: "Some inputs are invalid.",
+            reason_hi: "Kuch input galat hain.",
+            parsed,
+        };
+    }
+    catch {
+        return tsImpl.validateMany(inputs);
+    }
+}
+// ---------------------------------------------------------------------------
+// Format / mask — same contracts as ./index
+// ---------------------------------------------------------------------------
+function formatMobile(input) {
+    // Same contract as validateMobile (see ./index).
+    return validateMobile(input);
+}
+function formatPan(input) {
+    if (typeof input !== "string")
+        return tsImpl.formatPan(input);
+    return callPlain((b) => b.formatPan(input), () => tsImpl.formatPan(input));
+}
+function formatGstin(input) {
+    if (typeof input !== "string")
+        return tsImpl.formatGstin(input);
+    return callPlain((b) => b.formatGstin(input), () => tsImpl.formatGstin(input));
+}
+function maskAadhaar(input) {
+    // Same contract as validateAadhaar (see ./index) — NOT the Rust
+    // `mask_aadhaar` string function, which masks any 12-digit string.
+    return validateAadhaar(input);
+}
+function maskPan(input) {
+    if (typeof input !== "string")
+        return tsImpl.maskPan(input);
+    return callPlain((b) => b.maskPan(input), () => tsImpl.maskPan(input));
+}
+function maskMobile(input) {
+    if (typeof input !== "string")
+        return tsImpl.maskMobile(input);
+    return callPlain((b) => b.maskMobile(input), () => tsImpl.maskMobile(input));
+}
+// ---------------------------------------------------------------------------
+// Mock test-data generators — TEST DATA ONLY, never real issued IDs
+// ---------------------------------------------------------------------------
+function generatePan(entity) {
+    const code = typeof entity === "string" && entity.length > 0 ? entity : "P";
+    return callPlain((b) => b.generatePan(code), () => tsImpl.generatePan(entity));
+}
+function generateAadhaar() {
+    return callPlain((b) => b.generateAadhaar(), () => tsImpl.generateAadhaar());
+}
+function generateGstin(stateCode) {
+    const code = typeof stateCode === "string" ? stateCode : "18";
+    return callPlain((b) => b.generateGstin(code), () => tsImpl.generateGstin(stateCode));
+}
+function generateMobile() {
+    return callPlain((b) => b.generateMobile(), () => tsImpl.generateMobile());
+}
+// ---------------------------------------------------------------------------
+// Options variants — no native equivalent; always TypeScript
+// ---------------------------------------------------------------------------
+exports.validateMobileWithOptions = tsImpl.validateMobileWithOptions;
+exports.validatePanWithOptions = tsImpl.validatePanWithOptions;
+exports.validateAadhaarWithOptions = tsImpl.validateAadhaarWithOptions;
+exports.validateGstinWithOptions = tsImpl.validateGstinWithOptions;
+exports.formatMobileWithOptions = tsImpl.formatMobileWithOptions;
+exports.defaultOptions = tsImpl.defaultOptions;
+exports.lenientOptions = tsImpl.lenientOptions;
+exports.noSpacesHyphensOptions = tsImpl.noSpacesHyphensOptions;
+exports.default = {
+    backend,
+    isNativeAvailable,
+    validateMobile,
+    validatePan,
+    validateAadhaar,
+    validateGstin,
+    validateIfsc,
+    validateUpi,
+    validatePincode,
+    validateTan,
+    validateCin,
+    validateLlpin,
+    validateVoterId,
+    validateEpic,
+    validateVehicle,
+    validateVehicleRegistration,
+    validateMobileWithOptions: exports.validateMobileWithOptions,
+    validatePanWithOptions: exports.validatePanWithOptions,
+    validateAadhaarWithOptions: exports.validateAadhaarWithOptions,
+    validateGstinWithOptions: exports.validateGstinWithOptions,
+    formatMobile,
+    formatMobileWithOptions: exports.formatMobileWithOptions,
+    formatPan,
+    formatGstin,
+    maskAadhaar,
+    maskPan,
+    maskMobile,
+    generatePan,
+    generateAadhaar,
+    generateGstin,
+    generateMobile,
+    defaultOptions: exports.defaultOptions,
+    lenientOptions: exports.lenientOptions,
+    noSpacesHyphensOptions: exports.noSpacesHyphensOptions,
+    detect,
+    detectType,
+    validateMany,
+};

package/package.json

@@ -33,9 +33,10 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
+    "native:build": "npm --prefix ../../crates/indycheck-napi run build",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"
   },
   "types": "dist/index.d.ts",
-  "version": "0.2.0"
+  "version": "0.2.1"
 }