unischema 1.0.1 → 1.1.0

package/dist/chunk-FRBZHN4K.mjs

@@ -0,0 +1,335 @@
+import { isEmpty, isString, createError } from './chunk-FKDWSZIV.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 };

package/dist/chunk-FZ7K2PC7.js

@@ -0,0 +1,248 @@
+'use strict';
+
+var chunkNUW55QTO_js = require('./chunk-NUW55QTO.js');
+
+// src/validators/date/today.ts
+var todayValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== today.getTime()) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_TODAY",
+      message || "Date must be today",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/yesterday.ts
+var yesterdayValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  yesterday.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== yesterday.getTime()) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_YESTERDAY",
+      message || "Date must be yesterday",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/tomorrow.ts
+var tomorrowValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const tomorrow = /* @__PURE__ */ new Date();
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  tomorrow.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== tomorrow.getTime()) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_TOMORROW",
+      message || "Date must be tomorrow",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisWeek.ts
+var thisWeekValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfWeek = new Date(now);
+  startOfWeek.setDate(now.getDate() - now.getDay());
+  startOfWeek.setHours(0, 0, 0, 0);
+  const endOfWeek = new Date(startOfWeek);
+  endOfWeek.setDate(startOfWeek.getDate() + 6);
+  endOfWeek.setHours(23, 59, 59, 999);
+  if (date < startOfWeek || date > endOfWeek) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_THIS_WEEK",
+      message || "Date must be within this week",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisMonth.ts
+var thisMonthValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+  const endOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0, 23, 59, 59, 999);
+  if (date < startOfMonth || date > endOfMonth) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_THIS_MONTH",
+      message || "Date must be within this month",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisYear.ts
+var thisYearValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfYear = new Date(now.getFullYear(), 0, 1);
+  const endOfYear = new Date(now.getFullYear(), 11, 31, 23, 59, 59, 999);
+  if (date < startOfYear || date > endOfYear) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_THIS_YEAR",
+      message || "Date must be within this year",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/weekday.ts
+var weekdayValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const day = date.getDay();
+  if (day === 0 || day === 6) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_WEEKDAY",
+      message || "Date must be a weekday",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/weekend.ts
+var weekendValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const day = date.getDay();
+  if (day !== 0 && day !== 6) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_WEEKEND",
+      message || "Date must be a weekend",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/age.ts
+var ageValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const min = params?.min;
+  const max = params?.max;
+  const soft = params?.soft;
+  const message = params?.message;
+  const birthDate = chunkNUW55QTO_js.parseDate(value);
+  if (!birthDate) return null;
+  const today = /* @__PURE__ */ new Date();
+  let age = today.getFullYear() - birthDate.getFullYear();
+  const monthDiff = today.getMonth() - birthDate.getMonth();
+  if (monthDiff < 0 || monthDiff === 0 && today.getDate() < birthDate.getDate()) {
+    age--;
+  }
+  if (min !== void 0 && age < min) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_AGE_MIN",
+      message || `Age must be at least ${min}`,
+      soft
+    );
+  }
+  if (max !== void 0 && age > max) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_AGE_MAX",
+      message || `Age must be at most ${max}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/between.ts
+var betweenValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const start = params?.start;
+  const end = params?.end;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = chunkNUW55QTO_js.parseDate(value);
+  if (!date) return null;
+  const startDate = chunkNUW55QTO_js.parseDate(start);
+  const endDate = chunkNUW55QTO_js.parseDate(end);
+  if (startDate && date < startDate) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_DATE_BEFORE",
+      message || `Date must be after ${startDate.toLocaleDateString()}`,
+      soft
+    );
+  }
+  if (endDate && date > endDate) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_DATE_AFTER",
+      message || `Date must be before ${endDate.toLocaleDateString()}`,
+      soft
+    );
+  }
+  return null;
+};
+
+exports.ageValidator = ageValidator;
+exports.betweenValidator = betweenValidator;
+exports.thisMonthValidator = thisMonthValidator;
+exports.thisWeekValidator = thisWeekValidator;
+exports.thisYearValidator = thisYearValidator;
+exports.todayValidator = todayValidator;
+exports.tomorrowValidator = tomorrowValidator;
+exports.weekdayValidator = weekdayValidator;
+exports.weekendValidator = weekendValidator;
+exports.yesterdayValidator = yesterdayValidator;

package/dist/chunk-KHHJD6QK.mjs

@@ -0,0 +1,85 @@
+import { isEmpty, isObject, createError } from './chunk-FKDWSZIV.mjs';
+
+// src/validators/object/keys.ts
+var keysValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const pattern = params?.pattern;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isObject(value)) return null;
+  if (pattern) {
+    const keys = Object.keys(value);
+    const invalidKeys = keys.filter((key) => !pattern.test(key));
+    if (invalidKeys.length > 0) {
+      return createError(
+        context,
+        "INVALID_KEYS",
+        message || `Invalid keys: ${invalidKeys.join(", ")}`,
+        soft
+      );
+    }
+  }
+  return null;
+};
+
+// src/validators/object/pick.ts
+var pickValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const allowedKeys = params?.keys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isObject(value) || !allowedKeys) return null;
+  const keys = Object.keys(value);
+  const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
+  if (extraKeys.length > 0) {
+    return createError(
+      context,
+      "INVALID_PICK",
+      message || `Unexpected keys: ${extraKeys.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/object/omit.ts
+var omitValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const forbiddenKeys = params?.keys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isObject(value) || !forbiddenKeys) return null;
+  const keys = Object.keys(value);
+  const foundForbidden = keys.filter((key) => forbiddenKeys.includes(key));
+  if (foundForbidden.length > 0) {
+    return createError(
+      context,
+      "INVALID_OMIT",
+      message || `Forbidden keys found: ${foundForbidden.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/object/strict.ts
+var strictValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const allowedKeys = params?.allowedKeys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isObject(value) || !allowedKeys) return null;
+  const keys = Object.keys(value);
+  const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
+  if (extraKeys.length > 0) {
+    return createError(
+      context,
+      "INVALID_STRICT",
+      message || `Unknown keys not allowed: ${extraKeys.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+export { keysValidator, omitValidator, pickValidator, strictValidator };

package/dist/chunk-NUW55QTO.js

@@ -0,0 +1,48 @@
+'use strict';
+
+// src/validators/utils.ts
+function createError(context, code, message, soft = false) {
+  return {
+    field: context.path,
+    code,
+    message,
+    severity: soft ? "soft" : "hard"
+  };
+}
+function isEmpty(value) {
+  return value === void 0 || value === null || value === "";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isDate(value) {
+  return value instanceof Date && !isNaN(value.getTime());
+}
+function parseDate(value) {
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    return isNaN(parsed.getTime()) ? null : parsed;
+  }
+  return null;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+exports.createError = createError;
+exports.isArray = isArray;
+exports.isDate = isDate;
+exports.isEmpty = isEmpty;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.parseDate = parseDate;