@germondai/ts-utils 0.0.1 → 0.0.2

package/dist/module.js

@@ -61,14 +61,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 +112,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 +125,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 +174,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 +217,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 +262,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 +289,7 @@ export {
   isPhoneNumber,
   isObject,
   isMacAddress,
-  isJson,
+  isJSON,
   isISODate,
   isIPv6,
   isIPv4,

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.2",
   "description": "Germond's TypeScript Utilities",
   "repository": {
     "type": "git",