@cyberskill/shared 1.217.0 → 2.0.0

package/dist/react/storage/storage.hook.js

@@ -2,75 +2,73 @@ import { useState as h, useEffect as y, useCallback as z } from "react";
 import { storage as i } from "./storage.util.js";
 import { serializer as E } from "../../util/serializer/serializer.util.js";
 import { catchError as m } from "../log/log.util.js";
-var p = (o, l, t) => new Promise((c, r) => {
-  var a = (s) => {
+var p = (r, l, t) => new Promise((n, o) => {
+  var f = (s) => {
     try {
       u(t.next(s));
     } catch (e) {
-      r(e);
+      o(e);
     }
-  }, f = (s) => {
+  }, a = (s) => {
     try {
       u(t.throw(s));
     } catch (e) {
-      r(e);
+      o(e);
     }
-  }, u = (s) => s.done ? c(s.value) : Promise.resolve(s.value).then(a, f);
-  u((t = t.apply(o, l)).next());
+  }, u = (s) => s.done ? n(s.value) : Promise.resolve(s.value).then(f, a);
+  u((t = t.apply(r, l)).next());
 });
-function b(o, l, t = E) {
-  const [c, r] = h(l), [a, f] = h(!1);
+function b(r, l, t = E) {
+  const [n, o] = h(l), [f, a] = h(!1);
   y(() => {
     let e = !0;
     return p(null, null, function* () {
       try {
-        const d = yield i.get(o);
+        const d = yield i.get(r);
         if (e)
           if (d !== null) {
             const v = t.deserialize(d);
-            r(v);
+            o(v);
           } else if (l !== void 0) {
             const v = t.serialize(l);
-            yield i.set(o, v), r(l);
+            yield i.set(r, v), o(l);
           } else
-            r(void 0);
+            o(void 0);
       } catch (d) {
-        m(d), e && r(l);
+        m(d), e && o(l);
       } finally {
-        e && f(!0);
+        e && a(!0);
       }
     }), () => {
-      e = !1, f(!1);
+      e = !1, a(!1);
     };
-  }, [o, l, t]), y(() => {
-    if (!a)
+  }, [r, l, t]), y(() => {
+    if (!f)
       return;
     p(null, null, function* () {
       try {
-        if (c !== void 0) {
-          const n = t.serialize(c);
-          yield i.set(o, n);
+        if (n !== void 0) {
+          const c = t.serialize(n);
+          yield i.set(r, c);
         }
-      } catch (n) {
-        m(n);
+      } catch (c) {
+        m(c);
       }
     });
-  }, [c, o, t, a]);
+  }, [n, r, t, f]);
   const u = z(
     (e) => {
-      r(
-        (n) => typeof e == "function" ? e(n) : e
-      );
+      o((c) => typeof e == "function" ? e(c) : e);
     },
     []
   ), s = z(() => p(null, null, function* () {
     try {
-      yield i.remove(o), r(void 0);
+      yield i.remove(r), o(void 0);
     } catch (e) {
       m(e);
     }
-  }), [o]);
-  return { value: c, set: u, remove: s };
+  }), [r]);
+  return { value: n, set: u, remove: s };
 }
 export {
   b as useStorage

package/dist/react/storage/storage.util.d.ts

@@ -1,6 +1,45 @@
+/**
+ * Browser storage utility object using localForage for cross-browser compatibility.
+ * This object provides a unified interface for browser storage operations using localForage,
+ * which automatically chooses the best available storage method (IndexedDB, WebSQL, or localStorage)
+ * based on browser capabilities. It includes comprehensive error handling and type safety.
+ */
 export declare const storage: {
+    /**
+     * Retrieves a value from browser storage by key.
+     * This method fetches data that was previously stored using the set method.
+     * Returns null if the key doesn't exist or if an error occurs during retrieval.
+     *
+     * @param key - The unique identifier for the stored value.
+     * @returns A promise that resolves to the stored value or null if not found.
+     */
     get<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Stores a value in browser storage with a unique key.
+     * This method saves data that can be retrieved later using the get method.
+     * The data is automatically handled by localForage which chooses the optimal
+     * storage method for the browser environment.
+     *
+     * @param key - The unique identifier for the value to store.
+     * @param value - The data to store (will be automatically handled by localForage).
+     * @returns A promise that resolves when the storage operation is complete.
+     */
     set<T = unknown>(key: string, value: T): Promise<void>;
+    /**
+     * Removes a value from browser storage by key.
+     * This method permanently deletes the stored data associated with the specified key.
+     * If the key doesn't exist, the operation completes successfully without error.
+     *
+     * @param key - The unique identifier of the value to remove.
+     * @returns A promise that resolves when the removal operation is complete.
+     */
     remove(key: string): Promise<void>;
+    /**
+     * Retrieves all storage keys.
+     * This method returns an array of all keys that currently have stored values.
+     * Returns an empty array if no keys exist or if an error occurs during retrieval.
+     *
+     * @returns A promise that resolves to an array of storage keys.
+     */
     keys(): Promise<string[]>;
 };

package/dist/react/storage/storage.util.js

@@ -17,6 +17,14 @@ var o = (r, e, n) => new Promise((s, i) => {
   c((n = n.apply(r, e)).next());
 });
 const f = {
+  /**
+   * Retrieves a value from browser storage by key.
+   * This method fetches data that was previously stored using the set method.
+   * Returns null if the key doesn't exist or if an error occurs during retrieval.
+   *
+   * @param key - The unique identifier for the stored value.
+   * @returns A promise that resolves to the stored value or null if not found.
+   */
   get(r) {
     return o(this, null, function* () {
       try {
@@ -26,6 +34,16 @@ const f = {
       }
     });
   },
+  /**
+   * Stores a value in browser storage with a unique key.
+   * This method saves data that can be retrieved later using the get method.
+   * The data is automatically handled by localForage which chooses the optimal
+   * storage method for the browser environment.
+   *
+   * @param key - The unique identifier for the value to store.
+   * @param value - The data to store (will be automatically handled by localForage).
+   * @returns A promise that resolves when the storage operation is complete.
+   */
   set(r, e) {
     return o(this, null, function* () {
       try {
@@ -35,6 +53,14 @@ const f = {
       }
     });
   },
+  /**
+   * Removes a value from browser storage by key.
+   * This method permanently deletes the stored data associated with the specified key.
+   * If the key doesn't exist, the operation completes successfully without error.
+   *
+   * @param key - The unique identifier of the value to remove.
+   * @returns A promise that resolves when the removal operation is complete.
+   */
   remove(r) {
     return o(this, null, function* () {
       try {
@@ -44,6 +70,13 @@ const f = {
       }
     });
   },
+  /**
+   * Retrieves all storage keys.
+   * This method returns an array of all keys that currently have stored values.
+   * Returns an empty array if no keys exist or if an error occurs during retrieval.
+   *
+   * @returns A promise that resolves to an array of storage keys.
+   */
   keys() {
     return o(this, null, function* () {
       try {

package/dist/react/userback/userback.component.d.ts

@@ -1,2 +1,20 @@
 import { I_UserBackProps } from './userback.type.js';
+/**
+ * Userback feedback widget component for collecting user feedback.
+ * This component integrates the Userback feedback widget into React applications,
+ * providing a customizable feedback collection interface for users to submit
+ * bug reports, feature requests, and general feedback.
+ *
+ * Features:
+ * - Userback widget integration
+ * - Customizable feedback collection
+ * - Automatic widget initialization
+ * - Token-based configuration
+ * - Responsive design support
+ *
+ * @param props - Component props containing token and options.
+ * @param props.token - The Userback token for widget authentication.
+ * @param props.options - Optional configuration options for the Userback widget.
+ * @returns A React component that renders the Userback feedback widget.
+ */
 export declare function Userback({ token, options }: I_UserBackProps): null;

package/dist/typescript/common.type.d.ts

@@ -1,5 +1,11 @@
 import { default as consola } from 'consola';
+/**
+ * Generic object type with string keys and values of type T (defaults to unknown).
+ */
 export type T_Object<T = unknown> = Record<string, T>;
+/**
+ * Logging interface for browser and Node.js environments, compatible with consola.
+ */
 export interface I_Log {
     silent: typeof consola['silent'];
     level: typeof consola['level'];

package/dist/typescript/index.d.ts

@@ -1,2 +1,5 @@
+/**
+ * Re-exports all common TypeScript types for shared usage across the codebase.
+ */
 export * from './common.type.js';
 export * from './react.type.js';

package/dist/util/common/common.util.d.ts

@@ -1,26 +1,38 @@
 import { I_EnvFlags, I_NodeEnvInput } from './common.type.js';
 /**
  * Convert a string to a regex pattern that matches the string and its accented variations.
- * @param str - The string to convert.
- * @returns The regex pattern as a string.
+ * This function normalizes the input string and creates a regex pattern that can match
+ * both the original characters and their accented equivalents.
+ *
+ * @param str - The string to convert to a regex pattern.
+ * @returns The regex pattern as a string that matches the original string and its accented variations.
  */
 export declare function regexSearchMapper(str: string): string;
 /**
  * Remove accents from a string.
+ * This function normalizes the string using NFD normalization and removes all diacritical marks.
+ *
  * @param str - The string to remove accents from.
- * @returns The string without accents.
+ * @returns The string without any accents or diacritical marks.
  */
 export declare function removeAccent(str: string): string;
 /**
  * Remove duplicates from an array based on a key function.
+ * This function can remove duplicates either by comparing values directly (when no keyFn is provided)
+ * or by using a custom key function to determine uniqueness.
+ *
  * @param arr - The array to remove duplicates from.
- * @param keyFn - A function that returns a unique key for each item in the array.
- * @returns A new array with duplicates removed.
+ * @param keyFn - Optional function that returns a unique key for each item in the array.
+ * @returns A new array with duplicates removed, maintaining the original order.
  */
 export declare function uniqueArray<T>(arr: T[], keyFn?: (item: T) => string | number): T[];
 /**
+ * Map environment variables to boolean flags indicating the current environment.
+ * This function takes NODE_ENV and NODE_ENV_MODE variables and returns flags
+ * indicating whether the current environment is development, staging, or production.
  *
- * @param env - The environment variables to map.
- * @returns  An object containing flags for the environment.
+ * @param env - The environment variables object containing NODE_ENV and NODE_ENV_MODE.
+ * @returns An object containing boolean flags for the environment (IS_DEV, IS_STAG, IS_PROD).
+ * @throws {Error} When NODE_ENV is production but NODE_ENV_MODE is development.
  */
 export declare function mapEnvironment(env: I_NodeEnvInput): I_EnvFlags;

package/dist/util/common/index.d.ts

@@ -1,2 +1,5 @@
+/**
+ * Re-exports all common utility types for shared usage across the codebase.
+ */
 export * from './common.type.js';
 export * from './common.util.js';

package/dist/util/index.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Re-exports all utility modules for shared usage across the codebase.
+ */
 export * from './common/index.js';
 export * from './object/index.js';
 export * from './serializer/index.js';

package/dist/util/object/object.util.d.ts

@@ -1,29 +1,42 @@
 /**
  * Check if a string is a valid JSON string.
- * @param str - The string to check.
+ * This function attempts to parse the string as JSON and returns true if successful,
+ * false if the string is not valid JSON.
+ *
+ * @param str - The string to check for valid JSON format.
  * @returns True if the string is a valid JSON string, false otherwise.
  */
 export declare function isJSON(str: string): boolean;
 /**
- * Gets a nested value from an object.
+ * Gets a nested value from an object using a path array.
+ * This function traverses the object following the provided path and returns
+ * the value at the specified location, or undefined if the path doesn't exist.
+ *
  * @param obj - The object to get the value from.
- * @param path - The path to the value.
- * @returns The value at the specified path, or undefined if it does not exist.
+ * @param path - An array of keys representing the path to the desired value.
+ * @returns The value at the specified path, or undefined if the path doesn't exist.
  */
 export declare function getNestedValue<T>(obj: T, path: (string | number)[]): unknown;
 /**
- * Sets a nested value in an object.
- * If the path does not exist, it will be created.
+ * Sets a nested value in an object using a path array.
+ * This function creates the path if it doesn't exist and sets the value at the specified location.
+ * The function returns a new object with the updated value, maintaining immutability.
+ *
  * @param obj - The object to set the value in.
- * @param path - The path to the value.
- * @param value - The value to set.
- * @returns The updated object.
+ * @param path - An array of keys representing the path to the desired location.
+ * @param value - The value to set at the specified path.
+ * @returns A new object with the updated value at the specified path.
  */
 export declare function setNestedValue<T>(obj: T, path: (string | number)[], value: unknown): T;
 /**
  * Deep merges multiple objects or arrays into a single object or array.
- * If all arguments are arrays, concatenates them.
- * If all are objects, deeply merges (concatenating arrays within objects).
- * Throws if mixed types.
+ * This function handles different types of merging:
+ * - If all arguments are arrays, it concatenates them
+ * - If all arguments are objects, it deeply merges them (concatenating arrays within objects)
+ * - Throws an error if mixed types are provided
+ *
+ * @param args - The objects or arrays to merge.
+ * @returns The merged result - either a concatenated array or a deeply merged object.
+ * @throws {Error} When arguments are mixed types (some arrays, some objects).
  */
 export declare function deepMerge<T = unknown>(...args: T[]): T;

package/dist/util/serializer/serializer.type.d.ts

@@ -1,5 +1,5 @@
 export type T_SerializerKnownTypes = 'Date' | 'Map' | 'Set' | 'RegExp' | 'BigInt';
-export interface T_SerializerValueMap {
+export interface I_SerializerValueMap {
     Date: Date;
     Map: Map<unknown, unknown>;
     Set: Set<unknown>;

package/dist/util/serializer/serializer.util.d.ts

@@ -1,2 +1,10 @@
 import { I_Serializer } from './serializer.type.js';
+/**
+ * A serializer that can handle complex JavaScript types that cannot be directly JSON stringified.
+ * This serializer extends JSON.stringify and JSON.parse to handle types like Date, Map, Set, RegExp, and BigInt.
+ *
+ * The serializer works by:
+ * 1. During serialization: Wrapping special types with type information before JSON stringification
+ * 2. During deserialization: Detecting wrapped types and reconstructing them to their original form
+ */
 export declare const serializer: I_Serializer<unknown>;

package/dist/util/serializer/serializer.util.js

@@ -37,8 +37,8 @@ const n = {
    * it will be serialized using the corresponding handler.
    * Otherwise, it will be serialized as is.
    *
-   * @param value - The value to serialize.
-   * @returns The serialized JSON string.
+   * @param value - The value to serialize to a JSON string.
+   * @returns The serialized JSON string that can be safely stored or transmitted.
    */
   serialize(e) {
     return JSON.stringify(e, (r, i) => {
@@ -56,8 +56,8 @@ const n = {
    * it will be deserialized using the corresponding handler.
    * Otherwise, it will be deserialized as is.
    *
-   * @param json - The JSON string to deserialize.
-   * @returns The deserialized value.
+   * @param json - The JSON string to deserialize back to its original form.
+   * @returns The deserialized value with all special types reconstructed.
    */
   deserialize(e) {
     return JSON.parse(e, (r, i) => {

package/dist/util/string/string.util.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("crypto-js"),c=require("lodash-es"),s=require("slugify");var f=Object.defineProperty,u=Object.getOwnPropertySymbols,d=Object.prototype.hasOwnProperty,g=Object.prototype.propertyIsEnumerable,i=(r,e,t)=>e in r?f(r,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):r[e]=t,O=(r,e)=>{for(var t in e||(e={}))d.call(e,t)&&i(r,t,e[t]);if(u)for(var t of u(e))g.call(e,t)&&i(r,t,e[t]);return r};const m=s.default||s;function w(r,e){const t=n=>{var o,l;return m(n!=null?n:"",O({lower:(o=e==null?void 0:e.lower)!=null?o:!0,locale:(l=e==null?void 0:e.locale)!=null?l:"vi"},e))};if(c.isObject(r)){const n={};for(const[o,l]of Object.entries(r))n[o]=t(l);return n}return t(r)}function y(r,e=4){return a.SHA256(r).toString(a.enc.Hex).slice(0,e)}function _(r=8){const e="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+[]{}|;:,.<>?";let t="";for(let n=0;n<r;n++){const o=Math.floor(Math.random()*e.length);t+=e.charAt(o)}return t}function h(r="",e=!1){const t=r.split(/[?#]/)[0]||"",n=t.substring(t.lastIndexOf("/")+1);if(e)return n;const o=n.lastIndexOf(".");return o>0?n.slice(0,o):n}function p(r,e,t){const n=r.indexOf(e);if(n===-1)return"";const o=n+e.length,l=r.indexOf(t,o);return l===-1?"":r.slice(o,l)}exports.generateRandomPassword=_;exports.generateShortId=y;exports.generateSlug=w;exports.getFileName=h;exports.substringBetween=p;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("crypto-js"),c=require("lodash-es"),u=require("slugify");var f=Object.defineProperty,s=Object.getOwnPropertySymbols,d=Object.prototype.hasOwnProperty,g=Object.prototype.propertyIsEnumerable,i=(r,e,t)=>e in r?f(r,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):r[e]=t,m=(r,e)=>{for(var t in e||(e={}))d.call(e,t)&&i(r,t,e[t]);if(s)for(var t of s(e))g.call(e,t)&&i(r,t,e[t]);return r};const O=u.default||u;function y(r,e){const t=n=>{var o,l;return O(n!=null?n:"",m({lower:(o=e==null?void 0:e.lower)!=null?o:!0,locale:(l=e==null?void 0:e.locale)!=null?l:"vi"},e))};if(c.isObject(r)){const n={};for(const[o,l]of Object.entries(r))n[o]=t(l);return n}return t(r)}function _(r,e=4){return a.SHA256(r).toString(a.enc.Hex).slice(0,e)}function h(r=8){const e="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+[]{}|;:,.<>?";return Array.from({length:r},()=>{const t=Math.floor(Math.random()*e.length);return e.charAt(t)}).join("")}function w(r="",e=!1){const t=r.split(/[?#]/)[0]||"",n=t.substring(t.lastIndexOf("/")+1);if(e)return n;const o=n.lastIndexOf(".");return o>0?n.slice(0,o):n}function p(r,e,t){const n=r.indexOf(e);if(n===-1)return"";const o=n+e.length,l=r.indexOf(t,o);return l===-1?"":r.slice(o,l)}exports.generateRandomPassword=h;exports.generateShortId=_;exports.generateSlug=y;exports.getFileName=w;exports.substringBetween=p;

package/dist/util/string/string.util.d.ts

@@ -1,39 +1,52 @@
 import { I_SlugifyOptions } from './string.type.js';
 /**
  * Generates a slug from a string or an object containing strings.
- * The slug is a URL-friendly version of the string.
+ * The slug is a URL-friendly version of the string, removing special characters
+ * and converting spaces to hyphens. This function can handle both single strings
+ * and objects with string values.
+ *
  * @param input - The string or object to be slugified.
- * @param options - Options for slugification.
- * @returns The slugified string or object.
+ * @param options - Options for slugification including replacement character, case sensitivity, locale, etc.
+ * @returns The slugified string or object with the same structure as the input.
  */
 export declare function generateSlug<T = string>(input: T, options?: I_SlugifyOptions): T;
 /**
  * Generates a short ID from a UUID.
- * The ID is a substring of the SHA256 hash of the UUID.
- * @param uuid - The UUID to be converted.
- * @param length - The length of the short ID.
- * @returns The short ID.
+ * The ID is a substring of the SHA256 hash of the UUID, providing a shorter
+ * but still unique identifier based on the original UUID.
+ *
+ * @param uuid - The UUID to be converted to a short ID.
+ * @param length - The desired length of the short ID (default: 4 characters).
+ * @returns A short ID string of the specified length derived from the UUID's SHA256 hash.
  */
 export declare function generateShortId(uuid: string, length?: number): string;
 /**
  * Generates a random password of a given length.
- * The password contains a mix of letters, numbers, and special characters.
- * @param length - The length of the password.
- * @returns The generated password.
+ * The password contains a mix of letters (both cases), numbers, and special characters
+ * to ensure complexity and security.
+ *
+ * @param length - The desired length of the password (default: 8 characters).
+ * @returns A randomly generated password string with the specified length.
  */
 export declare function generateRandomPassword(length?: number): string;
 /**
  * Get the file name from a URL.
- * @param url - The URL to extract the file name from.
- * @param getExtension - Whether to include the file extension.
- * @returns The file name.
+ * This function extracts the file name from a URL, optionally including or excluding
+ * the file extension. It handles URLs with query parameters and fragments.
+ *
+ * @param url - The URL to extract the file name from (default: empty string).
+ * @param getExtension - Whether to include the file extension in the result (default: false).
+ * @returns The file name extracted from the URL, with or without the extension.
  */
 export declare function getFileName(url?: string, getExtension?: boolean): string;
 /**
  * Extracts a substring between two strings.
- * @param s - The original string.
- * @param a - The starting string.
- * @param b - The ending string.
- * @returns The substring between the two strings.
+ * This function finds the first occurrence of the starting string, then finds the first
+ * occurrence of the ending string after the starting string, and returns the content between them.
+ *
+ * @param s - The original string to search within.
+ * @param a - The starting string that marks the beginning of the desired substring.
+ * @param b - The ending string that marks the end of the desired substring.
+ * @returns The substring between the two specified strings, or an empty string if either string is not found.
  */
 export declare function substringBetween(s: string, a: string, b: string): string;

package/dist/util/string/string.util.js

@@ -1,6 +1,6 @@
 import a from "crypto-js";
-import { isObject as u } from "lodash-es";
-import s from "slugify";
+import { isObject as s } from "lodash-es";
+import u from "slugify";
 var c = Object.defineProperty, f = Object.getOwnPropertySymbols, d = Object.prototype.hasOwnProperty, m = Object.prototype.propertyIsEnumerable, i = (e, r, t) => r in e ? c(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t, g = (e, r) => {
   for (var t in r || (r = {}))
     d.call(r, t) && i(e, t, r[t]);
@@ -9,8 +9,8 @@ var c = Object.defineProperty, f = Object.getOwnPropertySymbols, d = Object.prot
       m.call(r, t) && i(e, t, r[t]);
   return e;
 };
-const p = s.default || s;
-function y(e, r) {
+const p = u.default || u;
+function h(e, r) {
   const t = (n) => {
     var o, l;
     return p(n != null ? n : "", g({
@@ -18,7 +18,7 @@ function y(e, r) {
       locale: (l = r == null ? void 0 : r.locale) != null ? l : "vi"
     }, r));
   };
-  if (u(e)) {
+  if (s(e)) {
     const n = {};
     for (const [o, l] of Object.entries(e))
       n[o] = t(l);
@@ -26,17 +26,15 @@ function y(e, r) {
   }
   return t(e);
 }
-function h(e, r = 4) {
+function v(e, r = 4) {
   return a.SHA256(e).toString(a.enc.Hex).slice(0, r);
 }
-function v(e = 8) {
+function w(e = 8) {
   const r = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+[]{}|;:,.<>?";
-  let t = "";
-  for (let n = 0; n < e; n++) {
-    const o = Math.floor(Math.random() * r.length);
-    t += r.charAt(o);
-  }
-  return t;
+  return Array.from({ length: e }, () => {
+    const t = Math.floor(Math.random() * r.length);
+    return r.charAt(t);
+  }).join("");
 }
 function x(e = "", r = !1) {
   const t = e.split(/[?#]/)[0] || "", n = t.substring(t.lastIndexOf("/") + 1);
@@ -53,9 +51,9 @@ function P(e, r, t) {
   return l === -1 ? "" : e.slice(o, l);
 }
 export {
-  v as generateRandomPassword,
-  h as generateShortId,
-  y as generateSlug,
+  w as generateRandomPassword,
+  v as generateShortId,
+  h as generateSlug,
   x as getFileName,
   P as substringBetween
 };

package/dist/util/validate/validate.util.d.ts

@@ -1,6 +1,11 @@
+/**
+ * A collection of validation utility functions for common data validation tasks.
+ * This object provides methods to validate various data types and formats.
+ */
 export declare const validate: {
     /**
      * Checks if a value is empty.
+     * This function provides comprehensive empty checking for different data types:
      * - For strings, it checks if the string is empty or contains only whitespace.
      * - For arrays, it checks if the array has no elements.
      * - For objects, it checks if the object has no own properties.
@@ -10,18 +15,19 @@ export declare const validate: {
      * - For Dates, it returns false.
      * - For null and undefined, it returns true.
      * - For all other types, it returns false.
-     * @param value - The value to check.
+     *
+     * @param value - The value to check for emptiness.
      * @returns True if the value is empty, false otherwise.
      */
     isEmpty(value: unknown): boolean;
     /**
      * Checks if a string is a valid IP address (IPv4 or IPv6).
-     *
+     * This function validates IP addresses according to standard formats:
      * - IPv4: Four octets separated by dots, each between 0–255.
      * - IPv6: Eight groups of four hex digits, possibly compressed with `::`.
      *
      * @param ip - The IP address string to validate.
-     * @returns True if the IP is valid IPv4 or IPv6.
+     * @returns True if the IP is valid IPv4 or IPv6, false otherwise.
      */
     isValidIP(ip: string): boolean;
 };

package/dist/util/validate/validate.util.js

@@ -1,6 +1,7 @@
 const i = {
   /**
    * Checks if a value is empty.
+   * This function provides comprehensive empty checking for different data types:
    * - For strings, it checks if the string is empty or contains only whitespace.
    * - For arrays, it checks if the array has no elements.
    * - For objects, it checks if the object has no own properties.
@@ -10,7 +11,8 @@ const i = {
    * - For Dates, it returns false.
    * - For null and undefined, it returns true.
    * - For all other types, it returns false.
-   * @param value - The value to check.
+   *
+   * @param value - The value to check for emptiness.
    * @returns True if the value is empty, false otherwise.
    */
   isEmpty(t) {
@@ -18,12 +20,12 @@ const i = {
   },
   /**
    * Checks if a string is a valid IP address (IPv4 or IPv6).
-   *
+   * This function validates IP addresses according to standard formats:
    * - IPv4: Four octets separated by dots, each between 0–255.
    * - IPv6: Eight groups of four hex digits, possibly compressed with `::`.
    *
    * @param ip - The IP address string to validate.
-   * @returns True if the IP is valid IPv4 or IPv6.
+   * @returns True if the IP is valid IPv4 or IPv6, false otherwise.
    */
   isValidIP(t) {
     const e = t.split(".");