unischema 1.0.1 → 1.2.0

package/dist/chunk-OIYG5D2I.js

@@ -0,0 +1,50 @@
+'use strict';
+
+// src/validators/utils.ts
+function createError(context, code, message, soft = false, received, expected) {
+  return {
+    field: context.path,
+    code,
+    message,
+    severity: soft ? "soft" : "hard",
+    received,
+    expected
+  };
+}
+function isEmpty(value) {
+  return value === void 0 || value === null || value === "";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isDate(value) {
+  return value instanceof Date && !isNaN(value.getTime());
+}
+function parseDate(value) {
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    return isNaN(parsed.getTime()) ? null : parsed;
+  }
+  return null;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+exports.createError = createError;
+exports.isArray = isArray;
+exports.isDate = isDate;
+exports.isEmpty = isEmpty;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.parseDate = parseDate;

package/dist/chunk-RW6HDA5H.mjs

@@ -0,0 +1,194 @@
+import { isEmpty, isNumber, createError } from './chunk-KZZ7NVU3.mjs';
+
+// src/validators/number/port.ts
+var portValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (!Number.isInteger(value) || value < 0 || value > 65535) {
+    return createError(
+      context,
+      "INVALID_PORT",
+      message || "Must be a valid port number (0-65535)",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/latitude.ts
+var latitudeValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (value < -90 || value > 90) {
+    return createError(
+      context,
+      "INVALID_LATITUDE",
+      message || "Latitude must be between -90 and 90",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/longitude.ts
+var longitudeValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (value < -180 || value > 180) {
+    return createError(
+      context,
+      "INVALID_LONGITUDE",
+      message || "Longitude must be between -180 and 180",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/percentage.ts
+var percentageValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (value < 0 || value > 100) {
+    return createError(
+      context,
+      "INVALID_PERCENTAGE",
+      message || "Percentage must be between 0 and 100",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/between.ts
+var betweenValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const min = params?.min;
+  const max = params?.max;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (value < min || value > max) {
+    return createError(
+      context,
+      "INVALID_BETWEEN",
+      message || `Must be between ${min} and ${max}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/divisibleBy.ts
+var divisibleByValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const divisor = params?.divisor;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (value % divisor !== 0) {
+    return createError(
+      context,
+      "INVALID_DIVISIBLE_BY",
+      message || `Must be divisible by ${divisor}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/multipleOf.ts
+var multipleOfValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const multiple = params?.multiple;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (value % multiple !== 0) {
+    return createError(
+      context,
+      "INVALID_MULTIPLE_OF",
+      message || `Must be a multiple of ${multiple}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/even.ts
+var evenValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (value % 2 !== 0) {
+    return createError(
+      context,
+      "INVALID_EVEN",
+      message || "Must be an even number",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/odd.ts
+var oddValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (value % 2 === 0) {
+    return createError(
+      context,
+      "INVALID_ODD",
+      message || "Must be an odd number",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/safe.ts
+var safeValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (!Number.isSafeInteger(value)) {
+    return createError(
+      context,
+      "INVALID_SAFE_INTEGER",
+      message || "Must be a safe integer",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/finite.ts
+var finiteValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value)) return null;
+  if (!Number.isFinite(value)) {
+    return createError(
+      context,
+      "INVALID_FINITE",
+      message || "Must be a finite number",
+      soft
+    );
+  }
+  return null;
+};
+
+export { betweenValidator, divisibleByValidator, evenValidator, finiteValidator, latitudeValidator, longitudeValidator, multipleOfValidator, oddValidator, percentageValidator, portValidator, safeValidator };

package/dist/chunk-TTK77YBI.mjs

@@ -0,0 +1,15 @@
+// src/types/index.ts
+function toEnterpriseResponse(result, data) {
+  return {
+    status: result.valid ? "success" : "validation_error",
+    data: result.valid ? data : void 0,
+    errors: [...result.hardErrors, ...result.softErrors],
+    msg: result.valid ? "Validation successful" : "Validation failed",
+    validation: {
+      hard_validations: result.hardErrors,
+      soft_validations: result.softErrors
+    }
+  };
+}
+
+export { toEnterpriseResponse };

package/dist/chunk-TXT36BCE.js

@@ -0,0 +1,248 @@
+'use strict';
+
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
+
+// src/validators/date/today.ts
+var todayValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== today.getTime()) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_TODAY",
+      message || "Date must be today",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/yesterday.ts
+var yesterdayValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  yesterday.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== yesterday.getTime()) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_YESTERDAY",
+      message || "Date must be yesterday",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/tomorrow.ts
+var tomorrowValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const tomorrow = /* @__PURE__ */ new Date();
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  tomorrow.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== tomorrow.getTime()) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_TOMORROW",
+      message || "Date must be tomorrow",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisWeek.ts
+var thisWeekValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfWeek = new Date(now);
+  startOfWeek.setDate(now.getDate() - now.getDay());
+  startOfWeek.setHours(0, 0, 0, 0);
+  const endOfWeek = new Date(startOfWeek);
+  endOfWeek.setDate(startOfWeek.getDate() + 6);
+  endOfWeek.setHours(23, 59, 59, 999);
+  if (date < startOfWeek || date > endOfWeek) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_THIS_WEEK",
+      message || "Date must be within this week",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisMonth.ts
+var thisMonthValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+  const endOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0, 23, 59, 59, 999);
+  if (date < startOfMonth || date > endOfMonth) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_THIS_MONTH",
+      message || "Date must be within this month",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisYear.ts
+var thisYearValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfYear = new Date(now.getFullYear(), 0, 1);
+  const endOfYear = new Date(now.getFullYear(), 11, 31, 23, 59, 59, 999);
+  if (date < startOfYear || date > endOfYear) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_THIS_YEAR",
+      message || "Date must be within this year",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/weekday.ts
+var weekdayValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const day = date.getDay();
+  if (day === 0 || day === 6) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_WEEKDAY",
+      message || "Date must be a weekday",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/weekend.ts
+var weekendValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const day = date.getDay();
+  if (day !== 0 && day !== 6) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_WEEKEND",
+      message || "Date must be a weekend",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/age.ts
+var ageValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const min = params?.min;
+  const max = params?.max;
+  const soft = params?.soft;
+  const message = params?.message;
+  const birthDate = chunkOIYG5D2I_js.parseDate(value);
+  if (!birthDate) return null;
+  const today = /* @__PURE__ */ new Date();
+  let age = today.getFullYear() - birthDate.getFullYear();
+  const monthDiff = today.getMonth() - birthDate.getMonth();
+  if (monthDiff < 0 || monthDiff === 0 && today.getDate() < birthDate.getDate()) {
+    age--;
+  }
+  if (min !== void 0 && age < min) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_AGE_MIN",
+      message || `Age must be at least ${min}`,
+      soft
+    );
+  }
+  if (max !== void 0 && age > max) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_AGE_MAX",
+      message || `Age must be at most ${max}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/between.ts
+var betweenValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const start = params?.start;
+  const end = params?.end;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkOIYG5D2I_js.parseDate(value);
+  if (!date) return null;
+  const startDate = chunkOIYG5D2I_js.parseDate(start);
+  const endDate = chunkOIYG5D2I_js.parseDate(end);
+  if (startDate && date < startDate) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_DATE_BEFORE",
+      message || `Date must be after ${startDate.toLocaleDateString()}`,
+      soft
+    );
+  }
+  if (endDate && date > endDate) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_DATE_AFTER",
+      message || `Date must be before ${endDate.toLocaleDateString()}`,
+      soft
+    );
+  }
+  return null;
+};
+
+exports.ageValidator = ageValidator;
+exports.betweenValidator = betweenValidator;
+exports.thisMonthValidator = thisMonthValidator;
+exports.thisWeekValidator = thisWeekValidator;
+exports.thisYearValidator = thisYearValidator;
+exports.todayValidator = todayValidator;
+exports.tomorrowValidator = tomorrowValidator;
+exports.weekdayValidator = weekdayValidator;
+exports.weekendValidator = weekendValidator;
+exports.yesterdayValidator = yesterdayValidator;

package/dist/index-C17xs-fU.d.mts

@@ -0,0 +1,140 @@
+/**
+ * Core types for the FormSchema validation engine
+ */
+type ValidationSeverity = 'hard' | 'soft';
+interface ValidationError {
+    /** Field path (e.g., "email" or "address.city") */
+    field: string;
+    /** Path as array (e.g., ["address", "city"]) */
+    path?: string[];
+    /** Error code for programmatic handling */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** Severity level - hard errors block submission, soft are warnings */
+    severity: ValidationSeverity;
+    /** Value that was received (for context) */
+    received?: unknown;
+    /** Expected value or constraints (for context) */
+    expected?: unknown;
+}
+interface ValidationResult {
+    /** True if no hard errors exist */
+    valid: boolean;
+    /** Errors that block form submission */
+    hardErrors: ValidationError[];
+    /** Warnings that don't block submission */
+    softErrors: ValidationError[];
+    /** Errors aggregated by field path */
+    errorsByField?: Record<string, ValidationError[]>;
+}
+/** Validation options */
+interface ValidationOptions {
+    /** Custom error message formatter */
+    errorMap?: (error: ValidationError) => ValidationError | {
+        message: string;
+    };
+    /** Stop validation on first error */
+    abortEarly?: boolean;
+    /** Aggregate errors by field */
+    aggregateByField?: boolean;
+}
+type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+interface ValidationRule {
+    /** Rule type identifier */
+    type: string;
+    /** Rule parameters */
+    params?: Record<string, unknown>;
+    /** Custom error message */
+    message?: string;
+    /** Is this a soft validation (warning only)? */
+    soft?: boolean;
+    /** Is this an async validation? */
+    async?: boolean;
+    /** Debounce delay in ms for async validators */
+    debounce?: number;
+    /** Timeout in ms for async validators */
+    timeout?: number;
+}
+interface FieldDefinition<T = unknown> {
+    /** The base type of this field */
+    type: FieldType;
+    /** Validation rules to apply */
+    rules: ValidationRule[];
+    /** Is this field required? */
+    required: boolean;
+    /** Default value */
+    defaultValue?: T;
+    /** For nested schemas */
+    schema?: SchemaDefinition;
+    /** For array items */
+    items?: FieldDefinition;
+    /** Field metadata */
+    meta?: Record<string, unknown>;
+    /** Transform functions to apply to value */
+    transforms?: Array<(value: unknown) => unknown>;
+    /** Preprocess function to apply before validation */
+    preprocess?: (value: unknown) => unknown;
+    /** Allow null values */
+    nullable?: boolean;
+    /** Allow null or undefined values */
+    nullish?: boolean;
+}
+interface SchemaDefinition {
+    /** Field definitions keyed by field name */
+    fields: Record<string, FieldDefinition>;
+    /** Schema metadata */
+    meta?: Record<string, unknown>;
+    /** Allow unknown keys to pass through */
+    passthrough?: boolean;
+    /** Strict mode - reject unknown keys */
+    strict?: boolean;
+    /** Catchall field definition for unknown keys */
+    catchall?: FieldDefinition;
+}
+interface ValidatorContext {
+    /** Current field path */
+    path: string;
+    /** Full data object being validated */
+    root: unknown;
+    /** Parent object containing this field */
+    parent?: unknown;
+}
+type ValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => ValidationError | null;
+type AsyncValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => Promise<ValidationError | null>;
+/** Async refine function type - returns boolean or validation result object */
+type AsyncRefineFn<T = unknown> = (value: T) => Promise<boolean | {
+    valid: boolean;
+    message?: string;
+}>;
+/** Options for async validation */
+interface AsyncValidationOptions {
+    /** Custom error message */
+    message?: string;
+    /** Debounce delay in ms */
+    debounce?: number;
+    /** Timeout in ms (default: 5000) */
+    timeout?: number;
+    /** Is this a soft validation (warning only)? */
+    soft?: boolean;
+    /** Cache results (useful for expensive checks) */
+    cache?: boolean;
+    /** Cache TTL in seconds (default: 3600) */
+    cacheTTL?: number;
+}
+interface EnterpriseValidationResponse {
+    status: 'success' | 'validation_error';
+    data?: unknown;
+    errors: ValidationError[];
+    msg: string;
+    validation: {
+        hard_validations: ValidationError[];
+        soft_validations: ValidationError[];
+    };
+}
+/**
+ * Convert ValidationResult to enterprise-compatible response format
+ */
+declare function toEnterpriseResponse(result: ValidationResult, data?: unknown): EnterpriseValidationResponse;
+
+export { type AsyncRefineFn as A, type EnterpriseValidationResponse as E, type FieldDefinition as F, type SchemaDefinition as S, type ValidatorContext as V, type ValidationError as a, type ValidationResult as b, type ValidationRule as c, type AsyncValidationOptions as d, type ValidationOptions as e, type ValidatorFn as f, type ValidationSeverity as g, type FieldType as h, type AsyncValidatorFn as i, toEnterpriseResponse as t };