@zairakai/js-utils 1.0.0

package/dist/chunk-W6JEMFAF.js

@@ -0,0 +1,54 @@
+// src/schemas.ts
+import { z } from "zod";
+var EmailSchema = z.string().email("Invalid email format").min(1, "Email is required");
+var PhoneSchema = z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number format");
+var UrlSchema = z.string().url("Invalid URL format");
+var DateSchema = z.union([
+  z.string().datetime(),
+  z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Invalid date format (YYYY-MM-DD)"),
+  z.date()
+]);
+var ApiResponseSchema = (dataSchema) => z.object({
+  success: z.boolean(),
+  data: dataSchema.optional(),
+  message: z.string().optional(),
+  errors: z.array(z.string()).optional()
+});
+var PaginationSchema = z.object({
+  page: z.number().int().positive().default(1),
+  perPage: z.number().int().min(1).max(100).default(15),
+  total: z.number().int().nonnegative(),
+  lastPage: z.number().int().positive()
+});
+var PaginatedResponseSchema = (itemSchema) => z.object({
+  data: z.array(itemSchema),
+  pagination: PaginationSchema
+});
+var validateSchema = (schema, data) => {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    const errors = result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+    throw new Error(`Validation failed: ${errors.join(", ")}`);
+  }
+  return result.data;
+};
+var safeValidateSchema = (schema, data) => {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+  return { success: false, errors };
+};
+
+export {
+  EmailSchema,
+  PhoneSchema,
+  UrlSchema,
+  DateSchema,
+  ApiResponseSchema,
+  PaginationSchema,
+  PaginatedResponseSchema,
+  validateSchema,
+  safeValidateSchema
+};

package/dist/chunk-XEJLBAXE.js

@@ -0,0 +1,164 @@
+// src/validators.ts
+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);
+};
+
+export {
+  isTrue,
+  isFalse,
+  isNull,
+  isUndefined,
+  isSet,
+  isArray,
+  isObject,
+  isString,
+  isNumber,
+  isInteger,
+  isFloat,
+  isBoolean,
+  isFunction,
+  isDate,
+  isNumeric,
+  isEmail,
+  isUrl,
+  isEmpty,
+  isNotEmpty,
+  isBlank,
+  isPresent,
+  filled,
+  blank,
+  isEven,
+  isOdd,
+  isJson,
+  isBase64,
+  isMacAddress,
+  isUuid,
+  isIp
+};

package/dist/chunk-Z7G3SIQH.js

@@ -0,0 +1,270 @@
+import {
+  data_get,
+  data_set
+} from "./chunk-ZJPKS2MQ.js";
+import {
+  diff,
+  isEqual
+} from "./chunk-LDSWHSRX.js";
+
+// src/obj.ts
+var Objectable = class _Objectable {
+  /**
+   * Create a new Objectable instance.
+   *
+   * @param {T} value The initial object value
+   */
+  constructor(value) {
+    this.value = structuredClone(value);
+    this.originalValue = structuredClone(value);
+  }
+  /**
+   * Get the current object state.
+   *
+   * @returns {T} The current object
+   */
+  toObject() {
+    return this.value;
+  }
+  /**
+   * Alias for toObject().
+   *
+   * @returns {T} The current object
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Get the original state from construction.
+   *
+   * @returns {T} The original object
+   */
+  getOriginal() {
+    return this.originalValue;
+  }
+  /**
+   * Sync original state with current state (marking it as clean).
+   *
+   * @returns {this} The Objectable instance
+   */
+  syncOriginal() {
+    this.originalValue = structuredClone(this.value);
+    return this;
+  }
+  /**
+   * Determine if any attribute has been modified.
+   *
+   * @param {string} [key] Optional key to check specifically
+   * @returns {boolean} True if dirty, false otherwise
+   */
+  isDirty(key) {
+    if (key) {
+      return !isEqual(data_get(this.originalValue, key), data_get(this.value, key));
+    }
+    return !isEqual(this.originalValue, this.value);
+  }
+  /**
+   * Determine if the object is equivalent to its original state.
+   *
+   * @param {string} [key] Optional key to check specifically
+   * @returns {boolean} True if clean, false otherwise
+   */
+  isClean(key) {
+    return !this.isDirty(key);
+  }
+  /**
+   * Get the attributes that have been modified.
+   *
+   * @returns {Partial<T>} The dirty attributes
+   */
+  getDirty() {
+    return diff(this.originalValue, this.value);
+  }
+  /**
+   * Get a value by dot notation.
+   *
+   * @param {string} key The key to retrieve
+   * @param {unknown} [defaultValue=null] The default value if not found
+   * @returns {unknown} The retrieved value
+   */
+  dataGet(key, defaultValue = null) {
+    return data_get(this.value, key, defaultValue);
+  }
+  /**
+   * Set a value by dot notation.
+   *
+   * @param {string} key The key to set
+   * @param {unknown} value The value to set
+   * @returns {this} The Objectable instance
+   */
+  dataSet(key, value) {
+    data_set(this.value, key, value);
+    return this;
+  }
+  /**
+   * Get only specified keys.
+   *
+   * @param {K[]} keys The keys to include
+   * @returns {Objectable<Pick<T, K>>} A new Objectable instance
+   */
+  only(keys) {
+    const result = {};
+    keys.forEach((key) => {
+      const k = key;
+      if (k in this.value) {
+        result[k] = this.value[k];
+      }
+    });
+    return new _Objectable(result);
+  }
+  /**
+   * Get all keys except specified ones.
+   *
+   * @param {K[]} keys The keys to exclude
+   * @returns {Objectable<Omit<T, K>>} A new Objectable instance
+   */
+  except(keys) {
+    const result = { ...this.value };
+    keys.forEach((key) => {
+      const k = key;
+      delete result[k];
+    });
+    return new _Objectable(result);
+  }
+  /**
+   * Map over object entries.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {Record<string, U>} The resulting object
+   */
+  map(callback) {
+    const result = {};
+    for (const [key, val] of Object.entries(this.value)) {
+      result[key] = callback(val, key);
+    }
+    return result;
+  }
+  /**
+   * Filter object entries.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {this} The Objectable instance
+   */
+  filter(callback) {
+    const result = {};
+    for (const [key, val] of Object.entries(this.value)) {
+      if (callback(val, key)) {
+        result[key] = val;
+      }
+    }
+    this.value = result;
+    return this;
+  }
+  /**
+   * Merge with another object.
+   *
+   * @param {U} other The object to merge with
+   * @returns {Objectable<T & U>} A new Objectable instance
+   */
+  merge(other) {
+    return new _Objectable({ ...this.value, ...other });
+  }
+  /**
+   * Deep merge with another object (non-mutating on source).
+   *
+   * @param {Record<string, unknown>} other The object to deep merge with
+   * @returns {this} The Objectable instance
+   */
+  mergeDeep(other) {
+    const merge = (target, source) => {
+      const result = { ...target };
+      for (const key of Object.keys(source)) {
+        const srcVal = source[key];
+        const tgtVal = target[key];
+        if (srcVal !== null && "object" === typeof srcVal && !Array.isArray(srcVal) && tgtVal !== null && "object" === typeof tgtVal && !Array.isArray(tgtVal)) {
+          result[key] = merge(tgtVal, srcVal);
+        } else {
+          result[key] = srcVal;
+        }
+      }
+      return result;
+    };
+    this.value = merge(this.value, other);
+    return this;
+  }
+  /**
+   * Check if object has key.
+   *
+   * @param {string} key The key to check
+   * @returns {boolean} True if key exists
+   */
+  has(key) {
+    return key in this.value;
+  }
+  /**
+   * Get keys.
+   *
+   * @returns {string[]} The object keys
+   */
+  keys() {
+    return Object.keys(this.value);
+  }
+  /**
+   * Get values.
+   *
+   * @returns {unknown[]} The object values
+   */
+  values() {
+    return Object.values(this.value);
+  }
+  /**
+   * Clone the object.
+   *
+   * @returns {Objectable<T>} A new cloned Objectable instance
+   */
+  clone() {
+    return new _Objectable(structuredClone(this.value));
+  }
+  /**
+   * Pipe to a callback.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {U} The result of the callback
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Execute callback if condition is met.
+   *
+   * @param {boolean | Function} condition The condition to check
+   * @param {Function} callback The callback to execute
+   * @returns {this} The Objectable instance
+   */
+  when(condition, callback) {
+    const shouldExecute = "function" === typeof condition ? condition() : condition;
+    if (shouldExecute) {
+      callback(this);
+    }
+    return this;
+  }
+};
+var obj = (value) => {
+  return new Objectable(value);
+};
+var Obj = {
+  /** Create a new Objectable instance */
+  of: (value) => new Objectable(value),
+  /** Get object keys */
+  keys: (value) => Object.keys(value),
+  /** Get object values */
+  values: (value) => Object.values(value),
+  /** Merge objects */
+  merge: (target, ...sources) => Object.assign({}, target, ...sources)
+};
+
+export {
+  Objectable,
+  obj,
+  Obj
+};

package/dist/chunk-ZJPKS2MQ.js

@@ -0,0 +1,101 @@
+// src/runtime.ts
+function isRecord(value2) {
+  return null !== value2 && "object" === typeof value2 && !Array.isArray(value2);
+}
+var tap = (value2, callback) => {
+  callback(value2);
+  return value2;
+};
+var when = (condition, onTrue, onFalse) => {
+  const shouldExecute = "function" === typeof condition ? condition() : Boolean(condition);
+  if (shouldExecute) {
+    return onTrue();
+  } else if (onFalse) {
+    return onFalse();
+  }
+  return void 0;
+};
+var value = (val) => {
+  return "function" === typeof val ? val() : val;
+};
+var data_get = (target, key, defaultValue = null) => {
+  if (!isRecord(target) && !Array.isArray(target)) {
+    return defaultValue;
+  }
+  const parts = Array.isArray(key) ? key : key.split(".");
+  let result = target;
+  for (const part of parts) {
+    if (!isRecord(result) && !Array.isArray(result)) {
+      return defaultValue;
+    }
+    if (part in result) {
+      result = result[part];
+    } else {
+      return defaultValue;
+    }
+  }
+  return result;
+};
+var data_set = (target, key, value2) => {
+  if (!isRecord(target) && !Array.isArray(target)) {
+    return target;
+  }
+  const parts = Array.isArray(key) ? key : key.split(".");
+  let current = target;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!isRecord(current)) {
+      break;
+    }
+    const currentRecord = current;
+    if (!(part in currentRecord) || !isRecord(currentRecord[part])) {
+      currentRecord[part] = {};
+    }
+    current = currentRecord[part];
+  }
+  if (isRecord(current)) {
+    ;
+    current[parts[parts.length - 1]] = value2;
+  }
+  return target;
+};
+var optional = (value2) => {
+  return value2 ?? null;
+};
+var retry = async (times, callback, sleepMilliseconds = 0) => {
+  let lastError;
+  for (let attempt = 1; attempt <= times; attempt++) {
+    try {
+      return await callback(attempt);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < times && 0 < sleepMilliseconds) {
+        await new Promise((resolve) => setTimeout(resolve, sleepMilliseconds));
+      }
+    }
+  }
+  throw lastError ?? new Error(`Retry failed after ${times} attempts`);
+};
+var throw_if = (condition, exception) => {
+  if ("function" === typeof condition ? condition() : Boolean(condition)) {
+    throw "string" === typeof exception ? new Error(exception) : exception;
+  }
+};
+var throw_unless = (condition, exception) => {
+  if (!("function" === typeof condition ? condition() : Boolean(condition))) {
+    throw "string" === typeof exception ? new Error(exception) : exception;
+  }
+};
+
+export {
+  isRecord,
+  tap,
+  when,
+  value,
+  data_get,
+  data_set,
+  optional,
+  retry,
+  throw_if,
+  throw_unless
+};