@validex/core 1.0.0

package/dist/index.js

@@ -0,0 +1,361 @@
+import {
+  BusinessName,
+  Color,
+  Country,
+  CreditCard,
+  Currency,
+  DateTime,
+  Email,
+  Iban,
+  IpAddress,
+  Jwt,
+  LicenseKey,
+  MacAddress,
+  Password,
+  PasswordConfirmation,
+  PersonName,
+  Phone,
+  PostalCode,
+  Slug,
+  Text,
+  Token,
+  Url,
+  Username,
+  Uuid,
+  VatNumber,
+  Website,
+  configure,
+  createRule,
+  fieldNameToLabel,
+  getConfig,
+  getConfig2,
+  getCrossField,
+  getErrorMessage,
+  getParams,
+  initAugmentation,
+  preloadData,
+  resetConfig,
+  setup
+} from "./chunk-TBVAKZA5.js";
+import "./chunk-OOFMB7K5.js";
+import "./chunk-NDLUDRZJ.js";
+import "./chunk-PFPNNQGJ.js";
+import "./chunk-SMDC2EAD.js";
+import "./chunk-KTN4NQQL.js";
+import "./chunk-5DOFRLSB.js";
+import "./chunk-OTPQTLPM.js";
+import "./chunk-WKVMDEA3.js";
+import "./chunk-BYMZTDYD.js";
+import "./chunk-4HUGF4EZ.js";
+import {
+  collapseWhitespace,
+  containsEmail,
+  containsHtml,
+  containsUrl,
+  emptyToUndefined,
+  hasDigits,
+  hasLowercase,
+  hasSpecial,
+  hasUppercase,
+  maxConsecutive,
+  maxWords,
+  minWords,
+  noSpaces,
+  onlyAlpha,
+  onlyAlphaSpaceHyphen,
+  onlyAlphanumeric,
+  onlyAlphanumericSpaceHyphen,
+  onlyNumeric,
+  stripHtml,
+  toSlug,
+  toTitleCase
+} from "./chunk-6MGS4JWP.js";
+import {
+  requiredWhen,
+  sameAs
+} from "./chunk-BAFEYOPS.js";
+import "./chunk-TB6J73U7.js";
+import {
+  containsPhoneNumber
+} from "./chunk-FD77PZXB.js";
+import "./chunk-AGJWIOFF.js";
+
+// src/core/validate.ts
+import { z as z2 } from "zod";
+
+// src/core/crossFieldResolver.ts
+import { z } from "zod";
+function deriveFieldLabel(fieldName, explicitLabel, prefix) {
+  if (explicitLabel !== void 0)
+    return explicitLabel;
+  const config = getConfig();
+  const fallback = config.label?.fallback ?? "derived";
+  let defaultLabel;
+  if (fallback === "none")
+    defaultLabel = "";
+  else if (fallback === "generic")
+    defaultLabel = "This field";
+  else
+    defaultLabel = fieldNameToLabel(fieldName);
+  if (config.label?.transform !== void 0) {
+    const path = [...prefix ?? [], fieldName];
+    return config.label.transform({ path, fieldName, defaultLabel });
+  }
+  return defaultLabel;
+}
+function resolveCrossFieldMessage(namespace, code, params) {
+  const config = getConfig();
+  const i18n = config.i18n;
+  const pfx = i18n.prefix ?? "validation";
+  const sep = i18n.separator ?? ".";
+  const key = [pfx, "messages", namespace, code].join(sep);
+  if (i18n.enabled && i18n.t !== void 0)
+    return i18n.t(key, params);
+  if (i18n.enabled)
+    return key;
+  return getErrorMessage(namespace, code, params);
+}
+function resolveSameAs(fieldName, sameAs2, shape, parsedData, meta, prefix) {
+  if (!(sameAs2 in shape)) {
+    throw new Error(
+      `validex: sameAs("${sameAs2}") on field "${fieldName}" \u2014 target field "${sameAs2}" does not exist in the schema`
+    );
+  }
+  const sourceValue = parsedData?.[fieldName];
+  const targetValue = parsedData?.[sameAs2];
+  if (sourceValue === targetValue)
+    return void 0;
+  const targetSchema = shape[sameAs2];
+  const targetMeta = targetSchema !== void 0 ? getCrossField(targetSchema) : void 0;
+  const label = deriveFieldLabel(fieldName, meta.label, prefix);
+  const targetLabel = deriveFieldLabel(sameAs2, targetMeta?.label, prefix);
+  return {
+    path: [...prefix, fieldName],
+    message: resolveCrossFieldMessage("confirmation", "mismatch", {
+      label,
+      targetLabel,
+      code: "mismatch",
+      namespace: "confirmation"
+    })
+  };
+}
+function resolveRequiredWhen(fieldName, targetName, parsedData, rawObj, fieldErrors, meta, prefix) {
+  const targetDotPath = [...prefix, targetName].join(".");
+  if (fieldErrors.has(targetDotPath))
+    return void 0;
+  const targetValue = parsedData?.[targetName];
+  if (targetValue === void 0 || targetValue === null || targetValue === "")
+    return void 0;
+  const rawValue = rawObj[fieldName];
+  if (rawValue !== void 0 && rawValue !== null && rawValue !== "")
+    return void 0;
+  const label = deriveFieldLabel(fieldName, meta.label, prefix);
+  return {
+    path: [...prefix, fieldName],
+    message: resolveCrossFieldMessage("base", "required", {
+      label,
+      code: "required",
+      namespace: "base"
+    })
+  };
+}
+function resolveFieldConstraint(fieldName, shape, parsedData, rawObj, fieldErrors, prefix) {
+  const fieldSchema = shape[fieldName];
+  if (fieldSchema === void 0)
+    return [];
+  const meta = getCrossField(fieldSchema);
+  if (meta === void 0)
+    return [];
+  const issues = [];
+  const dotPath = [...prefix, fieldName].join(".");
+  if (meta.sameAs !== void 0 && !fieldErrors.has(dotPath)) {
+    const issue = resolveSameAs(fieldName, meta.sameAs, shape, parsedData, meta, prefix);
+    if (issue !== void 0)
+      issues.push(issue);
+  }
+  if (meta.requiredWhen !== void 0) {
+    const issue = resolveRequiredWhen(fieldName, meta.requiredWhen, parsedData, rawObj, fieldErrors, meta, prefix);
+    if (issue !== void 0)
+      issues.push(issue);
+  }
+  return issues;
+}
+function resolveCrossFieldConstraints(schema, parsedData, fieldErrors, rawData, prefix = []) {
+  const shape = schema.shape;
+  const rawObj = typeof rawData === "object" && rawData !== null ? rawData : {};
+  const issues = [];
+  for (const fieldName of Object.keys(shape)) {
+    issues.push(...resolveFieldConstraint(fieldName, shape, parsedData, rawObj, fieldErrors, prefix));
+  }
+  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    if (fieldSchema instanceof z.ZodObject) {
+      const nestedParsed = parsedData?.[fieldName];
+      issues.push(...resolveCrossFieldConstraints(
+        fieldSchema,
+        nestedParsed,
+        fieldErrors,
+        rawObj[fieldName],
+        [...prefix, fieldName]
+      ));
+    }
+  }
+  return issues;
+}
+
+// src/core/validate.ts
+function buildDotPath(path) {
+  return path.map(String).join(".");
+}
+function buildNestedErrors(issues) {
+  const root = {};
+  for (const issue of issues) {
+    const { path, message } = issue;
+    if (path.length === 0)
+      continue;
+    let current = root;
+    for (let i = 0; i < path.length - 1; i++) {
+      const segment = String(path[i]);
+      if (current[segment] === void 0)
+        current[segment] = {};
+      current = current[segment];
+    }
+    const lastSegment = String(path.at(-1));
+    const existing = current[lastSegment];
+    if (Array.isArray(existing))
+      existing.push(message);
+    else
+      current[lastSegment] = [message];
+  }
+  return root;
+}
+function collectIssues(issues, errors, firstErrors) {
+  for (const issue of issues) {
+    const dotPath = buildDotPath(issue.path);
+    if (errors[dotPath] === void 0) {
+      errors[dotPath] = [];
+      firstErrors[dotPath] = issue.message;
+    }
+    errors[dotPath].push(issue.message);
+  }
+}
+async function validate(schema, data) {
+  initAugmentation();
+  const result = await schema.safeParseAsync(data);
+  if (result.success)
+    return handleSuccess(schema, result.data, data);
+  return handleFailure(schema, result.error, data);
+}
+function handleSuccess(schema, parsed, raw) {
+  if (schema instanceof z2.ZodObject) {
+    const crossIssues = resolveCrossFieldConstraints(schema, parsed, /* @__PURE__ */ new Set(), raw);
+    if (crossIssues.length > 0) {
+      const errors = {};
+      const firstErrors = {};
+      collectIssues(crossIssues, errors, firstErrors);
+      return { success: false, errors, firstErrors, nestedErrors: buildNestedErrors(crossIssues), issues: crossIssues };
+    }
+  }
+  return {
+    success: true,
+    data: parsed,
+    // SAFETY: Zod safeParseAsync returns inferred output type on success
+    errors: {},
+    firstErrors: {},
+    nestedErrors: {},
+    issues: []
+  };
+}
+function handleFailure(schema, error, raw) {
+  const rawIssues = error.issues;
+  const errors = {};
+  const firstErrors = {};
+  const fieldErrors = /* @__PURE__ */ new Set();
+  for (const issue of rawIssues) {
+    const dotPath = buildDotPath(issue.path);
+    fieldErrors.add(dotPath);
+    if (errors[dotPath] === void 0) {
+      errors[dotPath] = [];
+      firstErrors[dotPath] = issue.message;
+    }
+    errors[dotPath].push(issue.message);
+  }
+  if (schema instanceof z2.ZodObject) {
+    const rawObj = typeof raw === "object" && raw !== null ? raw : {};
+    const crossIssues = resolveCrossFieldConstraints(schema, rawObj, fieldErrors, raw);
+    collectIssues(crossIssues, errors, firstErrors);
+    if (crossIssues.length > 0) {
+      const allIssues = [...rawIssues, ...crossIssues];
+      return { success: false, errors, firstErrors, nestedErrors: buildNestedErrors(allIssues), issues: allIssues };
+    }
+  }
+  return {
+    success: false,
+    errors,
+    firstErrors,
+    nestedErrors: buildNestedErrors(rawIssues),
+    // SAFETY: issues escape hatch exposes raw Zod issues as ReadonlyArray<unknown> for consumers
+    issues: error.issues
+  };
+}
+
+// src/index.ts
+initAugmentation();
+export {
+  BusinessName,
+  Color,
+  Country,
+  CreditCard,
+  Currency,
+  DateTime,
+  Email,
+  Iban,
+  IpAddress,
+  Jwt,
+  LicenseKey,
+  MacAddress,
+  Password,
+  PasswordConfirmation,
+  PersonName,
+  Phone,
+  PostalCode,
+  Slug,
+  Text,
+  Token,
+  Url,
+  Username,
+  Uuid,
+  VatNumber,
+  Website,
+  collapseWhitespace,
+  configure,
+  containsEmail,
+  containsHtml,
+  containsPhoneNumber,
+  containsUrl,
+  createRule,
+  emptyToUndefined,
+  getConfig2 as getConfig,
+  getParams,
+  hasDigits,
+  hasLowercase,
+  hasSpecial,
+  hasUppercase,
+  maxConsecutive,
+  maxWords,
+  minWords,
+  noSpaces,
+  onlyAlpha,
+  onlyAlphaSpaceHyphen,
+  onlyAlphanumeric,
+  onlyAlphanumericSpaceHyphen,
+  onlyNumeric,
+  preloadData,
+  requiredWhen,
+  resetConfig,
+  sameAs,
+  setup,
+  stripHtml,
+  toSlug,
+  toTitleCase,
+  validate
+};

package/dist/locales/en.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkISY3F7TIcjs = require('../chunk-ISY3F7TI.cjs');
+
+
+
+
+exports.default = _chunkISY3F7TIcjs.en_default; exports.lang = _chunkISY3F7TIcjs.lang; exports.validation = _chunkISY3F7TIcjs.validation;

package/dist/locales/en.d.cts

@@ -0,0 +1,234 @@
+var lang = "en";
+var validation = {
+	labels: {
+		email: "Email",
+		personName: "Name",
+		businessName: "Business Name",
+		password: "Password",
+		passwordConfirmation: "Password Confirmation",
+		phone: "Phone",
+		website: "Website",
+		url: "URL",
+		username: "Username",
+		slug: "Slug",
+		postalCode: "Postal Code",
+		licenseKey: "License Key",
+		uuid: "UUID",
+		jwt: "JWT",
+		dateTime: "Date/Time",
+		token: "Token",
+		text: "Text",
+		country: "Country",
+		currency: "Currency",
+		color: "Color",
+		creditCard: "Credit Card",
+		iban: "IBAN",
+		vatNumber: "VAT Number",
+		macAddress: "MAC Address",
+		ipAddress: "IP Address",
+		string: "Value"
+	},
+	messages: {
+		base: {
+			required: "{{label}} is required",
+			min: "{{label}} must be at least {{minimum}} characters",
+			max: "{{label}} must be at most {{maximum}} characters",
+			type: "{{label}} must be a {{expected}}",
+			format: "{{label}} is not valid"
+		},
+		email: {
+			invalid: "{{label}} is not a valid email address",
+			disposableBlocked: "{{label}} must not use a disposable email provider",
+			plusAliasBlocked: "{{label}} must not use plus aliases",
+			domainBlocked: "Email domain '{{domain}}' is not allowed",
+			domainNotAllowed: "Email domain '{{domain}}' is not in the allowed list",
+			subdomainNotAllowed: "Subdomain email addresses are not allowed",
+			custom: "{{label}} failed custom validation"
+		},
+		personName: {
+			invalid: "{{label}} is not a valid name",
+			maxWords: "{{label}} must have at most {{maximum}} words",
+			boundary: "{{label}} must start and end with a letter",
+			maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+			custom: "{{label}} failed custom validation"
+		},
+		businessName: {
+			invalid: "{{label}} is not a valid business name",
+			boundary: "{{label}} must start and end with an alphanumeric character",
+			maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+			custom: "{{label}} failed custom validation"
+		},
+		password: {
+			minUppercase: "{{label}} must have at least {{minimum}} uppercase characters",
+			minLowercase: "{{label}} must have at least {{minimum}} lowercase characters",
+			minDigits: "{{label}} must have at least {{minimum}} digits",
+			minSpecial: "{{label}} must have at least {{minimum}} special characters",
+			maxUppercase: "{{label}} must have at most {{maximum}} uppercase characters",
+			maxLowercase: "{{label}} must have at most {{maximum}} lowercase characters",
+			maxDigits: "{{label}} must have at most {{maximum}} digits",
+			maxSpecial: "{{label}} must have at most {{maximum}} special characters",
+			maxConsecutive: "{{label}} must not have more than {{maximum}} consecutive identical characters",
+			commonBlocked: "{{label}} is too common",
+			custom: "{{label}} failed custom validation"
+		},
+		confirmation: {
+			mismatch: "{{label}} must match {{targetLabel}}",
+			custom: "{{label}} failed custom validation"
+		},
+		phone: {
+			invalid: "{{label}} is not a valid phone number",
+			requireMobile: "{{label}} must be a mobile phone number",
+			countryCodeRequired: "{{label}} must include a country code prefix",
+			countryBlocked: "Phone numbers from '{{country}}' are not allowed",
+			countryNotAllowed: "Phone numbers from '{{country}}' are not in the allowed list",
+			custom: "{{label}} failed custom validation"
+		},
+		website: {
+			invalid: "{{label}} is not a valid website URL",
+			httpsRequired: "{{label}} must use HTTPS",
+			wwwRequired: "{{label}} must include www prefix",
+			pathNotAllowed: "{{label}} must not contain URL paths",
+			queryNotAllowed: "{{label}} must not contain query strings",
+			domainBlocked: "Domain '{{domain}}' is not allowed",
+			domainNotAllowed: "Domain '{{domain}}' is not in the allowed list",
+			subdomainNotAllowed: "Subdomain URLs are not allowed",
+			custom: "{{label}} failed custom validation"
+		},
+		url: {
+			invalid: "{{label}} is not a valid URL",
+			protocolNotAllowed: "Protocol '{{protocol}}' is not allowed",
+			tldRequired: "{{label}} must include a top-level domain",
+			queryNotAllowed: "{{label}} must not contain query strings",
+			authNotAllowed: "{{label}} must not contain credentials",
+			domainBlocked: "Domain '{{domain}}' is not allowed",
+			domainNotAllowed: "Domain '{{domain}}' is not in the allowed list",
+			custom: "{{label}} failed custom validation"
+		},
+		username: {
+			invalid: "{{label}} is not a valid username",
+			reservedBlocked: "The username '{{value}}' is reserved",
+			boundary: "{{label}} must start and end with an alphanumeric character",
+			maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+			custom: "{{label}} failed custom validation"
+		},
+		slug: {
+			invalid: "{{label}} is not a valid slug",
+			custom: "{{label}} failed custom validation"
+		},
+		postalCode: {
+			invalid: "{{label}} is not a valid postal code",
+			custom: "{{label}} failed custom validation"
+		},
+		licenseKey: {
+			invalid: "{{label}} is not a valid license key",
+			custom: "{{label}} failed custom validation"
+		},
+		uuid: {
+			invalid: "{{label}} is not a valid UUID",
+			custom: "{{label}} failed custom validation"
+		},
+		jwt: {
+			invalid: "{{label}} is not a valid JWT",
+			expiryRequired: "{{label}} must have an expiration claim",
+			expired: "{{label}} has expired",
+			notYetValid: "{{label}} is not yet valid",
+			missingClaim: "Required claim '{{claim}}' is missing",
+			algorithmNotAllowed: "Algorithm '{{algorithm}}' is not allowed",
+			custom: "{{label}} failed custom validation"
+		},
+		dateTime: {
+			invalid: "{{label}} is not a valid date",
+			tooEarly: "{{label}} must be after {{minimum}}",
+			tooLate: "{{label}} must be before {{maximum}}",
+			noFuture: "{{label}} must not be in the future",
+			noPast: "{{label}} must not be in the past",
+			custom: "{{label}} failed custom validation"
+		},
+		token: {
+			invalid: "{{label}} is not a valid {{type}} token",
+			custom: "{{label}} failed custom validation"
+		},
+		text: {
+			invalid: "{{label}} is not valid text",
+			noEmails: "{{label}} must not contain email addresses",
+			noUrls: "{{label}} must not contain URLs",
+			noPhoneNumbers: "{{label}} must not contain phone numbers",
+			noHtml: "{{label}} must not contain HTML",
+			minWords: "{{label}} must have at least {{minimum}} words",
+			maxWords: "{{label}} must have at most {{maximum}} words",
+			maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+			custom: "{{label}} failed custom validation"
+		},
+		country: {
+			invalid: "{{label}} is not a valid country code",
+			blocked: "Country '{{country}}' is not allowed",
+			notAllowed: "Country '{{country}}' is not in the allowed list",
+			custom: "{{label}} failed custom validation"
+		},
+		currency: {
+			invalid: "{{label}} is not a valid currency code",
+			blocked: "Currency '{{currency}}' is not allowed",
+			notAllowed: "Currency '{{currency}}' is not in the allowed list",
+			custom: "{{label}} failed custom validation"
+		},
+		color: {
+			invalid: "{{label}} is not a valid color",
+			custom: "{{label}} failed custom validation"
+		},
+		creditCard: {
+			invalid: "{{label}} is not a valid credit card number",
+			issuerNotAllowed: "Card issuer '{{issuer}}' is not in the allowed list",
+			issuerBlocked: "Card issuer '{{issuer}}' is not allowed",
+			custom: "{{label}} failed custom validation"
+		},
+		iban: {
+			invalid: "{{label}} is not a valid IBAN",
+			countryBlocked: "IBANs from '{{country}}' are not allowed",
+			countryNotAllowed: "IBANs from '{{country}}' are not in the allowed list",
+			custom: "{{label}} failed custom validation"
+		},
+		vatNumber: {
+			invalid: "{{label}} is not a valid VAT number",
+			custom: "{{label}} failed custom validation"
+		},
+		macAddress: {
+			invalid: "{{label}} is not a valid MAC address",
+			custom: "{{label}} failed custom validation"
+		},
+		ipAddress: {
+			invalid: "{{label}} is not a valid IP address",
+			privateNotAllowed: "{{label}} must not be a private IP address",
+			custom: "{{label}} failed custom validation"
+		},
+		string: {
+			minUppercase: "{{label}} must have at least {{minimum}} uppercase characters",
+			maxUppercase: "{{label}} must have at most {{maximum}} uppercase characters",
+			minLowercase: "{{label}} must have at least {{minimum}} lowercase characters",
+			maxLowercase: "{{label}} must have at most {{maximum}} lowercase characters",
+			minDigits: "{{label}} must have at least {{minimum}} digits",
+			maxDigits: "{{label}} must have at most {{maximum}} digits",
+			minSpecial: "{{label}} must have at least {{minimum}} special characters",
+			maxSpecial: "{{label}} must have at most {{maximum}} special characters",
+			noEmails: "{{label}} must not contain email addresses",
+			noUrls: "{{label}} must not contain URLs",
+			noPhoneNumbers: "{{label}} must not contain phone numbers",
+			noHtml: "{{label}} must not contain HTML",
+			noSpaces: "{{label}} must not contain spaces",
+			onlyAlpha: "{{label}} must contain only letters",
+			onlyNumeric: "{{label}} must contain only digits",
+			onlyAlphanumeric: "{{label}} must contain only letters and digits",
+			onlyAlphaSpaceHyphen: "{{label}} must contain only letters, spaces, and hyphens",
+			onlyAlphanumericSpaceHyphen: "{{label}} must contain only letters, digits, spaces, and hyphens",
+			minWords: "{{label}} must have at least {{minimum}} words",
+			maxWords: "{{label}} must have at most {{maximum}} words",
+			maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+			custom: "{{label}} failed custom validation"
+		}
+	}
+};
+var en = {
+	lang: lang,
+	validation: validation
+};
+
+export { en as default, lang, validation };