@nhtio/validation 0.1.0-master-5ddd6b01

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@nhtio/validation",
+  "version": "0.1.0-master-5ddd6b01",
+  "description": "A powerful schema description language and data validator",
+  "keywords": [],
+  "author": "Jak Giveon <jak@nht.io>",
+  "copyright": "© 2025-present New Horizon Technology LTD",
+  "license": "MIT",
+  "module": "./index.mjs",
+  "main": "./index.cjs",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.cjs",
+      "types": "./index.d.ts"
+    }
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "npm:rolldown-vite@latest"
+    },
+    "onlyBuiltDependencies": [
+      "es5-ext"
+    ]
+  },
+  "packageManager": "pnpm@10.8.0+sha512.0e82714d1b5b43c74610193cb20734897c1d00de89d0e18420aebc5977fa13d780a9cb05734624e81ebd81cc876cd464794850641c48b9544326b5622ca29971",
+  "type": "module",
+  "dependencies": {}
+}

package/private/guards.d.ts

@@ -0,0 +1,67 @@
+import { DateTime } from 'luxon';
+import type { DateObjectUnits } from 'luxon';
+/**
+ * Checks if a value is an instance of a specific class.
+ * @param value - The value to check
+ * @param type - The name of the class to check against
+ * @returns true if the value is an instance of the specified class, false otherwise
+ */
+export declare const isInstanceOf: <T>(value: unknown, type: string, ctor?: new (...args: any[]) => T) => value is T;
+/**
+ * Type guard to check if a value is a Luxon DateTime instance
+ * @param value - The value to check
+ * @returns True if the value is a Luxon DateTime, false otherwise
+ */
+export declare const isLuxonDateTime: (value: unknown) => value is DateTime;
+/**
+ * Type guard to check if a value is a plain object (not null, not array)
+ * @param value - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ */
+export declare const isPlainObject: (value: unknown) => value is {
+    [key: string]: unknown;
+};
+/**
+ * Type guard to check if a value is an array
+ * @param value - The value to check
+ * @returns True if the value is an array, false otherwise
+ */
+export declare const isArray: (value: unknown) => value is unknown[];
+/**
+ * Type guard to check if a value is a valid Luxon DateObjectUnits object.
+ *
+ * This function validates that the input is a plain object containing only valid
+ * Luxon date/time unit properties with numeric values. It ensures type safety
+ * when working with objects that should represent date/time units for Luxon operations.
+ *
+ * @param value - The value to check for DateObjectUnits compatibility
+ * @returns True if the value is a valid DateObjectUnits object, false otherwise
+ *
+ * @example
+ * ```typescript
+ * // Valid DateObjectUnits objects
+ * const validUnits1 = { year: 2023, month: 12, day: 25 };
+ * const validUnits2 = { hour: 14, minute: 30, second: 45 };
+ * const validUnits3 = { weekYear: 2023, weekNumber: 52 };
+ *
+ * console.log(isDateObjectUnits(validUnits1)); // true
+ * console.log(isDateObjectUnits(validUnits2)); // true
+ * console.log(isDateObjectUnits(validUnits3)); // true
+ *
+ * // Invalid cases
+ * console.log(isDateObjectUnits({})); // false (empty object)
+ * console.log(isDateObjectUnits({ year: "2023" })); // false (string value)
+ * console.log(isDateObjectUnits({ invalid: 123 })); // false (invalid property)
+ * console.log(isDateObjectUnits(null)); // false
+ * console.log(isDateObjectUnits([])); // false
+ * ```
+ *
+ * @remarks
+ * The function validates against all supported Luxon DateObjectUnits properties:
+ * - Time units: year, month, day, ordinal
+ * - Week-based units: weekYear, localWeekYear, weekNumber, localWeekNumber, weekday, localWeekday
+ * - Time of day units: hour, minute, second, millisecond
+ *
+ * All property values must be numbers or undefined. The object must contain at least one property.
+ */
+export declare const isDateObjectUnits: (value: unknown) => value is DateObjectUnits;

package/private/index.d.ts

@@ -0,0 +1,51 @@
+import type { Root } from 'joi';
+import type { BigIntSchema } from './schemas/bigint';
+import type { DatetimeSchema } from './schemas/datetime';
+/**
+ * Extended Joi root interface that includes custom schema types for
+ * additional validation scenarios.
+ *
+ * This interface extends the standard Joi Root interface to include
+ * additional schema types
+ *
+ * @example
+ * ```typescript
+ * import { validator } from '@nhtio/validation'
+ *
+ * const schema = validator.object({
+ *   id: validator.bigint().positive().required(),
+ *   balance: validator.bigint().min(0n).optional()
+ * })
+ * ```
+ *
+ * @public
+ */
+export interface ValidationRoot extends Root {
+    bigint(): BigIntSchema;
+    datetime(): DatetimeSchema;
+}
+/**
+ * Extended Joi instance with custom schema types.
+ *
+ * This instance includes all standard Joi functionality plus additional
+ * schema types for additional validation scenarios.
+ *
+ * @example
+ * ```typescript
+ * import { validator } from '@nhtio/validation'
+ *
+ * // Standard Joi usage
+ * const userSchema = validator.object({
+ *   name: validator.string().required(),
+ *   age: validator.number().min(0),
+ *   balance: validator.bigint().positive() // Custom BigInt type
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare const validator: ValidationRoot;
+export type { BigIntSchema };
+export type { DatetimeSchema };
+export type * from './schemas';
+export { encode, decode } from './utils';

package/private/schemas/bigint.d.ts

@@ -0,0 +1,85 @@
+import type { AnySchema } from '../schemas';
+import type { ExtensionFactory, Reference } from 'joi';
+/**
+ * A Joi extension that adds support for BigInt validation with comprehensive
+ * comparison operations and type coercion.
+ *
+ * @example
+ * ```typescript
+ * import { validator } from '@nhtio/validation'
+ *
+ * const schema = validator.bigint()
+ *   .min(0n)
+ *   .max(1000n)
+ *   .required()
+ *
+ * // Validates and converts to BigInt
+ * const result = schema.validate("123") // Returns { value: 123n }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Works with all standard Joi methods
+ * const optionalSchema = validator.bigint()
+ *   .positive()
+ *   .optional()
+ *   .allow(null)
+ *   .default(0n)
+ * ```
+ *
+ * @public
+ */
+export declare const bigint: ExtensionFactory;
+/**
+ * Schema type for BigInt validation with comprehensive comparison operations.
+ *
+ * This interface extends the base Joi AnySchema to provide BigInt-specific
+ * validation methods including range checks, sign validation, and multiple checks.
+ *
+ * @example
+ * ```typescript
+ * import { validator } from '@nhtio/validation'
+ *
+ * const schema: BigIntSchema = validator.bigint()
+ *   .min(0n)
+ *   .max(1000n)
+ *   .positive()
+ * ```
+ *
+ * @public
+ */
+export interface BigIntSchema<TSchema = bigint> extends AnySchema<TSchema> {
+    /**
+     * Validates that the BigInt is greater than the specified threshold
+     * @param limit - The threshold value to compare against
+     */
+    greater(limit: bigint | Reference): this;
+    /**
+     * Validates that the BigInt is less than the specified threshold
+     * @param limit - The threshold value to compare against
+     */
+    less(limit: bigint | Reference): this;
+    /**
+     * Validates that the BigInt is less than or equal to the specified maximum
+     * @param limit - The maximum allowed value
+     */
+    max(limit: bigint | Reference): this;
+    /**
+     * Validates that the BigInt is greater than or equal to the specified minimum
+     * @param limit - The minimum allowed value
+     */
+    min(limit: bigint | Reference): this;
+    /**
+     * Validates that the BigInt is a multiple of the specified factor
+     * @param limit - The factor that the value must be a multiple of
+     */
+    multiple(limit: bigint | Reference): this;
+    /**
+     * Validates that the BigInt is negative (less than zero)
+     */
+    negative(): this;
+    /**
+     * Validates that the BigInt is positive (greater than zero)
+     */
+    positive(): this;
+}