unischema 1.0.0 → 1.1.0

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-VWP24NYS.mjs

@@ -0,0 +1,194 @@
+import { isEmpty, isNumber, createError } from './chunk-FKDWSZIV.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-XC4DKEXP.mjs

@@ -0,0 +1,97 @@
+import { isEmpty, createError, isNumber } from './chunk-FKDWSZIV.mjs';
+
+// src/validators/common/notMatches.ts
+var notMatchesValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const fieldName = params?.field;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!fieldName) return null;
+  const root = context.root;
+  const otherValue = root?.[fieldName];
+  if (value === otherValue) {
+    return createError(
+      context,
+      "INVALID_NOT_MATCHES",
+      message || `Must not match ${fieldName}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/common/greaterThan.ts
+var greaterThanValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const fieldName = params?.field;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value) || !fieldName) return null;
+  const root = context.root;
+  const otherValue = root?.[fieldName];
+  if (isNumber(otherValue) && value <= otherValue) {
+    return createError(
+      context,
+      "INVALID_GREATER_THAN",
+      message || `Must be greater than ${fieldName}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/common/lessThan.ts
+var lessThanValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const fieldName = params?.field;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isNumber(value) || !fieldName) return null;
+  const root = context.root;
+  const otherValue = root?.[fieldName];
+  if (isNumber(otherValue) && value >= otherValue) {
+    return createError(
+      context,
+      "INVALID_LESS_THAN",
+      message || `Must be less than ${fieldName}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/common/when.ts
+var whenValidator = (value, params, context) => {
+  const fieldName = params?.field;
+  const is = params?.is;
+  const then = params?.then;
+  if (!fieldName || !then) return null;
+  const root = context.root;
+  const otherValue = root?.[fieldName];
+  if (otherValue === is) {
+    return then(value, params, context);
+  }
+  return null;
+};
+
+// src/validators/common/dependsOn.ts
+var dependsOnValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const fieldName = params?.field;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!fieldName) return null;
+  const root = context.root;
+  const otherValue = root?.[fieldName];
+  if (isEmpty(otherValue)) {
+    return createError(
+      context,
+      "INVALID_DEPENDS_ON",
+      message || `This field requires ${fieldName} to be set`,
+      soft
+    );
+  }
+  return null;
+};
+
+export { dependsOnValidator, greaterThanValidator, lessThanValidator, notMatchesValidator, whenValidator };

package/dist/chunk-XGTUU27F.mjs

@@ -0,0 +1,124 @@
+import { isEmpty, isArray, createError } from './chunk-FKDWSZIV.mjs';
+
+// src/validators/array/includes.ts
+var includesValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const item = params?.item;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isArray(value)) return null;
+  if (!value.includes(item)) {
+    return createError(
+      context,
+      "INVALID_INCLUDES",
+      message || `Array must include ${JSON.stringify(item)}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/excludes.ts
+var excludesValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const item = params?.item;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isArray(value)) return null;
+  if (value.includes(item)) {
+    return createError(
+      context,
+      "INVALID_EXCLUDES",
+      message || `Array must not include ${JSON.stringify(item)}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/empty.ts
+var emptyValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isArray(value)) return null;
+  if (value.length > 0) {
+    return createError(
+      context,
+      "INVALID_EMPTY",
+      message || "Array must be empty",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/notEmpty.ts
+var notEmptyValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isArray(value)) return null;
+  if (value.length === 0) {
+    return createError(
+      context,
+      "INVALID_NOT_EMPTY",
+      message || "Array must not be empty",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/sorted.ts
+var sortedValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const order = params?.order || "asc";
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isArray(value)) return null;
+  for (let i = 1; i < value.length; i++) {
+    const prev = value[i - 1];
+    const curr = value[i];
+    if (order === "asc") {
+      if (prev > curr) {
+        return createError(
+          context,
+          "INVALID_SORTED",
+          message || "Array must be sorted in ascending order",
+          soft
+        );
+      }
+    } else {
+      if (prev < curr) {
+        return createError(
+          context,
+          "INVALID_SORTED",
+          message || "Array must be sorted in descending order",
+          soft
+        );
+      }
+    }
+  }
+  return null;
+};
+
+// src/validators/array/compact.ts
+var compactValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isArray(value)) return null;
+  const hasFalsy = value.some((item) => !item);
+  if (hasFalsy) {
+    return createError(
+      context,
+      "INVALID_COMPACT",
+      message || "Array must not contain falsy values",
+      soft
+    );
+  }
+  return null;
+};
+
+export { compactValidator, emptyValidator, excludesValidator, includesValidator, notEmptyValidator, sortedValidator };

package/dist/index-BQR7OrY7.d.mts

@@ -0,0 +1,80 @@
+/**
+ * Core types for the FormSchema validation engine
+ */
+type ValidationSeverity = 'hard' | 'soft';
+interface ValidationError {
+    /** Field path (e.g., "email" or "address.city") */
+    field: 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;
+}
+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[];
+}
+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;
+}
+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>;
+}
+interface SchemaDefinition {
+    /** Field definitions keyed by field name */
+    fields: Record<string, FieldDefinition>;
+    /** Schema metadata */
+    meta?: Record<string, unknown>;
+}
+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;
+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 EnterpriseValidationResponse as E, type FieldType as F, type SchemaDefinition as S, type ValidatorContext as V, type ValidationError as a, type ValidationResult as b, type ValidatorFn as c, type ValidationSeverity as d, type ValidationRule as e, type FieldDefinition as f, toEnterpriseResponse as t };

package/dist/index-BQR7OrY7.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Core types for the FormSchema validation engine
+ */
+type ValidationSeverity = 'hard' | 'soft';
+interface ValidationError {
+    /** Field path (e.g., "email" or "address.city") */
+    field: 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;
+}
+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[];
+}
+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;
+}
+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>;
+}
+interface SchemaDefinition {
+    /** Field definitions keyed by field name */
+    fields: Record<string, FieldDefinition>;
+    /** Schema metadata */
+    meta?: Record<string, unknown>;
+}
+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;
+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 EnterpriseValidationResponse as E, type FieldType as F, type SchemaDefinition as S, type ValidatorContext as V, type ValidationError as a, type ValidationResult as b, type ValidatorFn as c, type ValidationSeverity as d, type ValidationRule as e, type FieldDefinition as f, toEnterpriseResponse as t };

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { S as SchemaDefinition, V as ValidationResult, a as ValidatorFn } from './schema-BwQtngae.mjs';
-export { A as ArrayFieldBuilder, B as BaseFieldBuilder, h as BooleanFieldBuilder, D as DateFieldBuilder, q as EnterpriseValidationResponse, E as EnumFieldBuilder, l as FieldDefinition, F as FieldType, I as InferInput, c as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, d as SchemaBuilder, g as StringFieldBuilder, j as ValidationError, k as ValidationRule, i as ValidationSeverity, n as ValidatorContext, e as extend, f as field, m as merge, o as omit, b as partial, p as pick, s as schema, t as toEnterpriseResponse } from './schema-BwQtngae.mjs';
+import { S as SchemaDefinition, b as ValidationResult, c as ValidatorFn } from './index-BQR7OrY7.mjs';
+export { E as EnterpriseValidationResponse, f as FieldDefinition, F as FieldType, a as ValidationError, e as ValidationRule, d as ValidationSeverity, V as ValidatorContext, t as toEnterpriseResponse } from './index-BQR7OrY7.mjs';
+export { A as ArrayFieldBuilder, B as BaseFieldBuilder, d as BooleanFieldBuilder, D as DateFieldBuilder, E as EnumFieldBuilder, I as InferInput, b as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, S as SchemaBuilder, c as StringFieldBuilder, e as extend, f as field, m as merge, o as omit, a as partial, p as pick, s as schema } from './schema-DYU1zGVm.mjs';
 
 /**
  * Core validation engine - runs unchanged in browser and Node.js

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { S as SchemaDefinition, V as ValidationResult, a as ValidatorFn } from './schema-BwQtngae.js';
-export { A as ArrayFieldBuilder, B as BaseFieldBuilder, h as BooleanFieldBuilder, D as DateFieldBuilder, q as EnterpriseValidationResponse, E as EnumFieldBuilder, l as FieldDefinition, F as FieldType, I as InferInput, c as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, d as SchemaBuilder, g as StringFieldBuilder, j as ValidationError, k as ValidationRule, i as ValidationSeverity, n as ValidatorContext, e as extend, f as field, m as merge, o as omit, b as partial, p as pick, s as schema, t as toEnterpriseResponse } from './schema-BwQtngae.js';
+import { S as SchemaDefinition, b as ValidationResult, c as ValidatorFn } from './index-BQR7OrY7.js';
+export { E as EnterpriseValidationResponse, f as FieldDefinition, F as FieldType, a as ValidationError, e as ValidationRule, d as ValidationSeverity, V as ValidatorContext, t as toEnterpriseResponse } from './index-BQR7OrY7.js';
+export { A as ArrayFieldBuilder, B as BaseFieldBuilder, d as BooleanFieldBuilder, D as DateFieldBuilder, E as EnumFieldBuilder, I as InferInput, b as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, S as SchemaBuilder, c as StringFieldBuilder, e as extend, f as field, m as merge, o as omit, a as partial, p as pick, s as schema } from './schema-CpAjXgEF.js';
 
 /**
  * Core validation engine - runs unchanged in browser and Node.js