unischema 1.0.1 → 1.2.0

package/dist/adapters/frontend/index.mjs

@@ -1,420 +1,11 @@
-// src/core/validators.ts
-function createError(context, code, message, soft = false) {
-  return {
-    field: context.path,
-    code,
-    message,
-    severity: soft ? "soft" : "hard"
-  };
-}
-var typeValidators = {
-  string: (value, _params, context) => {
-    if (value !== void 0 && value !== null && typeof value !== "string") {
-      return createError(context, "INVALID_TYPE", `Expected string, got ${typeof value}`);
-    }
-    return null;
-  },
-  number: (value, _params, context) => {
-    if (value !== void 0 && value !== null && typeof value !== "number") {
-      return createError(context, "INVALID_TYPE", `Expected number, got ${typeof value}`);
-    }
-    if (typeof value === "number" && isNaN(value)) {
-      return createError(context, "INVALID_NUMBER", "Value is not a valid number");
-    }
-    return null;
-  },
-  boolean: (value, _params, context) => {
-    if (value !== void 0 && value !== null && typeof value !== "boolean") {
-      return createError(context, "INVALID_TYPE", `Expected boolean, got ${typeof value}`);
-    }
-    return null;
-  },
-  date: (value, _params, context) => {
-    if (value === void 0 || value === null) return null;
-    if (value instanceof Date) {
-      if (isNaN(value.getTime())) {
-        return createError(context, "INVALID_DATE", "Invalid date value");
-      }
-      return null;
-    }
-    if (typeof value === "string") {
-      const parsed = new Date(value);
-      if (isNaN(parsed.getTime())) {
-        return createError(context, "INVALID_DATE", "Invalid date format");
-      }
-      return null;
-    }
-    return createError(context, "INVALID_TYPE", `Expected date, got ${typeof value}`);
-  },
-  array: (value, _params, context) => {
-    if (value !== void 0 && value !== null && !Array.isArray(value)) {
-      return createError(context, "INVALID_TYPE", `Expected array, got ${typeof value}`);
-    }
-    return null;
-  },
-  object: (value, _params, context) => {
-    if (value !== void 0 && value !== null) {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        return createError(context, "INVALID_TYPE", `Expected object, got ${typeof value}`);
-      }
-    }
-    return null;
-  }
-};
-var ruleValidators = {
-  required: (value, _params, context) => {
-    const isEmpty = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
-    if (isEmpty) {
-      return createError(context, "REQUIRED", "This field is required");
-    }
-    return null;
-  },
-  min: (value, params, context) => {
-    const min = params?.value;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (value === void 0 || value === null) return null;
-    if (typeof value === "number") {
-      if (value < min) {
-        return createError(
-          context,
-          "MIN_VALUE",
-          message || `Value must be at least ${min}`,
-          soft
-        );
-      }
-    }
-    if (typeof value === "string") {
-      if (value.length < min) {
-        return createError(
-          context,
-          "MIN_LENGTH",
-          message || `Must be at least ${min} characters`,
-          soft
-        );
-      }
-    }
-    if (Array.isArray(value)) {
-      if (value.length < min) {
-        return createError(
-          context,
-          "MIN_ITEMS",
-          message || `Must have at least ${min} items`,
-          soft
-        );
-      }
-    }
-    return null;
-  },
-  max: (value, params, context) => {
-    const max = params?.value;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (value === void 0 || value === null) return null;
-    if (typeof value === "number") {
-      if (value > max) {
-        return createError(
-          context,
-          "MAX_VALUE",
-          message || `Value must be at most ${max}`,
-          soft
-        );
-      }
-    }
-    if (typeof value === "string") {
-      if (value.length > max) {
-        return createError(
-          context,
-          "MAX_LENGTH",
-          message || `Must be at most ${max} characters`,
-          soft
-        );
-      }
-    }
-    if (Array.isArray(value)) {
-      if (value.length > max) {
-        return createError(
-          context,
-          "MAX_ITEMS",
-          message || `Must have at most ${max} items`,
-          soft
-        );
-      }
-    }
-    return null;
-  },
-  email: (value, params, context) => {
-    if (value === void 0 || value === null || value === "") return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "string") {
-      return createError(context, "INVALID_EMAIL", "Email must be a string", soft);
-    }
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailRegex.test(value)) {
-      return createError(
-        context,
-        "INVALID_EMAIL",
-        message || "Invalid email address",
-        soft
-      );
-    }
-    return null;
-  },
-  pattern: (value, params, context) => {
-    if (value === void 0 || value === null || value === "") return null;
-    const pattern = params?.pattern;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "string") return null;
-    const regex = new RegExp(pattern);
-    if (!regex.test(value)) {
-      return createError(
-        context,
-        "PATTERN_MISMATCH",
-        message || `Value does not match required pattern`,
-        soft
-      );
-    }
-    return null;
-  },
-  url: (value, params, context) => {
-    if (value === void 0 || value === null || value === "") return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "string") {
-      return createError(context, "INVALID_URL", "URL must be a string", soft);
-    }
-    try {
-      new URL(value);
-      return null;
-    } catch {
-      return createError(
-        context,
-        "INVALID_URL",
-        message || "Invalid URL format",
-        soft
-      );
-    }
-  },
-  ipAddress: (value, params, context) => {
-    if (value === void 0 || value === null || value === "") return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "string") {
-      return createError(context, "INVALID_IP", "IP address must be a string", soft);
-    }
-    const ipv4Pattern = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-    if (!ipv4Pattern.test(value)) {
-      return createError(
-        context,
-        "INVALID_IP",
-        message || "Invalid IP address format",
-        soft
-      );
-    }
-    return null;
-  },
-  enum: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const values = params?.values;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (!values.includes(value)) {
-      return createError(
-        context,
-        "INVALID_ENUM",
-        message || `Value must be one of: ${values.join(", ")}`,
-        soft
-      );
-    }
-    return null;
-  },
-  custom: (value, params, context) => {
-    const validate2 = params?.validate;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (!validate2) return null;
-    const result = validate2(value, context);
-    if (typeof result === "boolean") {
-      if (!result) {
-        return createError(
-          context,
-          "CUSTOM_VALIDATION",
-          message || "Validation failed",
-          soft
-        );
-      }
-      return null;
-    }
-    if (!result.valid) {
-      return createError(
-        context,
-        "CUSTOM_VALIDATION",
-        result.message || message || "Validation failed",
-        soft
-      );
-    }
-    return null;
-  },
-  // Enterprise patterns - matches field against another field
-  matches: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const otherField = params?.field;
-    const soft = params?.soft;
-    const message = params?.message;
-    const root = context.root;
-    const otherValue = root[otherField];
-    if (value !== otherValue) {
-      return createError(
-        context,
-        "FIELD_MISMATCH",
-        message || `Must match ${otherField}`,
-        soft
-      );
-    }
-    return null;
-  },
-  // Integer validation
-  integer: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "number" || !Number.isInteger(value)) {
-      return createError(
-        context,
-        "NOT_INTEGER",
-        message || "Value must be an integer",
-        soft
-      );
-    }
-    return null;
-  },
-  // Positive number validation
-  positive: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value === "number" && value <= 0) {
-      return createError(
-        context,
-        "NOT_POSITIVE",
-        message || "Value must be positive",
-        soft
-      );
-    }
-    return null;
-  },
-  // Negative number validation
-  negative: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value === "number" && value >= 0) {
-      return createError(
-        context,
-        "NOT_NEGATIVE",
-        message || "Value must be negative",
-        soft
-      );
-    }
-    return null;
-  }
-};
-var customValidators = /* @__PURE__ */ new Map();
-function getValidator(name) {
-  return ruleValidators[name] ?? customValidators.get(name);
-}
-function getTypeValidator(type) {
-  return typeValidators[type];
-}
-
-// src/core/engine.ts
-function validateField(fieldDef, value, context) {
-  const errors = [];
-  const typeValidator = getTypeValidator(fieldDef.type);
-  if (typeValidator) {
-    const typeError = typeValidator(value, void 0, context);
-    if (typeError) {
-      errors.push(typeError);
-      return errors;
-    }
-  }
-  if (fieldDef.required) {
-    const requiredValidator = getValidator("required");
-    if (requiredValidator) {
-      const error = requiredValidator(value, void 0, context);
-      if (error) {
-        errors.push(error);
-        return errors;
-      }
-    }
-  } else if (value === void 0 || value === null || value === "") {
-    return errors;
-  }
-  for (const rule of fieldDef.rules) {
-    const validator = getValidator(rule.type);
-    if (!validator) {
-      console.warn(`Unknown validator: ${rule.type}`);
-      continue;
-    }
-    const params = {
-      ...rule.params,
-      soft: rule.soft,
-      message: rule.message
-    };
-    const error = validator(value, params, context);
-    if (error) {
-      errors.push(error);
-    }
-  }
-  if (fieldDef.type === "object" && fieldDef.schema && value !== null && value !== void 0) {
-    const nestedResult = validateSchema(fieldDef.schema, value, context.path, context.root);
-    errors.push(...nestedResult.hardErrors, ...nestedResult.softErrors);
-  }
-  if (fieldDef.type === "array" && fieldDef.items && Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      const itemContext = {
-        path: `${context.path}[${i}]`,
-        root: context.root,
-        parent: value
-      };
-      const itemErrors = validateField(fieldDef.items, value[i], itemContext);
-      errors.push(...itemErrors);
-    }
-  }
-  return errors;
-}
-function validateSchema(schema, data, basePath = "", root) {
-  const hardErrors = [];
-  const softErrors = [];
-  const rootData = root ?? data;
-  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
-    const value = data[fieldName];
-    const path = basePath ? `${basePath}.${fieldName}` : fieldName;
-    const context = {
-      path,
-      root: rootData,
-      parent: data
-    };
-    const errors = validateField(fieldDef, value, context);
-    for (const error of errors) {
-      if (error.severity === "soft") {
-        softErrors.push(error);
-      } else {
-        hardErrors.push(error);
-      }
-    }
-  }
-  return {
-    valid: hardErrors.length === 0,
-    hardErrors,
-    softErrors
-  };
-}
-function validate(schema, data) {
-  return validateSchema(schema, data);
-}
+import { validate } from '../../chunk-MFEBMQAU.mjs';
+import '../../chunk-75YSYC4K.mjs';
+import '../../chunk-KZCV5IW4.mjs';
+import '../../chunk-COMVAVFU.mjs';
+import '../../chunk-RW6HDA5H.mjs';
+import '../../chunk-7XES4A3M.mjs';
+import '../../chunk-5A4ITJVD.mjs';
+import '../../chunk-KZZ7NVU3.mjs';
 
 // src/adapters/frontend/form.ts
 function createForm(schema, options = {}) {
@@ -864,5 +455,3 @@ function coerceValue(value, type) {
 }
 
 export { FormController, coerceValue, createForm, debounceValidation, focusFirstError, getFieldError, getFieldErrors, getFieldWarning, getFieldWarnings, getFirstErrorField, groupErrorsByField, hasFieldError, hasFieldWarning, parseApiErrors, toErrorMap, toWarningsMap };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map

package/dist/chunk-5A4ITJVD.mjs

@@ -0,0 +1,124 @@
+import { isEmpty, isArray, createError } from './chunk-KZZ7NVU3.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/chunk-66RFUBVU.js

@@ -0,0 +1,131 @@
+'use strict';
+
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
+
+// src/validators/array/includes.ts
+var includesValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const item = params?.item;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
+  if (!value.includes(item)) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const item = params?.item;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
+  if (value.includes(item)) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
+  if (value.length > 0) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_EMPTY",
+      message || "Array must be empty",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/notEmpty.ts
+var notEmptyValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
+  if (value.length === 0) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const order = params?.order || "asc";
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.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 chunkOIYG5D2I_js.createError(
+          context,
+          "INVALID_SORTED",
+          message || "Array must be sorted in ascending order",
+          soft
+        );
+      }
+    } else {
+      if (prev < curr) {
+        return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
+  const hasFalsy = value.some((item) => !item);
+  if (hasFalsy) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_COMPACT",
+      message || "Array must not contain falsy values",
+      soft
+    );
+  }
+  return null;
+};
+
+exports.compactValidator = compactValidator;
+exports.emptyValidator = emptyValidator;
+exports.excludesValidator = excludesValidator;
+exports.includesValidator = includesValidator;
+exports.notEmptyValidator = notEmptyValidator;
+exports.sortedValidator = sortedValidator;