@germondai/ts-utils 0.0.1 → 0.0.3

package/dist/module.js

@@ -1,15 +1,11 @@
 // src/runtime/collection.ts
-var hasDuplicates = (array, keyExtractor) => {
-  const seen = new Set;
-  for (const item of array) {
-    const key = keyExtractor ? keyExtractor(item) : item;
-    if (seen.has(key))
-      return true;
-    seen.add(key);
-  }
-  return false;
-};
-var uniqueArray = (array) => [...new Set(array)];
+var hasDuplicates = (array, keyExtractor) => new Set(array.map((value, index) => keyExtractor?.(value, index, array) || value)).size < array.length;
+var uniqueArray = (array, keyExtractor) => [
+  ...new Map(array.map((value, index, array2) => [
+    keyExtractor?.(value, index, array2) || value,
+    value
+  ])).values()
+];
 // src/runtime/constants.ts
 var SUPPORTED_DISPLAYABLE_MEDIA_TYPES = {
   images: [
@@ -61,14 +57,29 @@ var escapeHTML = (str) => {
   };
   return str.replace(/[&<>"']/g, (char) => escapeMap[char] || char);
 };
+var unescapeHTML = (str) => {
+  const unescapeMap = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#039;": "'"
+  };
+  return str.replace(/&[a-zA-Z0-9#]+;/g, (entity) => unescapeMap[entity] || entity);
+};
 // src/runtime/data.ts
 var clone = (data) => JSON.parse(JSON.stringify(data));
 // src/runtime/errors.ts
-var catchError = (promise, errorsToCatch) => promise().then((data) => ({ data, ok: true })).catch((error) => {
-  if (errorsToCatch === undefined || errorsToCatch.some((e) => error instanceof e))
-    return { error, ok: false };
-  throw error;
-});
+var catchError = async (promise, errorsToCatch) => {
+  try {
+    const data = await promise();
+    return { data, ok: true };
+  } catch (error) {
+    if (errorsToCatch === undefined || errorsToCatch.some((e) => error instanceof e))
+      return { error, ok: false };
+    throw error;
+  }
+};
 // src/runtime/math.ts
 var rand = (n, m = 0) => Math.floor(Math.random() * (m - n + 1)) + n;
 var percentage = (value, maxValue, decimalPlaces = 2) => {
@@ -97,14 +108,6 @@ var isCreditCard = (value) => /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:0
 var isDomain = (value) => /^(?!:\/\/)([a-zA-Z0-9-_]{1,63}\.)+[a-zA-Z]{2,63}$/.test(value);
 var isPostalCode = (value) => /^[A-Za-z0-9\s-]{3,10}$/.test(value);
 var isISODate = (value) => /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/.test(value);
-var isJson = (value) => {
-  try {
-    JSON.parse(value);
-    return true;
-  } catch {
-    return false;
-  }
-};
 var isBase64 = (value) => /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
 var isSlug = (value) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
 // src/runtime/size.ts
@@ -118,6 +121,29 @@ var formatBytes = (bytes, decimals = 2) => {
   const size = parseFloat((bytes / Math.pow(k, i)).toFixed(dm));
   return `${size} ${sizes[i]}`;
 };
+var toBytes = (size) => {
+  const match = size.trim().match(/^(\d+\.?\d*)\s*(B|KB|MB|GB|TB)$/i);
+  if (!match)
+    return;
+  const value = Number(match[1]);
+  const unit = match[2]?.toUpperCase();
+  if (isNaN(value) || value < 0)
+    return;
+  switch (unit) {
+    case "B":
+      return value;
+    case "KB":
+      return value * 1024;
+    case "MB":
+      return value * 1024 * 1024;
+    case "GB":
+      return value * 1024 * 1024 * 1024;
+    case "TB":
+      return value * 1024 * 1024 * 1024 * 1024;
+    default:
+      return;
+  }
+};
 // src/runtime/time.ts
 var formatTime = (seconds) => {
   const hours = Math.floor(seconds / 3600);
@@ -144,6 +170,36 @@ var formatDuration = (ms) => {
     return `${min}m ${sec % 60}s`;
   return `${sec}s`;
 };
+var toSeconds = (time) => {
+  time = time?.trim();
+  if (!time)
+    return;
+  if (/^\d+$/.test(time)) {
+    const seconds2 = Number(time);
+    if (isNaN(seconds2))
+      return;
+    return seconds2;
+  }
+  if (time.includes(":")) {
+    const parts = time.split(":").map(Number);
+    if (parts.some(isNaN))
+      return;
+    if (parts.length === 2)
+      return (parts[0] || 0) * 60 + (parts[1] || 0);
+    else if (parts.length === 3)
+      return (parts[0] || 0) * 3600 + (parts[1] || 0) * 60 + (parts[2] || 0);
+    return;
+  }
+  const match = time.match(/(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?/i);
+  if (!match || !match.some((v, i) => i > 0 && v !== undefined))
+    return;
+  const hours = Number(match[1] || "0");
+  const minutes = Number(match[2] || "0");
+  const seconds = Number(match[3] || "0");
+  if (isNaN(hours) || isNaN(minutes) || isNaN(seconds))
+    return;
+  return hours * 3600 + minutes * 60 + seconds;
+};
 // src/runtime/type.ts
 var isPrimitive = (value) => value === null || value === undefined || typeof value !== "object" && typeof value !== "function";
 var isObject = (value) => value !== null && typeof value === "object" && value.constructor === Object;
@@ -157,6 +213,16 @@ var isEmpty = (value) => {
     return Object.keys(value).length === 0;
   return false;
 };
+var isJSON = (value) => {
+  if (typeof value !== "string")
+    return false;
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
 // src/runtime/url.ts
 var getQueryParams = (urlString) => {
   const url = new URL(urlString);
@@ -192,15 +258,18 @@ var buildUrl = (baseUrl, path, queryParams) => {
 export {
   updateQueryParam,
   uniqueArray,
+  unescapeHTML,
   truncate,
   toggleCase,
   toTitleCase,
   toSnakeCase,
   toSentenceCase,
+  toSeconds,
   toPascalCase,
   toKebabCase,
   toConstantCase,
   toCamelCase,
+  toBytes,
   stripTags,
   slugify,
   sleep,
@@ -216,7 +285,7 @@ export {
   isPhoneNumber,
   isObject,
   isMacAddress,
-  isJson,
+  isJSON,
   isISODate,
   isIPv6,
   isIPv4,

package/dist/runtime/collection.d.ts

@@ -1,19 +1,53 @@
 /**
- * Checks if an array contains duplicate values.
+ * Determines whether an array contains duplicate values.
  *
  * @param array - The array to check for duplicates.
+ * @param keyExtractor - Optional function to extract a key for comparison. If provided, duplicates are determined based on the extracted key.
  * @returns True if the array contains duplicates, false otherwise.
  *
  * @example
+ * // Basic usage with primitive values
  * hasDuplicates([1, 2, 3, 4, 1]); // true
  * hasDuplicates(['a', 'b', 'c']); // false
+ *
+ * // Usage with objects and a key extractor
  * hasDuplicates([{ id: 1 }, { id: 2 }, { id: 1 }], (item) => item.id); // true
  */
-export declare const hasDuplicates: <T>(array: T[], keyExtractor?: (item: T) => unknown) => boolean;
+export declare const hasDuplicates: <T>(array: T[], keyExtractor?: (value: T, index: number, array: T[]) => string | number) => boolean;
 /**
- * Removes duplicates from an array.
+ * Removes duplicates from an array based on a key function.
  *
  * @param array - The array to process.
+ * @param keyExtractor - Function to generate a unique key for each item.
  * @returns A new array without duplicates.
  */
-export declare const uniqueArray: <T>(array: T[]) => T[];
+/**
+ * Returns a new array containing only unique elements from the input array.
+ * Uniqueness is determined based on the values returned by the `keyExtractor` function,
+ * or by the elements themselves if no `keyExtractor` is provided.
+ *
+ * @typeParam T - The type of elements in the input array.
+ * @param array - The input array from which to extract unique elements.
+ * @param keyExtractor - An optional function that extracts a key from each element
+ * to determine uniqueness. If not provided, the elements themselves are used.
+ * The function receives the current element, its index, and the entire array as arguments.
+ * @returns A new array containing only unique elements from the input array.
+ *
+ * @example
+ * // Using default behavior (elements themselves determine uniqueness)
+ * const numbers = [1, 2, 2, 3, 4, 4];
+ * const uniqueNumbers = uniqueArray(numbers);
+ * console.log(uniqueNumbers); // Output: [1, 2, 3, 4]
+ *
+ * @example
+ * // Using a keyExtractor to determine uniqueness
+ * const users = [
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 1, name: 'Alice' },
+ * ];
+ * const uniqueUsers = uniqueArray(users, user => user.id);
+ * console.log(uniqueUsers);
+ * // Output: [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ */
+export declare const uniqueArray: <T>(array: T[], keyExtractor?: (value: T, index: number, array: T[]) => string | number) => T[];

package/dist/runtime/convertor.d.ts

@@ -104,3 +104,11 @@ export declare const stripTags: (html: string) => string;
  * @returns The HTML-escaped string.
  */
 export declare const escapeHTML: (str: string) => string;
+/**
+ * Unescapes HTML entities in a string.
+ * Converts HTML entities like `&`, `<`, `>`, `"`, and `'` back to their original characters.
+ *
+ * @param str - The input string to unescape.
+ * @returns The unescaped string.
+ */
+export declare const unescapeHTML: (str: string) => string;

package/dist/runtime/errors.d.ts

@@ -11,7 +11,11 @@
  * @returns A promise resolving to an object with either the data or an error.
  */
 export declare const catchError: <T, E extends new (message?: string) => Error>(promise: () => Promise<T>, errorsToCatch?: E[]) => Promise<{
-    data?: T;
-    ok: boolean;
-    error?: InstanceType<E>;
+    data: T;
+    ok: true;
+    error?: never;
+} | {
+    data?: never;
+    ok: false;
+    error: InstanceType<E>;
 }>;

package/dist/runtime/regex.d.ts

@@ -145,17 +145,6 @@ export declare const isPostalCode: (value: string) => boolean;
  * isISODate('2024-13-01'); // false
  */
 export declare const isISODate: (value: string) => boolean;
-/**
- * Checks if a given string is a valid JSON string.
- *
- * @param value - The string to validate.
- * @returns True if the string is valid JSON, false otherwise.
- *
- * @example
- * isJson('{"name": "John"}'); // true
- * isJson('{invalid}'); // false
- */
-export declare const isJson: (value: string) => boolean;
 /**
  * Checks if a given string is a valid Base64-encoded string.
  *

package/dist/runtime/size.d.ts

@@ -8,3 +8,26 @@
  * @returns A string representing the file size (e.g., "1.23 MB").
  */
 export declare const formatBytes: (bytes: number, decimals?: number) => string;
+/**
+ * Converts a human-readable size string into its equivalent size in bytes.
+ *
+ * @param size - The size string to convert. It should be in the format of a number
+ * followed by a unit (e.g., "10 KB", "5.5 MB", "1 GB"). Supported units are:
+ * - B (bytes)
+ * - KB (kilobytes)
+ * - MB (megabytes)
+ * - GB (gigabytes)
+ * - TB (terabytes)
+ *
+ * @returns The size in bytes as a number, or `undefined` if the input format is invalid
+ * or the value is negative.
+ *
+ * @example
+ * ```typescript
+ * toBytes("10 KB") // Returns 10240
+ * toBytes("5.5 MB") // Returns 5767168
+ * toBytes("1 GB") // Returns 1073741824
+ * toBytes("invalid") // Returns undefined
+ * ```
+ */
+export declare const toBytes: (size: string) => number | undefined;

package/dist/runtime/time.d.ts

@@ -16,3 +16,15 @@ export declare const formatTime: (seconds: number) => string;
  * @returns A formatted string (e.g., "2h 15m 30s").
  */
 export declare const formatDuration: (ms: number) => string;
+/**
+ * Converts a time string into seconds.
+ *
+ * Supports various formats:
+ * - Direct seconds (e.g., '2947')
+ * - MM:SS or HH:MM:SS
+ * - 'Xh Ym Zs' format (e.g., '2h 15m 30s')
+ *
+ * @param time - The time string to convert.
+ * @returns The total number of seconds, or undefined if the format is invalid.
+ */
+export declare const toSeconds: (time: string) => number | undefined;

package/dist/runtime/type.d.ts

@@ -34,3 +34,17 @@ export declare const isArray: <T>(value: unknown) => value is T[];
  * @returns True if the value is empty, false otherwise.
  */
 export declare const isEmpty: (value: unknown) => boolean;
+/**
+ * Determines whether a value is valid JSON.
+ *
+ * This function checks if a value can be parsed as JSON.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is valid JSON, false otherwise.
+ *
+ * @example
+ * isJson('{"name": "John"}'); // true
+ * isJson('{invalid}'); // false
+ *
+ */
+export declare const isJSON: (value: string) => boolean;

package/package.json

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