@zairakai/js-utils 1.0.0

package/dist/chunk-G7ZJ23DW.js

@@ -0,0 +1,253 @@
+// src/number.ts
+var Numberable = class {
+  /**
+   * Create a new Numberable instance.
+   *
+   * @param {unknown} value The initial value
+   */
+  constructor(value) {
+    this.value = Number(value ?? 0);
+    if (isNaN(this.value)) {
+      this.value = 0;
+    }
+  }
+  /**
+   * Get the raw number value.
+   *
+   * @returns {number} The raw value
+   */
+  toNumber() {
+    return this.value;
+  }
+  /**
+   * Alias for toNumber().
+   *
+   * @returns {number} The raw value
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Format the number with locale-specific formatting.
+   *
+   * @param {number} [decimals=0] The number of decimal points
+   * @param {string} [locale='en-US'] The locale to use for formatting
+   * @returns {string} The formatted number
+   */
+  format(decimals = 0, locale = "en-US") {
+    return new Intl.NumberFormat(locale, {
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    }).format(this.value);
+  }
+  /**
+   * Format the number as currency.
+   *
+   * @param {string} [currency='USD'] The currency code (e.g., 'USD', 'EUR')
+   * @param {string} [locale='en-US'] The locale to use for formatting
+   * @returns {string} The formatted currency string
+   */
+  currency(currency = "USD", locale = "en-US") {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency
+    }).format(this.value);
+  }
+  /**
+   * Format the number as a percentage.
+   *
+   * @param {number} [decimals=0] The number of decimal points
+   * @param {string} [locale='en-US'] The locale to use for formatting
+   * @returns {string} The formatted percentage string
+   */
+  percentage(decimals = 0, locale = "en-US") {
+    return new Intl.NumberFormat(locale, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    }).format(this.value / 100);
+  }
+  /**
+   * Format the number as a human-readable file size.
+   *
+   * @param {number} [precision=2] The number of decimal points
+   * @returns {string} The formatted file size (e.g., "1.50 MB")
+   */
+  fileSize(precision = 2) {
+    if (0 === this.value) {
+      return "0 B";
+    }
+    const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const i = Math.floor(Math.log(this.value) / Math.log(1024));
+    return `${parseFloat((this.value / Math.pow(1024, i)).toFixed(precision))} ${units[i]}`;
+  }
+  /**
+   * Abbreviate the number (e.g., 1K, 1M, 1B).
+   *
+   * @param {number} [precision=1] The number of decimal points
+   * @returns {string} The abbreviated number
+   */
+  abbreviate(precision = 1) {
+    if (1e3 > this.value) {
+      return String(this.value);
+    }
+    const units = ["", "K", "M", "B", "T"];
+    const i = Math.floor(Math.log10(this.value) / 3);
+    return `${parseFloat((this.value / Math.pow(1e3, i)).toFixed(precision))}${units[i]}`;
+  }
+  /**
+   * Add an ordinal suffix to the number (e.g., 1st, 2nd, 3rd).
+   *
+   * @returns {string} The number with its ordinal suffix
+   */
+  ordinal() {
+    const s = ["th", "st", "nd", "rd"];
+    const v = this.value % 100;
+    return this.value + (s[(v - 20) % 10] || s[v] || s[0]);
+  }
+  /**
+   * Clamp the number between a minimum and maximum value.
+   *
+   * @param {number} min The minimum value
+   * @param {number} max The maximum value
+   * @returns {this} The Numberable instance
+   */
+  clamp(min, max) {
+    this.value = Math.min(Math.max(this.value, min), max);
+    return this;
+  }
+  /**
+   * Check if the number is between a minimum and maximum value.
+   *
+   * @param {number} min The minimum value
+   * @param {number} max The maximum value
+   * @param {boolean} [inclusive=true] Whether to include the boundaries
+   * @returns {boolean} True if the number is between min and max
+   */
+  isBetween(min, max, inclusive = true) {
+    return inclusive ? this.value >= min && this.value <= max : this.value > min && this.value < max;
+  }
+  /**
+   * Add a value to the current number.
+   *
+   * @param {number} value The value to add
+   * @returns {this} The Numberable instance
+   */
+  add(value) {
+    this.value += value;
+    return this;
+  }
+  /**
+   * Subtract a value from the current number.
+   *
+   * @param {number} value The value to subtract
+   * @returns {this} The Numberable instance
+   */
+  sub(value) {
+    this.value -= value;
+    return this;
+  }
+  /**
+   * Multiply the current number by a value.
+   *
+   * @param {number} value The value to multiply by
+   * @returns {this} The Numberable instance
+   */
+  mul(value) {
+    this.value *= value;
+    return this;
+  }
+  /**
+   * Divide the current number by a value.
+   *
+   * @param {number} value The value to divide by
+   * @returns {this} The Numberable instance
+   */
+  div(value) {
+    if (0 !== value) {
+      this.value /= value;
+    }
+    return this;
+  }
+  /**
+   * Round the number to a specified precision.
+   *
+   * @param {number} [precision=0] The number of decimal points
+   * @returns {this} The Numberable instance
+   */
+  round(precision = 0) {
+    const factor = Math.pow(10, precision);
+    this.value = Math.round(this.value * factor) / factor;
+    return this;
+  }
+  /**
+   * Round the number up to a specified precision.
+   *
+   * @param {number} [precision=0] The number of decimal points
+   * @returns {this} The Numberable instance
+   */
+  ceil(precision = 0) {
+    const factor = Math.pow(10, precision);
+    this.value = Math.ceil(this.value * factor) / factor;
+    return this;
+  }
+  /**
+   * Round the number down to a specified precision.
+   *
+   * @param {number} [precision=0] The number of decimal points
+   * @returns {this} The Numberable instance
+   */
+  floor(precision = 0) {
+    const factor = Math.pow(10, precision);
+    this.value = Math.floor(this.value * factor) / factor;
+    return this;
+  }
+  /**
+   * Pipe the current Numberable instance to a callback.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {U} The result of the callback
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Execute a callback if a condition is met.
+   *
+   * @param {boolean | Function} condition The condition to check
+   * @param {Function} callback The callback to execute if condition is true
+   * @returns {this} The Numberable instance
+   */
+  when(condition, callback) {
+    const shouldExecute = "function" === typeof condition ? condition() : condition;
+    if (shouldExecute) {
+      callback(this);
+    }
+    return this;
+  }
+};
+var num = (value) => {
+  return new Numberable(value);
+};
+var NumberHelper = {
+  /** Create a new Numberable instance */
+  of: (value) => new Numberable(value),
+  /** Format the number with locale-specific formatting */
+  format: (value, decimals = 0, locale = "en-US") => new Numberable(value).format(decimals, locale),
+  /** Format the number as currency */
+  currency: (value, currency = "USD", locale = "en-US") => new Numberable(value).currency(currency, locale),
+  /** Format the number as a percentage */
+  percentage: (value, decimals = 0, locale = "en-US") => new Numberable(value).percentage(decimals, locale),
+  /** Format the number as a human-readable file size */
+  fileSize: (value, precision = 2) => new Numberable(value).fileSize(precision),
+  /** Abbreviate the number */
+  abbreviate: (value, precision = 1) => new Numberable(value).abbreviate(precision),
+  /** Add an ordinal suffix to the number */
+  ordinal: (value) => new Numberable(value).ordinal()
+};
+
+export {
+  Numberable,
+  num,
+  NumberHelper
+};

package/dist/chunk-IPP7PA6H.js

@@ -0,0 +1,136 @@
+import {
+  diff,
+  isEqual
+} from "./chunk-LDSWHSRX.js";
+
+// src/validator.ts
+import { z } from "zod";
+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 z.ZodObject ? rules : 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 z.ZodObject ? rules : 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);
+};
+
+export {
+  Validator,
+  ValidationInstance,
+  validator
+};

package/dist/chunk-LDSWHSRX.js

@@ -0,0 +1,96 @@
+// 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;
+};
+
+export {
+  isEqual,
+  diff
+};