unischema 1.0.1 → 1.2.0

package/dist/chunk-COMVAVFU.mjs

@@ -0,0 +1,335 @@
+import { isEmpty, isString, createError } from './chunk-KZZ7NVU3.mjs';
+
+// src/validators/string/email.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var emailValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_EMAIL", "Email must be a string", soft);
+  }
+  if (!EMAIL_REGEX.test(value)) {
+    return createError(
+      context,
+      "INVALID_EMAIL",
+      message || "Invalid email address",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/url.ts
+var urlValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    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
+    );
+  }
+};
+
+// 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_IP", "IP address must be a string", soft);
+  }
+  if (!IPV4_REGEX.test(value)) {
+    return 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_IPV6", "IPv6 address must be a string", soft);
+  }
+  if (!IPV6_REGEX.test(value)) {
+    return 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_ALPHA", "Value must be a string", soft);
+  }
+  if (!ALPHA_REGEX.test(value)) {
+    return 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_ALPHANUMERIC", "Value must be a string", soft);
+  }
+  if (!ALPHANUMERIC_REGEX.test(value)) {
+    return 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_NUMERIC", "Value must be a string", soft);
+  }
+  if (!NUMERIC_REGEX.test(value)) {
+    return createError(
+      context,
+      "INVALID_NUMERIC",
+      message || "Must contain only numbers",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/lowercase.ts
+var lowercaseValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_LOWERCASE", "Value must be a string", soft);
+  }
+  if (value !== value.toLowerCase()) {
+    return createError(
+      context,
+      "INVALID_LOWERCASE",
+      message || "Must be lowercase",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/uppercase.ts
+var uppercaseValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_UPPERCASE", "Value must be a string", soft);
+  }
+  if (value !== value.toUpperCase()) {
+    return 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_SLUG", "Slug must be a string", soft);
+  }
+  if (!SLUG_REGEX.test(value)) {
+    return 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_HEX", "Hex value must be a string", soft);
+  }
+  if (!HEX_REGEX.test(value)) {
+    return 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_BASE64", "Base64 value must be a string", soft);
+  }
+  if (!BASE64_REGEX.test(value)) {
+    return 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 (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) {
+    return createError(context, "INVALID_JSON", "JSON value must be a string", soft);
+  }
+  try {
+    JSON.parse(value);
+    return null;
+  } catch {
+    return createError(
+      context,
+      "INVALID_JSON",
+      message || "Must be valid JSON",
+      soft
+    );
+  }
+};
+
+// src/validators/string/length.ts
+var lengthValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const length = params?.length;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) return null;
+  if (value.length !== length) {
+    return createError(
+      context,
+      "INVALID_LENGTH",
+      message || `Must be exactly ${length} characters`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/contains.ts
+var containsValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const substring = params?.substring;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) return null;
+  if (!value.includes(substring)) {
+    return createError(
+      context,
+      "INVALID_CONTAINS",
+      message || `Must contain "${substring}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/startsWith.ts
+var startsWithValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const prefix = params?.prefix;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) return null;
+  if (!value.startsWith(prefix)) {
+    return createError(
+      context,
+      "INVALID_STARTS_WITH",
+      message || `Must start with "${prefix}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/endsWith.ts
+var endsWithValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const suffix = params?.suffix;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isString(value)) return null;
+  if (!value.endsWith(suffix)) {
+    return createError(
+      context,
+      "INVALID_ENDS_WITH",
+      message || `Must end with "${suffix}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+export { alphaValidator, alphanumericValidator, base64Validator, containsValidator, emailValidator, endsWithValidator, hexValidator, ipAddressValidator, ipv6Validator, jsonValidator, lengthValidator, lowercaseValidator, numericValidator, slugValidator, startsWithValidator, uppercaseValidator, urlValidator };