unischema 1.0.1 → 1.2.0

package/dist/chunk-FPCCH55A.js

@@ -0,0 +1,103 @@
+'use strict';
+
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
+
+// src/validators/common/notMatches.ts
+var notMatchesValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.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 chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_NOT_MATCHES",
+      message || `Must not match ${fieldName}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/common/greaterThan.ts
+var greaterThanValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const fieldName = params?.field;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value) || !fieldName) return null;
+  const root = context.root;
+  const otherValue = root?.[fieldName];
+  if (chunkOIYG5D2I_js.isNumber(otherValue) && value <= otherValue) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const fieldName = params?.field;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value) || !fieldName) return null;
+  const root = context.root;
+  const otherValue = root?.[fieldName];
+  if (chunkOIYG5D2I_js.isNumber(otherValue) && value >= otherValue) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(otherValue)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_DEPENDS_ON",
+      message || `This field requires ${fieldName} to be set`,
+      soft
+    );
+  }
+  return null;
+};
+
+exports.dependsOnValidator = dependsOnValidator;
+exports.greaterThanValidator = greaterThanValidator;
+exports.lessThanValidator = lessThanValidator;
+exports.notMatchesValidator = notMatchesValidator;
+exports.whenValidator = whenValidator;

package/dist/chunk-IUXRLMET.js

@@ -0,0 +1,206 @@
+'use strict';
+
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
+
+// src/validators/number/port.ts
+var portValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (!Number.isInteger(value) || value < 0 || value > 65535) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (value < -90 || value > 90) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (value < -180 || value > 180) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (value < 0 || value > 100) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const min = params?.min;
+  const max = params?.max;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (value < min || value > max) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const divisor = params?.divisor;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (value % divisor !== 0) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const multiple = params?.multiple;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (value % multiple !== 0) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (value % 2 !== 0) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_EVEN",
+      message || "Must be an even number",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/odd.ts
+var oddValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (value % 2 === 0) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_ODD",
+      message || "Must be an odd number",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/number/safe.ts
+var safeValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (!Number.isSafeInteger(value)) {
+    return chunkOIYG5D2I_js.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 (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isNumber(value)) return null;
+  if (!Number.isFinite(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_FINITE",
+      message || "Must be a finite number",
+      soft
+    );
+  }
+  return null;
+};
+
+exports.betweenValidator = betweenValidator;
+exports.divisibleByValidator = divisibleByValidator;
+exports.evenValidator = evenValidator;
+exports.finiteValidator = finiteValidator;
+exports.latitudeValidator = latitudeValidator;
+exports.longitudeValidator = longitudeValidator;
+exports.multipleOfValidator = multipleOfValidator;
+exports.oddValidator = oddValidator;
+exports.percentageValidator = percentageValidator;
+exports.portValidator = portValidator;
+exports.safeValidator = safeValidator;

package/dist/chunk-JEW6U6CB.js

@@ -0,0 +1,353 @@
+'use strict';
+
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
+
+// src/validators/string/email.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var emailValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_EMAIL", "Email must be a string", soft);
+  }
+  if (!EMAIL_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_EMAIL",
+      message || "Invalid email address",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/url.ts
+var urlValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_URL", "URL must be a string", soft);
+  }
+  try {
+    new URL(value);
+    return null;
+  } catch {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_URL",
+      message || "Invalid URL format",
+      soft
+    );
+  }
+};
+
+// src/validators/string/ipAddress.ts
+var IPV4_REGEX = /^((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]?)$/;
+var ipAddressValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_IP", "IP address must be a string", soft);
+  }
+  if (!IPV4_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_IP",
+      message || "Invalid IP address format",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/ipv6.ts
+var IPV6_REGEX = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|::)$/;
+var ipv6Validator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_IPV6", "IPv6 address must be a string", soft);
+  }
+  if (!IPV6_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_IPV6",
+      message || "Invalid IPv6 address format",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/alpha.ts
+var ALPHA_REGEX = /^[a-zA-Z]+$/;
+var alphaValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_ALPHA", "Value must be a string", soft);
+  }
+  if (!ALPHA_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_ALPHA",
+      message || "Must contain only letters",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/alphanumeric.ts
+var ALPHANUMERIC_REGEX = /^[a-zA-Z0-9]+$/;
+var alphanumericValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_ALPHANUMERIC", "Value must be a string", soft);
+  }
+  if (!ALPHANUMERIC_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_ALPHANUMERIC",
+      message || "Must contain only letters and numbers",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/numeric.ts
+var NUMERIC_REGEX = /^[0-9]+$/;
+var numericValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_NUMERIC", "Value must be a string", soft);
+  }
+  if (!NUMERIC_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_NUMERIC",
+      message || "Must contain only numbers",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/lowercase.ts
+var lowercaseValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_LOWERCASE", "Value must be a string", soft);
+  }
+  if (value !== value.toLowerCase()) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_LOWERCASE",
+      message || "Must be lowercase",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/uppercase.ts
+var uppercaseValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_UPPERCASE", "Value must be a string", soft);
+  }
+  if (value !== value.toUpperCase()) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_UPPERCASE",
+      message || "Must be uppercase",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/slug.ts
+var SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var slugValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_SLUG", "Slug must be a string", soft);
+  }
+  if (!SLUG_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_SLUG",
+      message || "Must be a valid URL slug (lowercase, numbers, hyphens)",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/hex.ts
+var HEX_REGEX = /^(0x)?[0-9a-fA-F]+$/;
+var hexValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_HEX", "Hex value must be a string", soft);
+  }
+  if (!HEX_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_HEX",
+      message || "Must be a valid hexadecimal string",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/base64.ts
+var BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var base64Validator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_BASE64", "Base64 value must be a string", soft);
+  }
+  if (!BASE64_REGEX.test(value)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_BASE64",
+      message || "Must be a valid base64 string",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/json.ts
+var jsonValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) {
+    return chunkOIYG5D2I_js.createError(context, "INVALID_JSON", "JSON value must be a string", soft);
+  }
+  try {
+    JSON.parse(value);
+    return null;
+  } catch {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_JSON",
+      message || "Must be valid JSON",
+      soft
+    );
+  }
+};
+
+// src/validators/string/length.ts
+var lengthValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const length = params?.length;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) return null;
+  if (value.length !== length) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_LENGTH",
+      message || `Must be exactly ${length} characters`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/contains.ts
+var containsValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const substring = params?.substring;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) return null;
+  if (!value.includes(substring)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_CONTAINS",
+      message || `Must contain "${substring}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/startsWith.ts
+var startsWithValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const prefix = params?.prefix;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) return null;
+  if (!value.startsWith(prefix)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_STARTS_WITH",
+      message || `Must start with "${prefix}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/endsWith.ts
+var endsWithValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const suffix = params?.suffix;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isString(value)) return null;
+  if (!value.endsWith(suffix)) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_ENDS_WITH",
+      message || `Must end with "${suffix}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+exports.alphaValidator = alphaValidator;
+exports.alphanumericValidator = alphanumericValidator;
+exports.base64Validator = base64Validator;
+exports.containsValidator = containsValidator;
+exports.emailValidator = emailValidator;
+exports.endsWithValidator = endsWithValidator;
+exports.hexValidator = hexValidator;
+exports.ipAddressValidator = ipAddressValidator;
+exports.ipv6Validator = ipv6Validator;
+exports.jsonValidator = jsonValidator;
+exports.lengthValidator = lengthValidator;
+exports.lowercaseValidator = lowercaseValidator;
+exports.numericValidator = numericValidator;
+exports.slugValidator = slugValidator;
+exports.startsWithValidator = startsWithValidator;
+exports.uppercaseValidator = uppercaseValidator;
+exports.urlValidator = urlValidator;