@germondai/ts-utils 0.0.3 → 0.0.5

package/dist/module.js

@@ -69,6 +69,34 @@ var unescapeHTML = (str) => {
 };
 // src/runtime/data.ts
 var clone = (data) => JSON.parse(JSON.stringify(data));
+var isEqual = (a, b) => {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a === "object") {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      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;
+    } else {
+      const keysA = Object.keys(a);
+      const keysB = Object.keys(b);
+      if (keysA.length !== keysB.length)
+        return false;
+      for (const key of keysA)
+        if (!keysB.includes(key) || !isEqual(a[key], b[key]))
+          return false;
+      return true;
+    }
+  }
+  return false;
+};
 // src/runtime/errors.ts
 var catchError = async (promise, errorsToCatch) => {
   try {
@@ -248,11 +276,12 @@ var buildUrl = (baseUrl, path, queryParams) => {
     const normalizedPath = path.startsWith("/") ? path : `/${path}`;
     url.pathname = `${url.pathname.replace(/\/$/, "")}${normalizedPath}`;
   }
-  if (queryParams) {
+  if (queryParams)
     Object.entries(queryParams).forEach(([key, value]) => {
-      url.searchParams.set(key, String(value));
+      if (value === undefined)
+        return;
+      url.searchParams.set(key, value === null ? "" : String(value));
     });
-  }
   return url.toString();
 };
 export {
@@ -291,6 +320,7 @@ export {
   isIPv4,
   isHexColor,
   isHex,
+  isEqual,
   isEmpty,
   isEmail,
   isDomain,

package/dist/runtime/data.d.ts

@@ -7,3 +7,19 @@
  * @returns A deep copy of the data.
  */
 export declare const clone: <T>(data: T) => T;
+/**
+ * Compares two values of the same type to determine if they are deeply equal.
+ *
+ * @typeParam T - The type of the values being compared.
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ * @returns `true` if the values are deeply equal, otherwise `false`.
+ *
+ * @remarks
+ * - For primitive types, the function uses strict equality (`===`).
+ * - For `null` or `undefined`, the function returns `false` if one value is nullish and the other is not.
+ * - For arrays, the function checks if they have the same length and recursively compares their elements.
+ * - For objects, the function checks if they have the same keys and recursively compares their corresponding values.
+ * - The function does not handle circular references and may result in a stack overflow for deeply nested structures.
+ */
+export declare const isEqual: <T>(a: T, b: T) => boolean;

package/dist/runtime/url.d.ts

@@ -46,4 +46,4 @@ export declare const removeQueryParam: (urlString: string, key: string) => strin
  * // returns 'https://example.com/api/v1/resource?search=test&page=2'
  * buildUrl('https://example.com', '/api/v1/resource', { search: 'test', page: 2 });
  */
-export declare const buildUrl: (baseUrl: string, path?: string, queryParams?: Record<string, string | number | boolean>) => string;
+export declare const buildUrl: (baseUrl: string, path?: string, queryParams?: Record<string, string | number | boolean | null | undefined>) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@germondai/ts-utils",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Germond's TypeScript Utilities",
   "repository": {
     "type": "git",