@zairakai/js-utils 1.0.0

package/dist/validator.cjs

@@ -0,0 +1,251 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/validator.ts
+var validator_exports = {};
+__export(validator_exports, {
+  ValidationInstance: () => ValidationInstance,
+  Validator: () => Validator,
+  validator: () => validator
+});
+module.exports = __toCommonJS(validator_exports);
+var import_zod = require("zod");
+
+// src/equals.ts
+var isEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && "object" === typeof a && "object" === typeof b) {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (Array.isArray(a)) {
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!isEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const [key, val] of a) {
+        if (!b.has(key) || !isEqual(val, b.get(key))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const val of a) {
+        if (!b.has(val)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a.constructor === RegExp) {
+      return a.source === b.source && a.flags === b.flags;
+    }
+    if (a.valueOf !== Object.prototype.valueOf) {
+      return a.valueOf() === b.valueOf();
+    }
+    if (a.toString !== Object.prototype.toString) {
+      return a.toString() === b.toString();
+    }
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) {
+      return false;
+    }
+    const bObj = b;
+    const aObj = a;
+    for (const key of keys) {
+      if (!Object.prototype.hasOwnProperty.call(bObj, key)) {
+        return false;
+      }
+      if (!isEqual(aObj[key], bObj[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+};
+var diff = (original, current) => {
+  const result = {};
+  if (isEqual(original, current)) {
+    return result;
+  }
+  if (!original || !current || "object" !== typeof original || "object" !== typeof current) {
+    return current || {};
+  }
+  const originalObj = original;
+  const currentObj = current;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(originalObj), ...Object.keys(currentObj)]);
+  for (const key of keys) {
+    if (!isEqual(originalObj[key], currentObj[key])) {
+      if (originalObj[key] && currentObj[key] && "object" === typeof originalObj[key] && "object" === typeof currentObj[key] && !Array.isArray(originalObj[key])) {
+        result[key] = diff(originalObj[key], currentObj[key]);
+      } else {
+        result[key] = currentObj[key];
+      }
+    }
+  }
+  return result;
+};
+
+// src/validator.ts
+var Validator = class {
+  /**
+   * Create a new validation instance
+   *
+   * @param {unknown} data The data to validate
+   * @param {T | z.ZodObject<T>} rules The validation rules (Zod shape or object)
+   * @returns {ValidationInstance<z.ZodObject<T>>} A new ValidationInstance
+   */
+  static make(data, rules) {
+    const schema = rules instanceof import_zod.z.ZodObject ? rules : import_zod.z.object(rules);
+    return new ValidationInstance(data, schema);
+  }
+  /**
+   * Validate data against rules and throw if it fails
+   *
+   * @param {unknown} data The data to validate
+   * @param {T | z.ZodObject<T>} rules The validation rules (Zod shape or object)
+   * @returns {z.infer<z.ZodObject<T>>} The validated data
+   * @throws {z.ZodError} If validation fails
+   */
+  static validate(data, rules) {
+    const schema = rules instanceof import_zod.z.ZodObject ? rules : import_zod.z.object(rules);
+    return schema.parse(data);
+  }
+  /**
+   * Compare two objects for equality
+   *
+   * @param {unknown} a First object
+   * @param {unknown} b Second object
+   * @returns {boolean} True if the objects are equal
+   */
+  static isEqual(a, b) {
+    return isEqual(a, b);
+  }
+  /**
+   * Get the differences between two objects
+   *
+   * @param {unknown} a First object
+   * @param {unknown} b Second object
+   * @returns {GenericRecord} An object containing the differences
+   */
+  static diff(a, b) {
+    return diff(a, b);
+  }
+};
+var ValidationInstance = class {
+  constructor(data, schema) {
+    this.data = data;
+    this.schema = schema;
+    this.result = this.schema.safeParse(this.data);
+  }
+  /**
+   * Check if validation failed
+   *
+   * @returns {boolean} True if validation failed
+   */
+  fails() {
+    return !this.result.success;
+  }
+  /**
+   * Check if validation passed
+   *
+   * @returns {boolean} True if validation passed
+   */
+  passes() {
+    return this.result.success;
+  }
+  /**
+   * Get validation errors
+   *
+   * @returns {Record<string, string[]>} An object with field names as keys and arrays of error messages as values
+   */
+  errors() {
+    if (this.result.success) {
+      return {};
+    }
+    const errors = {};
+    this.result.error.issues.forEach((err) => {
+      const path = err.path.join(".") || "root";
+      if (!errors[path]) {
+        errors[path] = [];
+      }
+      errors[path].push(err.message);
+    });
+    return errors;
+  }
+  /**
+   * Get the first error message for a given field
+   *
+   * @param {string} field The field name
+   * @returns {string | undefined} The first error message or undefined
+   */
+  firstError(field) {
+    const fieldErrors = this.errors()[field];
+    return fieldErrors ? fieldErrors[0] : void 0;
+  }
+  /**
+   * Get the validated data
+   *
+   * @returns {z.infer<T>} The validated data
+   * @throws {Error} If validation failed
+   */
+  validated() {
+    if (!this.result.success) {
+      throw new Error("Validation failed");
+    }
+    return this.result.data;
+  }
+  /**
+   * Get all error messages as a flat array
+   *
+   * @returns {string[]} An array of all error messages
+   */
+  allErrors() {
+    if (this.result.success) {
+      return [];
+    }
+    return this.result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+  }
+};
+var validator = (data, rules) => {
+  return Validator.make(data, rules);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ValidationInstance,
+  Validator,
+  validator
+});

package/dist/validator.d.cts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { GenericRecord } from './types.cjs';
+
+/**
+ * Validator class inspired by Laravel's Validator facade
+ * Uses Zod under the hood for robust runtime validation
+ */
+declare class Validator {
+    /**
+     * Create a new validation instance
+     *
+     * @param {unknown} data The data to validate
+     * @param {T | z.ZodObject<T>} rules The validation rules (Zod shape or object)
+     * @returns {ValidationInstance<z.ZodObject<T>>} A new ValidationInstance
+     */
+    static make<T extends z.ZodRawShape>(data: unknown, rules: T | z.ZodObject<T>): ValidationInstance<z.ZodObject<T, z.core.$strip>>;
+    /**
+     * Validate data against rules and throw if it fails
+     *
+     * @param {unknown} data The data to validate
+     * @param {T | z.ZodObject<T>} rules The validation rules (Zod shape or object)
+     * @returns {z.infer<z.ZodObject<T>>} The validated data
+     * @throws {z.ZodError} If validation fails
+     */
+    static validate<T extends z.ZodRawShape>(data: unknown, rules: T | z.ZodObject<T>): z.core.$InferObjectOutput<T, {}>;
+    /**
+     * Compare two objects for equality
+     *
+     * @param {unknown} a First object
+     * @param {unknown} b Second object
+     * @returns {boolean} True if the objects are equal
+     */
+    static isEqual(a: unknown, b: unknown): boolean;
+    /**
+     * Get the differences between two objects
+     *
+     * @param {unknown} a First object
+     * @param {unknown} b Second object
+     * @returns {GenericRecord} An object containing the differences
+     */
+    static diff(a: unknown, b: unknown): GenericRecord;
+}
+/**
+ * Individual validation instance
+ */
+declare class ValidationInstance<T extends z.ZodTypeAny> {
+    private data;
+    private schema;
+    private result;
+    constructor(data: unknown, schema: T);
+    /**
+     * Check if validation failed
+     *
+     * @returns {boolean} True if validation failed
+     */
+    fails(): boolean;
+    /**
+     * Check if validation passed
+     *
+     * @returns {boolean} True if validation passed
+     */
+    passes(): boolean;
+    /**
+     * Get validation errors
+     *
+     * @returns {Record<string, string[]>} An object with field names as keys and arrays of error messages as values
+     */
+    errors(): Record<string, string[]>;
+    /**
+     * Get the first error message for a given field
+     *
+     * @param {string} field The field name
+     * @returns {string | undefined} The first error message or undefined
+     */
+    firstError(field: string): string | undefined;
+    /**
+     * Get the validated data
+     *
+     * @returns {z.infer<T>} The validated data
+     * @throws {Error} If validation failed
+     */
+    validated(): z.infer<T>;
+    /**
+     * Get all error messages as a flat array
+     *
+     * @returns {string[]} An array of all error messages
+     */
+    allErrors(): string[];
+}
+/**
+ * Helper function to create a validator
+ *
+ * @param {unknown} data The data to validate
+ * @param {T | z.ZodObject<T>} rules The validation rules
+ * @returns {ValidationInstance<z.ZodObject<T>>} A new ValidationInstance
+ */
+declare const validator: <T extends z.ZodRawShape>(data: unknown, rules: T | z.ZodObject<T>) => ValidationInstance<z.ZodObject<T, z.core.$strip>>;
+
+export { ValidationInstance, Validator, validator };

package/dist/validator.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { GenericRecord } from './types.js';
+
+/**
+ * Validator class inspired by Laravel's Validator facade
+ * Uses Zod under the hood for robust runtime validation
+ */
+declare class Validator {
+    /**
+     * Create a new validation instance
+     *
+     * @param {unknown} data The data to validate
+     * @param {T | z.ZodObject<T>} rules The validation rules (Zod shape or object)
+     * @returns {ValidationInstance<z.ZodObject<T>>} A new ValidationInstance
+     */
+    static make<T extends z.ZodRawShape>(data: unknown, rules: T | z.ZodObject<T>): ValidationInstance<z.ZodObject<T, z.core.$strip>>;
+    /**
+     * Validate data against rules and throw if it fails
+     *
+     * @param {unknown} data The data to validate
+     * @param {T | z.ZodObject<T>} rules The validation rules (Zod shape or object)
+     * @returns {z.infer<z.ZodObject<T>>} The validated data
+     * @throws {z.ZodError} If validation fails
+     */
+    static validate<T extends z.ZodRawShape>(data: unknown, rules: T | z.ZodObject<T>): z.core.$InferObjectOutput<T, {}>;
+    /**
+     * Compare two objects for equality
+     *
+     * @param {unknown} a First object
+     * @param {unknown} b Second object
+     * @returns {boolean} True if the objects are equal
+     */
+    static isEqual(a: unknown, b: unknown): boolean;
+    /**
+     * Get the differences between two objects
+     *
+     * @param {unknown} a First object
+     * @param {unknown} b Second object
+     * @returns {GenericRecord} An object containing the differences
+     */
+    static diff(a: unknown, b: unknown): GenericRecord;
+}
+/**
+ * Individual validation instance
+ */
+declare class ValidationInstance<T extends z.ZodTypeAny> {
+    private data;
+    private schema;
+    private result;
+    constructor(data: unknown, schema: T);
+    /**
+     * Check if validation failed
+     *
+     * @returns {boolean} True if validation failed
+     */
+    fails(): boolean;
+    /**
+     * Check if validation passed
+     *
+     * @returns {boolean} True if validation passed
+     */
+    passes(): boolean;
+    /**
+     * Get validation errors
+     *
+     * @returns {Record<string, string[]>} An object with field names as keys and arrays of error messages as values
+     */
+    errors(): Record<string, string[]>;
+    /**
+     * Get the first error message for a given field
+     *
+     * @param {string} field The field name
+     * @returns {string | undefined} The first error message or undefined
+     */
+    firstError(field: string): string | undefined;
+    /**
+     * Get the validated data
+     *
+     * @returns {z.infer<T>} The validated data
+     * @throws {Error} If validation failed
+     */
+    validated(): z.infer<T>;
+    /**
+     * Get all error messages as a flat array
+     *
+     * @returns {string[]} An array of all error messages
+     */
+    allErrors(): string[];
+}
+/**
+ * Helper function to create a validator
+ *
+ * @param {unknown} data The data to validate
+ * @param {T | z.ZodObject<T>} rules The validation rules
+ * @returns {ValidationInstance<z.ZodObject<T>>} A new ValidationInstance
+ */
+declare const validator: <T extends z.ZodRawShape>(data: unknown, rules: T | z.ZodObject<T>) => ValidationInstance<z.ZodObject<T, z.core.$strip>>;
+
+export { ValidationInstance, Validator, validator };

package/dist/validator.js

@@ -0,0 +1,11 @@
+import {
+  ValidationInstance,
+  Validator,
+  validator
+} from "./chunk-IPP7PA6H.js";
+import "./chunk-LDSWHSRX.js";
+export {
+  ValidationInstance,
+  Validator,
+  validator
+};

package/dist/validators.cjs

@@ -0,0 +1,217 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/validators.ts
+var validators_exports = {};
+__export(validators_exports, {
+  blank: () => blank,
+  filled: () => filled,
+  isArray: () => isArray,
+  isBase64: () => isBase64,
+  isBlank: () => isBlank,
+  isBoolean: () => isBoolean,
+  isDate: () => isDate,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  isEven: () => isEven,
+  isFalse: () => isFalse,
+  isFloat: () => isFloat,
+  isFunction: () => isFunction,
+  isInteger: () => isInteger,
+  isIp: () => isIp,
+  isJson: () => isJson,
+  isMacAddress: () => isMacAddress,
+  isNotEmpty: () => isNotEmpty,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isNumeric: () => isNumeric,
+  isObject: () => isObject,
+  isOdd: () => isOdd,
+  isPresent: () => isPresent,
+  isSet: () => isSet,
+  isString: () => isString,
+  isTrue: () => isTrue,
+  isUndefined: () => isUndefined,
+  isUrl: () => isUrl,
+  isUuid: () => isUuid
+});
+module.exports = __toCommonJS(validators_exports);
+var isTrue = (value) => true === value;
+var isFalse = (value) => false === value;
+var isNull = (value) => null === value;
+var isUndefined = (value) => void 0 === value;
+var isSet = (value) => void 0 !== value && null !== value;
+var isArray = (value) => Array.isArray(value);
+var isObject = (value) => "object" === typeof value && null !== value && !Array.isArray(value);
+var isString = (value) => "string" === typeof value;
+var isNumber = (value) => "number" === typeof value && !isNaN(value);
+var isInteger = (value) => Number.isInteger(value);
+var isFloat = (value) => "number" === typeof value && !isNaN(value) && !Number.isInteger(value);
+var isBoolean = (value) => "boolean" === typeof value;
+var isFunction = (value) => "function" === typeof value;
+var isDate = (value) => value instanceof Date && !isNaN(value.getTime());
+var isNumeric = (value) => {
+  if ("number" === typeof value) {
+    return !isNaN(value) && isFinite(value);
+  }
+  if ("string" === typeof value) {
+    const num = Number(value.trim());
+    return "" !== value.trim() && !isNaN(num) && isFinite(num);
+  }
+  return false;
+};
+var isEmail = (value) => {
+  if ("string" !== typeof value) {
+    return false;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value);
+};
+var isUrl = (value) => {
+  if ("string" !== typeof value) {
+    return false;
+  }
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isEmpty = (value) => {
+  if (isNull(value) || isUndefined(value)) {
+    return true;
+  }
+  if (isString(value)) {
+    return 0 === value.trim().length;
+  }
+  if (isArray(value)) {
+    return 0 === value.length;
+  }
+  if (isObject(value)) {
+    return 0 === Object.keys(value).length;
+  }
+  if (isNumber(value)) {
+    return 0 === value;
+  }
+  if (isBoolean(value)) {
+    return isFalse(value);
+  }
+  return false;
+};
+var isNotEmpty = (value) => !isEmpty(value);
+var isBlank = (value) => {
+  if (value == null) {
+    return true;
+  }
+  if ("string" === typeof value) {
+    return "" === value.trim();
+  }
+  return isEmpty(value);
+};
+var isPresent = (value) => !isBlank(value);
+var filled = (value) => isPresent(value);
+var blank = (value) => isBlank(value);
+var isEven = (value) => {
+  return isNumber(value) && 0 === value % 2;
+};
+var isOdd = (value) => {
+  return isNumber(value) && 0 !== value % 2;
+};
+var isJson = (value) => {
+  if ("string" !== typeof value) {
+    return false;
+  }
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isBase64 = (value) => {
+  if ("string" !== typeof value) {
+    return false;
+  }
+  const base64Pattern = /^[A-Za-z0-9+/]*={0,2}$/;
+  if (0 !== value.length % 4) {
+    return false;
+  }
+  return base64Pattern.test(value);
+};
+var isMacAddress = (value) => {
+  if ("string" !== typeof value) {
+    return false;
+  }
+  const macPattern = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/;
+  return macPattern.test(value);
+};
+var isUuid = (value) => {
+  if ("string" !== typeof value) {
+    return false;
+  }
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+};
+var isIp = (value) => {
+  if ("string" !== typeof value) {
+    return false;
+  }
+  const ipv4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+  if (ipv4.test(value)) {
+    return value.split(".").every((part) => {
+      const n = Number(part);
+      return n >= 0 && n <= 255 && String(n) === part;
+    });
+  }
+  const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|(([0-9a-fA-F]{1,4}:){0,7}:)|(:[0-9a-fA-F]{1,4}){1,7}|(([0-9a-fA-F]{1,4}:){1,7}:)|(([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4})|::1)$/;
+  return ipv6.test(value);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blank,
+  filled,
+  isArray,
+  isBase64,
+  isBlank,
+  isBoolean,
+  isDate,
+  isEmail,
+  isEmpty,
+  isEven,
+  isFalse,
+  isFloat,
+  isFunction,
+  isInteger,
+  isIp,
+  isJson,
+  isMacAddress,
+  isNotEmpty,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isOdd,
+  isPresent,
+  isSet,
+  isString,
+  isTrue,
+  isUndefined,
+  isUrl,
+  isUuid
+});