@hy_ong/zod-kit 0.2.0 → 0.2.2

package/dist/chunk-ZXUMK2RR.js

@@ -0,0 +1,301 @@
+import {
+  getLocale,
+  t
+} from "./chunk-6AAP4LPF.js";
+
+// src/validators/common/datetime.ts
+import { z } from "zod";
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter";
+import isSameOrBefore from "dayjs/plugin/isSameOrBefore";
+import isToday from "dayjs/plugin/isToday";
+import weekday from "dayjs/plugin/weekday";
+import timezone from "dayjs/plugin/timezone";
+import utc from "dayjs/plugin/utc";
+dayjs.extend(isSameOrAfter);
+dayjs.extend(isSameOrBefore);
+dayjs.extend(customParseFormat);
+dayjs.extend(isToday);
+dayjs.extend(weekday);
+dayjs.extend(timezone);
+dayjs.extend(utc);
+var DATETIME_PATTERNS = {
+  "YYYY-MM-DD HH:mm": /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/,
+  "YYYY-MM-DD HH:mm:ss": /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/,
+  "YYYY-MM-DD hh:mm A": /^\d{4}-\d{2}-\d{2} \d{1,2}:\d{2} (AM|PM)$/i,
+  "YYYY-MM-DD hh:mm:ss A": /^\d{4}-\d{2}-\d{2} \d{1,2}:\d{2}:\d{2} (AM|PM)$/i,
+  "DD/MM/YYYY HH:mm": /^\d{1,2}\/\d{1,2}\/\d{4} \d{2}:\d{2}$/,
+  "DD/MM/YYYY HH:mm:ss": /^\d{1,2}\/\d{1,2}\/\d{4} \d{2}:\d{2}:\d{2}$/,
+  "DD/MM/YYYY hh:mm A": /^\d{1,2}\/\d{1,2}\/\d{4} \d{1,2}:\d{2} (AM|PM)$/i,
+  "MM/DD/YYYY HH:mm": /^\d{1,2}\/\d{1,2}\/\d{4} \d{2}:\d{2}$/,
+  "MM/DD/YYYY hh:mm A": /^\d{1,2}\/\d{1,2}\/\d{4} \d{1,2}:\d{2} (AM|PM)$/i,
+  "YYYY/MM/DD HH:mm": /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}$/,
+  "DD-MM-YYYY HH:mm": /^\d{1,2}-\d{1,2}-\d{4} \d{2}:\d{2}$/,
+  "MM-DD-YYYY HH:mm": /^\d{1,2}-\d{1,2}-\d{4} \d{2}:\d{2}$/,
+  ISO: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/,
+  RFC: /^[A-Za-z]{3}, \d{1,2} [A-Za-z]{3} \d{4} \d{2}:\d{2}:\d{2} [A-Z]{3}$/,
+  UNIX: /^\d{10}$/
+};
+var validateDateTimeFormat = (value, format) => {
+  const pattern = DATETIME_PATTERNS[format];
+  if (!pattern.test(value.trim())) {
+    return false;
+  }
+  const parsed = parseDateTimeValue(value, format);
+  return parsed !== null;
+};
+var parseDateTimeValue = (value, format, timezone2) => {
+  try {
+    const cleanValue = value.trim();
+    let parsed;
+    switch (format) {
+      case "ISO":
+        parsed = dayjs(cleanValue);
+        break;
+      case "RFC":
+        parsed = dayjs(cleanValue);
+        break;
+      case "UNIX":
+        parsed = dayjs.unix(parseInt(cleanValue, 10));
+        break;
+      default:
+        parsed = dayjs(cleanValue, format, true);
+        break;
+    }
+    if (!parsed.isValid()) {
+      return null;
+    }
+    if (timezone2) {
+      parsed = parsed.tz(timezone2);
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var normalizeDateTimeValue = (value, format, timezone2) => {
+  const parsed = parseDateTimeValue(value, format, timezone2);
+  if (!parsed) return null;
+  switch (format) {
+    case "ISO":
+      return parsed.toISOString();
+    case "RFC":
+      return parsed.format("ddd, DD MMM YYYY HH:mm:ss [GMT]");
+    case "UNIX":
+      return parsed.unix().toString();
+    default:
+      return parsed.format(format);
+  }
+};
+function datetime(required, options) {
+  const {
+    format = "YYYY-MM-DD HH:mm",
+    min,
+    max,
+    minHour,
+    maxHour,
+    allowedHours,
+    minuteStep,
+    timezone: timezone2,
+    includes,
+    excludes,
+    regex,
+    trimMode = "trim",
+    casing = "none",
+    mustBePast,
+    mustBeFuture,
+    mustBeToday,
+    mustNotBeToday,
+    weekdaysOnly,
+    weekendsOnly,
+    whitelist,
+    whitelistOnly = false,
+    transform,
+    defaultValue,
+    i18n
+  } = options ?? {};
+  const isRequired = required ?? false;
+  const actualDefaultValue = defaultValue ?? (isRequired ? "" : null);
+  const getMessage = (key, params) => {
+    if (i18n) {
+      const currentLocale = getLocale();
+      const customMessages = i18n[currentLocale];
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key];
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "");
+      }
+    }
+    return t(`common.datetime.${key}`, params);
+  };
+  const preprocessFn = (val) => {
+    if (val === null || val === void 0) {
+      return actualDefaultValue;
+    }
+    let processed = String(val);
+    switch (trimMode) {
+      case "trim":
+        processed = processed.trim();
+        break;
+      case "trimStart":
+        processed = processed.trimStart();
+        break;
+      case "trimEnd":
+        processed = processed.trimEnd();
+        break;
+      case "none":
+        break;
+    }
+    if (processed === "") {
+      if (whitelist && whitelist.includes("")) {
+        return "";
+      }
+      if (!isRequired) {
+        return actualDefaultValue;
+      }
+      return actualDefaultValue;
+    }
+    switch (casing) {
+      case "upper":
+        processed = processed.toUpperCase();
+        break;
+      case "lower":
+        processed = processed.toLowerCase();
+        break;
+      case "none":
+        break;
+    }
+    if (transform) {
+      processed = transform(processed);
+    }
+    return processed;
+  };
+  const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable());
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return;
+    if (isRequired && (val === "" || val === "null" || val === "undefined")) {
+      ctx.addIssue({ code: "custom", message: getMessage("required") });
+      return;
+    }
+    if (val === null) return;
+    if (!isRequired && val === "") return;
+    if (whitelist && whitelist.length > 0) {
+      if (whitelist.includes(val)) {
+        return;
+      }
+      if (whitelistOnly) {
+        ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") });
+        return;
+      }
+    }
+    if (regex) {
+      if (!regex.test(val)) {
+        ctx.addIssue({ code: "custom", message: getMessage("customRegex") });
+        return;
+      }
+    } else {
+      if (!validateDateTimeFormat(val, format)) {
+        ctx.addIssue({ code: "custom", message: getMessage("format", { format }) });
+        return;
+      }
+    }
+    if (includes && !val.includes(includes)) {
+      ctx.addIssue({ code: "custom", message: getMessage("includes", { includes }) });
+      return;
+    }
+    if (excludes) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes];
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          ctx.addIssue({ code: "custom", message: getMessage("excludes", { excludes: exclude }) });
+          return;
+        }
+      }
+    }
+    if (regex) {
+      return;
+    }
+    const parsed = parseDateTimeValue(val, format, timezone2);
+    if (!parsed) {
+      const pattern = DATETIME_PATTERNS[format];
+      if (!pattern.test(val.trim())) {
+        ctx.addIssue({ code: "custom", message: getMessage("format", { format }) });
+        return;
+      } else {
+        ctx.addIssue({ code: "custom", message: getMessage("invalid") });
+        return;
+      }
+    }
+    const hour = parsed.hour();
+    if (minHour !== void 0 && hour < minHour) {
+      ctx.addIssue({ code: "custom", message: getMessage("hour", { minHour, maxHour: maxHour ?? 23 }) });
+      return;
+    }
+    if (maxHour !== void 0 && hour > maxHour) {
+      ctx.addIssue({ code: "custom", message: getMessage("hour", { minHour: minHour ?? 0, maxHour }) });
+      return;
+    }
+    if (allowedHours && allowedHours.length > 0) {
+      if (!allowedHours.includes(hour)) {
+        ctx.addIssue({ code: "custom", message: getMessage("hour", { allowedHours: allowedHours.join(", ") }) });
+        return;
+      }
+    }
+    const minute = parsed.minute();
+    if (minuteStep !== void 0 && minute % minuteStep !== 0) {
+      ctx.addIssue({ code: "custom", message: getMessage("minute", { minuteStep }) });
+      return;
+    }
+    if (min) {
+      const minParsed = typeof min === "string" ? parseDateTimeValue(min, format, timezone2) : dayjs(min);
+      if (minParsed && parsed.isBefore(minParsed)) {
+        const minFormatted = typeof min === "string" ? min : minParsed.format(format);
+        ctx.addIssue({ code: "custom", message: getMessage("min", { min: minFormatted }) });
+        return;
+      }
+    }
+    if (max) {
+      const maxParsed = typeof max === "string" ? parseDateTimeValue(max, format, timezone2) : dayjs(max);
+      if (maxParsed && parsed.isAfter(maxParsed)) {
+        const maxFormatted = typeof max === "string" ? max : maxParsed.format(format);
+        ctx.addIssue({ code: "custom", message: getMessage("max", { max: maxFormatted }) });
+        return;
+      }
+    }
+    const now = timezone2 ? dayjs().tz(timezone2) : dayjs();
+    if (mustBePast && !parsed.isBefore(now)) {
+      ctx.addIssue({ code: "custom", message: getMessage("past") });
+      return;
+    }
+    if (mustBeFuture && !parsed.isAfter(now)) {
+      ctx.addIssue({ code: "custom", message: getMessage("future") });
+      return;
+    }
+    if (mustBeToday && !parsed.isSame(now, "day")) {
+      ctx.addIssue({ code: "custom", message: getMessage("today") });
+      return;
+    }
+    if (mustNotBeToday && parsed.isSame(now, "day")) {
+      ctx.addIssue({ code: "custom", message: getMessage("notToday") });
+      return;
+    }
+    const dayOfWeek = parsed.day();
+    if (weekdaysOnly && (dayOfWeek === 0 || dayOfWeek === 6)) {
+      ctx.addIssue({ code: "custom", message: getMessage("weekday") });
+      return;
+    }
+    if (weekendsOnly && dayOfWeek !== 0 && dayOfWeek !== 6) {
+      ctx.addIssue({ code: "custom", message: getMessage("weekend") });
+      return;
+    }
+  });
+  return schema;
+}
+
+export {
+  DATETIME_PATTERNS,
+  validateDateTimeFormat,
+  parseDateTimeValue,
+  normalizeDateTimeValue,
+  datetime
+};

package/dist/common/boolean.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTFGS34VDcjs = require('../chunk-TFGS34VD.cjs');
+require('../chunk-UCOXAZJF.cjs');
+
+
+exports.boolean = _chunkTFGS34VDcjs.boolean;

package/dist/common/boolean.d.cts

@@ -0,0 +1,119 @@
+import { ZodBoolean, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.cjs';
+
+/**
+ * @fileoverview Boolean validator for Zod Kit
+ *
+ * Provides flexible boolean validation with support for various truthy/falsy values,
+ * strict mode validation, and comprehensive transformation options.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+/**
+ * Type definition for boolean validation error messages
+ *
+ * @interface BooleanMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [shouldBeTrue] - Message when value should be true but isn't
+ * @property {string} [shouldBeFalse] - Message when value should be false but isn't
+ * @property {string} [invalid] - Message when value is not a valid boolean
+ */
+type BooleanMessages = {
+    required?: string;
+    shouldBeTrue?: string;
+    shouldBeFalse?: string;
+    invalid?: string;
+};
+/**
+ * Configuration options for boolean validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface BooleanOptions
+ * @property {boolean | null} [defaultValue] - Default value when input is empty
+ * @property {boolean} [shouldBe] - Specific boolean value that must be matched
+ * @property {unknown[]} [truthyValues] - Array of values that should be treated as true
+ * @property {unknown[]} [falsyValues] - Array of values that should be treated as false
+ * @property {boolean} [strict=false] - If true, only accepts actual boolean values
+ * @property {Function} [transform] - Custom transformation function for boolean values
+ * @property {Record<Locale, BooleanMessages>} [i18n] - Custom error messages for different locales
+ */
+type BooleanOptions<IsRequired extends boolean = true> = {
+    defaultValue?: IsRequired extends true ? boolean : boolean | null;
+    shouldBe?: boolean;
+    truthyValues?: unknown[];
+    falsyValues?: unknown[];
+    strict?: boolean;
+    transform?: (value: boolean) => boolean;
+    i18n?: Partial<Record<Locale, Partial<BooleanMessages>>>;
+};
+/**
+ * Type alias for boolean validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef BooleanSchema
+ * @description Returns ZodBoolean if required, ZodNullable<ZodBoolean> if optional
+ */
+type BooleanSchema<IsRequired extends boolean> = IsRequired extends true ? ZodBoolean : ZodNullable<ZodBoolean>;
+/**
+ * Creates a Zod schema for boolean validation with flexible value interpretation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {IsRequired} [required=false] - Whether the field is required
+ * @param {Omit<BooleanOptions<IsRequired>, 'required'>} [options] - Configuration options for boolean validation
+ * @returns {BooleanSchema<IsRequired>} Zod schema for boolean validation
+ *
+ * @description
+ * Creates a flexible boolean validator that can interpret various values as true/false,
+ * supports strict mode for type safety, and provides comprehensive transformation options.
+ *
+ * Features:
+ * - Flexible truthy/falsy value interpretation
+ * - Strict mode for type safety
+ * - Custom transformation functions
+ * - Specific boolean value requirements
+ * - Comprehensive internationalization
+ * - Default value support
+ *
+ * @example
+ * ```typescript
+ * // Basic boolean validation (optional by default)
+ * const basicSchema = boolean()
+ * basicSchema.parse(true) // ✓ Valid
+ * basicSchema.parse("true") // ✓ Valid (converted to true)
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required boolean
+ * const requiredSchema = boolean(true)
+ * requiredSchema.parse(true) // ✓ Valid
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * // Strict mode (only actual booleans)
+ * const strictSchema = boolean(false, { strict: true })
+ * strictSchema.parse(true) // ✓ Valid
+ * strictSchema.parse("true") // ✗ Invalid
+ *
+ * // Must be true
+ * const mustBeTrueSchema = boolean(true, { shouldBe: true })
+ * mustBeTrueSchema.parse(true) // ✓ Valid
+ * mustBeTrueSchema.parse(false) // ✗ Invalid
+ *
+ * // Custom truthy/falsy values
+ * const customSchema = boolean(false, {
+ *   truthyValues: ["yes", "on", 1],
+ *   falsyValues: ["no", "off", 0]
+ * })
+ * customSchema.parse("yes") // ✓ Valid (converted to true)
+ *
+ * // Optional with default
+ * const optionalSchema = boolean(false, { defaultValue: false })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link BooleanOptions} for all available configuration options
+ */
+declare function boolean<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<BooleanOptions<IsRequired>, 'required'>): BooleanSchema<IsRequired>;
+
+export { type BooleanMessages, type BooleanOptions, type BooleanSchema, boolean };

package/dist/common/boolean.d.ts

@@ -0,0 +1,119 @@
+import { ZodBoolean, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.js';
+
+/**
+ * @fileoverview Boolean validator for Zod Kit
+ *
+ * Provides flexible boolean validation with support for various truthy/falsy values,
+ * strict mode validation, and comprehensive transformation options.
+ *
+ * @author Ong Hoe Yuan
+ * @version 0.0.5
+ */
+
+/**
+ * Type definition for boolean validation error messages
+ *
+ * @interface BooleanMessages
+ * @property {string} [required] - Message when field is required but empty
+ * @property {string} [shouldBeTrue] - Message when value should be true but isn't
+ * @property {string} [shouldBeFalse] - Message when value should be false but isn't
+ * @property {string} [invalid] - Message when value is not a valid boolean
+ */
+type BooleanMessages = {
+    required?: string;
+    shouldBeTrue?: string;
+    shouldBeFalse?: string;
+    invalid?: string;
+};
+/**
+ * Configuration options for boolean validation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ *
+ * @interface BooleanOptions
+ * @property {boolean | null} [defaultValue] - Default value when input is empty
+ * @property {boolean} [shouldBe] - Specific boolean value that must be matched
+ * @property {unknown[]} [truthyValues] - Array of values that should be treated as true
+ * @property {unknown[]} [falsyValues] - Array of values that should be treated as false
+ * @property {boolean} [strict=false] - If true, only accepts actual boolean values
+ * @property {Function} [transform] - Custom transformation function for boolean values
+ * @property {Record<Locale, BooleanMessages>} [i18n] - Custom error messages for different locales
+ */
+type BooleanOptions<IsRequired extends boolean = true> = {
+    defaultValue?: IsRequired extends true ? boolean : boolean | null;
+    shouldBe?: boolean;
+    truthyValues?: unknown[];
+    falsyValues?: unknown[];
+    strict?: boolean;
+    transform?: (value: boolean) => boolean;
+    i18n?: Partial<Record<Locale, Partial<BooleanMessages>>>;
+};
+/**
+ * Type alias for boolean validation schema based on required flag
+ *
+ * @template IsRequired - Whether the field is required
+ * @typedef BooleanSchema
+ * @description Returns ZodBoolean if required, ZodNullable<ZodBoolean> if optional
+ */
+type BooleanSchema<IsRequired extends boolean> = IsRequired extends true ? ZodBoolean : ZodNullable<ZodBoolean>;
+/**
+ * Creates a Zod schema for boolean validation with flexible value interpretation
+ *
+ * @template IsRequired - Whether the field is required (affects return type)
+ * @param {IsRequired} [required=false] - Whether the field is required
+ * @param {Omit<BooleanOptions<IsRequired>, 'required'>} [options] - Configuration options for boolean validation
+ * @returns {BooleanSchema<IsRequired>} Zod schema for boolean validation
+ *
+ * @description
+ * Creates a flexible boolean validator that can interpret various values as true/false,
+ * supports strict mode for type safety, and provides comprehensive transformation options.
+ *
+ * Features:
+ * - Flexible truthy/falsy value interpretation
+ * - Strict mode for type safety
+ * - Custom transformation functions
+ * - Specific boolean value requirements
+ * - Comprehensive internationalization
+ * - Default value support
+ *
+ * @example
+ * ```typescript
+ * // Basic boolean validation (optional by default)
+ * const basicSchema = boolean()
+ * basicSchema.parse(true) // ✓ Valid
+ * basicSchema.parse("true") // ✓ Valid (converted to true)
+ * basicSchema.parse(null) // ✓ Valid (optional)
+ *
+ * // Required boolean
+ * const requiredSchema = boolean(true)
+ * requiredSchema.parse(true) // ✓ Valid
+ * requiredSchema.parse(null) // ✗ Invalid (required)
+ *
+ * // Strict mode (only actual booleans)
+ * const strictSchema = boolean(false, { strict: true })
+ * strictSchema.parse(true) // ✓ Valid
+ * strictSchema.parse("true") // ✗ Invalid
+ *
+ * // Must be true
+ * const mustBeTrueSchema = boolean(true, { shouldBe: true })
+ * mustBeTrueSchema.parse(true) // ✓ Valid
+ * mustBeTrueSchema.parse(false) // ✗ Invalid
+ *
+ * // Custom truthy/falsy values
+ * const customSchema = boolean(false, {
+ *   truthyValues: ["yes", "on", 1],
+ *   falsyValues: ["no", "off", 0]
+ * })
+ * customSchema.parse("yes") // ✓ Valid (converted to true)
+ *
+ * // Optional with default
+ * const optionalSchema = boolean(false, { defaultValue: false })
+ * ```
+ *
+ * @throws {z.ZodError} When validation fails with specific error messages
+ * @see {@link BooleanOptions} for all available configuration options
+ */
+declare function boolean<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<BooleanOptions<IsRequired>, 'required'>): BooleanSchema<IsRequired>;
+
+export { type BooleanMessages, type BooleanOptions, type BooleanSchema, boolean };

package/dist/common/boolean.js

@@ -0,0 +1,7 @@
+import {
+  boolean
+} from "../chunk-42C5OHRK.js";
+import "../chunk-6AAP4LPF.js";
+export {
+  boolean
+};

package/dist/common/color.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkUBK3VCVHcjs = require('../chunk-UBK3VCVH.cjs');
+require('../chunk-UCOXAZJF.cjs');
+
+
+
+exports.color = _chunkUBK3VCVHcjs.color; exports.validateColor = _chunkUBK3VCVHcjs.validateColor;

package/dist/common/color.d.cts

@@ -0,0 +1,26 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.cjs';
+
+type ColorFormat = "hex" | "rgb" | "hsl" | "any";
+type ColorMessages = {
+    required?: string;
+    invalid?: string;
+    notHex?: string;
+    notRgb?: string;
+    notHsl?: string;
+};
+type ColorOptions<IsRequired extends boolean = true> = {
+    format?: ColorFormat | ColorFormat[];
+    allowAlpha?: boolean;
+    transform?: (value: string) => string;
+    defaultValue?: IsRequired extends true ? string : string | null;
+    i18n?: Partial<Record<Locale, Partial<ColorMessages>>>;
+};
+type ColorSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+declare function validateColor(value: string, formats: ColorFormat[], allowAlpha: boolean): {
+    valid: boolean;
+    failedFormat?: ColorFormat;
+};
+declare function color<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<ColorOptions<IsRequired>, "required">): ColorSchema<IsRequired>;
+
+export { type ColorFormat, type ColorMessages, type ColorOptions, type ColorSchema, color, validateColor };

package/dist/common/color.d.ts

@@ -0,0 +1,26 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.js';
+
+type ColorFormat = "hex" | "rgb" | "hsl" | "any";
+type ColorMessages = {
+    required?: string;
+    invalid?: string;
+    notHex?: string;
+    notRgb?: string;
+    notHsl?: string;
+};
+type ColorOptions<IsRequired extends boolean = true> = {
+    format?: ColorFormat | ColorFormat[];
+    allowAlpha?: boolean;
+    transform?: (value: string) => string;
+    defaultValue?: IsRequired extends true ? string : string | null;
+    i18n?: Partial<Record<Locale, Partial<ColorMessages>>>;
+};
+type ColorSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+declare function validateColor(value: string, formats: ColorFormat[], allowAlpha: boolean): {
+    valid: boolean;
+    failedFormat?: ColorFormat;
+};
+declare function color<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<ColorOptions<IsRequired>, "required">): ColorSchema<IsRequired>;
+
+export { type ColorFormat, type ColorMessages, type ColorOptions, type ColorSchema, color, validateColor };

package/dist/common/color.js

@@ -0,0 +1,9 @@
+import {
+  color,
+  validateColor
+} from "../chunk-2SWEVDFZ.js";
+import "../chunk-6AAP4LPF.js";
+export {
+  color,
+  validateColor
+};

package/dist/common/coordinate.cjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkRYFG2GKMcjs = require('../chunk-RYFG2GKM.cjs');
+require('../chunk-UCOXAZJF.cjs');
+
+
+
+
+exports.coordinate = _chunkRYFG2GKMcjs.coordinate; exports.validateLatitude = _chunkRYFG2GKMcjs.validateLatitude; exports.validateLongitude = _chunkRYFG2GKMcjs.validateLongitude;

package/dist/common/coordinate.d.cts

@@ -0,0 +1,23 @@
+import { ZodString, ZodNullable } from 'zod';
+import { L as Locale } from '../config-CABSSvAp.cjs';
+
+type CoordinateType = "latitude" | "longitude" | "pair";
+type CoordinateMessages = {
+    required?: string;
+    invalid?: string;
+    invalidLatitude?: string;
+    invalidLongitude?: string;
+};
+type CoordinateOptions<IsRequired extends boolean = true> = {
+    type?: CoordinateType;
+    precision?: number;
+    transform?: (value: string) => string;
+    defaultValue?: IsRequired extends true ? string : string | null;
+    i18n?: Partial<Record<Locale, Partial<CoordinateMessages>>>;
+};
+type CoordinateSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>;
+declare function validateLatitude(value: number): boolean;
+declare function validateLongitude(value: number): boolean;
+declare function coordinate<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<CoordinateOptions<IsRequired>, "required">): CoordinateSchema<IsRequired>;
+
+export { type CoordinateMessages, type CoordinateOptions, type CoordinateSchema, type CoordinateType, coordinate, validateLatitude, validateLongitude };