@catbee/utils 1.1.0 → 2.0.0-next.1

package/crypto/index.mjs

@@ -0,0 +1,166 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { scrypt, createHmac, createHash, randomBytes, timingSafeEqual, createCipheriv, createDecipheriv } from 'crypto';
+import { promisify } from 'util';
+import { uuid } from '@catbee/utils/id';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function hmac(algorithm, input, secret, encoding = "hex") {
+  return createHmac(algorithm, secret).update(input).digest(encoding);
+}
+__name(hmac, "hmac");
+function hash(algorithm, input, encoding = "hex") {
+  return createHash(algorithm).update(input).digest(encoding);
+}
+__name(hash, "hash");
+function sha256Hmac(input, secret) {
+  return hmac("sha256", input, secret);
+}
+__name(sha256Hmac, "sha256Hmac");
+function sha1(input, encoding = "hex") {
+  return hash("sha1", input, encoding);
+}
+__name(sha1, "sha1");
+function sha256(input, encoding = "hex") {
+  return hash("sha256", input, encoding);
+}
+__name(sha256, "sha256");
+function md5(input) {
+  return hash("md5", input);
+}
+__name(md5, "md5");
+function randomString() {
+  return sha256(uuid());
+}
+__name(randomString, "randomString");
+function generateRandomBytes(byteLength = 32) {
+  return randomBytes(byteLength);
+}
+__name(generateRandomBytes, "generateRandomBytes");
+function generateRandomBytesAsString(byteLength = 32, encoding = "hex") {
+  return randomBytes(byteLength).toString(encoding);
+}
+__name(generateRandomBytesAsString, "generateRandomBytesAsString");
+function generateApiKey(prefix = "", byteLength = 24) {
+  const randomString2 = generateRandomBytesAsString(byteLength, "base64");
+  const key = randomString2.replace(/[+/=]/g, "").substring(0, 32);
+  return prefix ? `${prefix}_${key}` : key;
+}
+__name(generateApiKey, "generateApiKey");
+function safeCompare(a, b) {
+  if (typeof a === "string" && typeof b === "string") {
+    const bufA = Buffer.from(a);
+    const bufB = Buffer.from(b);
+    if (bufA.length !== bufB.length) return false;
+    return timingSafeEqual(bufA, bufB);
+  } else if ((a instanceof Buffer || a instanceof Uint8Array) && (b instanceof Buffer || b instanceof Uint8Array)) {
+    if (a.length !== b.length) return false;
+    return timingSafeEqual(a instanceof Buffer ? a : Buffer.from(a), b instanceof Buffer ? b : Buffer.from(b));
+  }
+  throw new Error("Cannot compare: inputs must be strings, Buffers, or Uint8Arrays");
+}
+__name(safeCompare, "safeCompare");
+var scryptAsync = promisify(scrypt);
+async function encrypt(data, key, options = {}) {
+  const algorithm = options.algorithm || "aes-256-gcm";
+  const inputEncoding = options.inputEncoding || "utf8";
+  const outputEncoding = options.outputEncoding || "hex";
+  const iv = randomBytes(16);
+  const derivedKey = typeof key === "string" ? await scryptAsync(key, iv.slice(0, 8), 32) : key;
+  const cipher = createCipheriv(algorithm, derivedKey, iv);
+  let ciphertext;
+  if (typeof data === "string") {
+    ciphertext = cipher.update(data, inputEncoding, outputEncoding);
+    ciphertext += cipher.final(outputEncoding);
+  } else {
+    const encrypted = Buffer.concat([
+      cipher.update(data),
+      cipher.final()
+    ]);
+    ciphertext = encrypted.toString(outputEncoding) ;
+  }
+  const authTag = algorithm.includes("gcm") ? cipher.getAuthTag() : void 0;
+  return {
+    ciphertext,
+    iv,
+    authTag,
+    algorithm
+  };
+}
+__name(encrypt, "encrypt");
+async function decrypt(encryptedData, key, options = {}) {
+  const algorithm = options.algorithm || encryptedData.algorithm || "aes-256-gcm";
+  const inputEncoding = options.inputEncoding || "hex";
+  const outputEncoding = options.outputEncoding || "utf8";
+  const derivedKey = typeof key === "string" ? await scryptAsync(key, encryptedData.iv.slice(0, 8), 32) : key;
+  const decipher = createDecipheriv(algorithm, derivedKey, encryptedData.iv);
+  if (encryptedData.authTag && algorithm.includes("gcm")) {
+    decipher.setAuthTag(encryptedData.authTag);
+  }
+  let decrypted;
+  if (typeof encryptedData.ciphertext === "string") {
+    decrypted = decipher.update(encryptedData.ciphertext, inputEncoding, outputEncoding);
+    decrypted += decipher.final(outputEncoding);
+  } else {
+    const result = Buffer.concat([
+      decipher.update(encryptedData.ciphertext),
+      decipher.final()
+    ]);
+    decrypted = result.toString(outputEncoding) ;
+  }
+  return decrypted;
+}
+__name(decrypt, "decrypt");
+function createSignedToken(payload, secret, expiresInSeconds = 3600) {
+  const tokenPayload = {
+    ...payload,
+    exp: Math.floor(Date.now() / 1e3) + expiresInSeconds
+  };
+  const payloadStr = JSON.stringify(tokenPayload);
+  const base64Payload = Buffer.from(payloadStr).toString("base64url");
+  const signature = hmac("sha256", base64Payload, secret, "base64url");
+  return `${base64Payload}.${signature}`;
+}
+__name(createSignedToken, "createSignedToken");
+function verifySignedToken(token, secret) {
+  try {
+    const [payloadB64, signature] = token.split(".");
+    if (!payloadB64 || !signature) return null;
+    const expectedSignature = hmac("sha256", payloadB64, secret, "base64url");
+    if (!safeCompare(signature, expectedSignature)) return null;
+    const payloadStr = Buffer.from(payloadB64, "base64url").toString("utf8");
+    const payload = JSON.parse(payloadStr);
+    if (payload.exp && payload.exp < Math.floor(Date.now() / 1e3)) {
+      return null;
+    }
+    return payload;
+  } catch {
+    return null;
+  }
+}
+__name(verifySignedToken, "verifySignedToken");
+
+export { createSignedToken, decrypt, encrypt, generateApiKey, generateRandomBytes, generateRandomBytesAsString, hash, hmac, md5, randomString, safeCompare, sha1, sha256, sha256Hmac, verifySignedToken };

package/date/index.cjs

@@ -0,0 +1,340 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/date/date.utils.ts
+function formatDate(date, options = {}) {
+  const { format = "yyyy-MM-dd", locale, timeZone } = options;
+  const d = date instanceof Date ? date : new Date(date);
+  if (format === "yyyy-MM-dd") {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd}`;
+  }
+  if (format === "yyyy-MM-dd HH:mm:ss") {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    const HH = String(d.getHours()).padStart(2, "0");
+    const MM = String(d.getMinutes()).padStart(2, "0");
+    const SS = String(d.getSeconds()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd} ${HH}:${MM}:${SS}`;
+  }
+  if (format === "relative") {
+    return formatRelativeTime(date);
+  }
+  return new Intl.DateTimeFormat(locale, {
+    timeZone,
+    year: format.includes("yyyy") || format.includes("y") ? "numeric" : void 0,
+    month: format.includes("MM") || format.includes("M") ? "numeric" : void 0,
+    day: format.includes("dd") || format.includes("d") ? "numeric" : void 0,
+    hour: format.includes("HH") || format.includes("H") ? "numeric" : void 0,
+    minute: format.includes("mm") || format.includes("m") ? "numeric" : void 0,
+    second: format.includes("ss") || format.includes("s") ? "numeric" : void 0,
+    hour12: !format.includes("HH") && !format.includes("H")
+  }).format(d);
+}
+__name(formatDate, "formatDate");
+function formatRelativeTime(date, now = /* @__PURE__ */ new Date(), locale) {
+  const d1 = date instanceof Date ? date : new Date(date);
+  const d2 = now instanceof Date ? now : new Date(now);
+  const diffMs = d1.getTime() - d2.getTime();
+  const diffSecs = Math.round(diffMs / 1e3);
+  const diffMins = Math.round(diffSecs / 60);
+  const diffHours = Math.round(diffMins / 60);
+  const diffDays = Math.round(diffHours / 24);
+  const diffMonths = Math.round(diffDays / 30);
+  const diffYears = Math.round(diffDays / 365);
+  const formatter = new Intl.RelativeTimeFormat(locale, {
+    numeric: "auto"
+  });
+  if (Math.abs(diffSecs) < 60) return formatter.format(diffSecs, "second");
+  if (Math.abs(diffMins) < 60) return formatter.format(diffMins, "minute");
+  if (Math.abs(diffHours) < 24) return formatter.format(diffHours, "hour");
+  if (Math.abs(diffDays) < 30) return formatter.format(diffDays, "day");
+  if (Math.abs(diffMonths) < 12) return formatter.format(diffMonths, "month");
+  return formatter.format(diffYears, "year");
+}
+__name(formatRelativeTime, "formatRelativeTime");
+function parseDate(input, fallback) {
+  if (typeof input === "number") {
+    return new Date(input);
+  }
+  try {
+    const date = new Date(input);
+    if (Number.isNaN(date.getTime())) {
+      return fallback || null;
+    }
+    return date;
+  } catch {
+    return fallback || null;
+  }
+}
+__name(parseDate, "parseDate");
+function dateDiff(date1, date2 = /* @__PURE__ */ new Date(), unit = "days") {
+  const d1 = date1 instanceof Date ? date1 : new Date(date1);
+  const d2 = date2 instanceof Date ? date2 : new Date(date2);
+  const diffMs = d1.getTime() - d2.getTime();
+  switch (unit) {
+    case "milliseconds":
+      return diffMs;
+    case "seconds":
+      return diffMs / 1e3;
+    case "minutes":
+      return diffMs / (1e3 * 60);
+    case "hours":
+      return diffMs / (1e3 * 60 * 60);
+    case "days":
+      return diffMs / (1e3 * 60 * 60 * 24);
+    case "months":
+      return (d1.getFullYear() - d2.getFullYear()) * 12 + d1.getMonth() - d2.getMonth();
+    case "years":
+      return d1.getFullYear() - d2.getFullYear();
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+}
+__name(dateDiff, "dateDiff");
+function addToDate(date, amount, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "milliseconds":
+      d.setMilliseconds(d.getMilliseconds() + amount);
+      break;
+    case "seconds":
+      d.setSeconds(d.getSeconds() + amount);
+      break;
+    case "minutes":
+      d.setMinutes(d.getMinutes() + amount);
+      break;
+    case "hours":
+      d.setHours(d.getHours() + amount);
+      break;
+    case "days":
+      d.setDate(d.getDate() + amount);
+      break;
+    case "months": {
+      const origDate = d.getDate();
+      const origMonth = d.getMonth();
+      d.setDate(1);
+      d.setMonth(origMonth + amount);
+      const lastDay = new Date(d.getFullYear(), d.getMonth() + 1, 0).getDate();
+      d.setDate(Math.min(origDate, lastDay));
+      break;
+    }
+    case "years":
+      d.setFullYear(d.getFullYear() + amount);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(addToDate, "addToDate");
+function startOf(date, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "second":
+      d.setMilliseconds(0);
+      break;
+    case "minute":
+      d.setSeconds(0, 0);
+      break;
+    case "hour":
+      d.setMinutes(0, 0, 0);
+      break;
+    case "day":
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "week":
+      d.setHours(0, 0, 0, 0);
+      d.setDate(d.getDate() - d.getDay());
+      break;
+    case "month":
+      d.setDate(1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "quarter":
+      d.setMonth(Math.floor(d.getMonth() / 3) * 3, 1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "year":
+      d.setMonth(0, 1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(startOf, "startOf");
+function endOf(date, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "second":
+      d.setMilliseconds(999);
+      break;
+    case "minute":
+      d.setSeconds(59, 999);
+      break;
+    case "hour":
+      d.setMinutes(59, 59, 999);
+      break;
+    case "day":
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "week":
+      d.setDate(d.getDate() - d.getDay() + 6);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "month":
+      d.setMonth(d.getMonth() + 1, 0);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "quarter":
+      d.setMonth(Math.floor(d.getMonth() / 3) * 3 + 3, 0);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "year":
+      d.setMonth(11, 31);
+      d.setHours(23, 59, 59, 999);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(endOf, "endOf");
+function isBetween(date, start, end, inclusive = true) {
+  const d = date instanceof Date ? date.getTime() : date;
+  const s = start instanceof Date ? start.getTime() : start;
+  const e = end instanceof Date ? end.getTime() : end;
+  return inclusive ? d >= s && d <= e : d > s && d < e;
+}
+__name(isBetween, "isBetween");
+function isLeapYear(year) {
+  const y = year instanceof Date ? year.getFullYear() : year;
+  return y % 4 === 0 && y % 100 !== 0 || y % 400 === 0;
+}
+__name(isLeapYear, "isLeapYear");
+function daysInMonth(year, month) {
+  if (year instanceof Date) {
+    month = year.getMonth();
+    year = year.getFullYear();
+  }
+  if (month === void 0) {
+    throw new Error("Month is required when year is a number");
+  }
+  return new Date(year, month + 1, 0).getDate();
+}
+__name(daysInMonth, "daysInMonth");
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return "0ms";
+  const parts = [];
+  const days = Math.floor(ms / (24 * 60 * 60 * 1e3));
+  if (days) {
+    parts.push(`${days}d`);
+    ms -= days * 24 * 60 * 60 * 1e3;
+  }
+  const hours = Math.floor(ms / (60 * 60 * 1e3));
+  if (hours) {
+    parts.push(`${hours}h`);
+    ms -= hours * 60 * 60 * 1e3;
+  }
+  const minutes = Math.floor(ms / (60 * 1e3));
+  if (minutes) {
+    parts.push(`${minutes}m`);
+    ms -= minutes * 60 * 1e3;
+  }
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds) {
+    parts.push(`${seconds}s`);
+    ms -= seconds * 1e3;
+  }
+  if (ms > 0) parts.push(`${ms}ms`);
+  return parts.join(" ");
+}
+__name(formatDuration, "formatDuration");
+function parseDuration(value) {
+  const MAX_SAFE = Number.MAX_SAFE_INTEGER;
+  if (typeof value === "number" && Number.isFinite(value)) return Math.min(value, MAX_SAFE);
+  if (typeof value !== "string" || !value.trim()) return 0;
+  if (/^\d+$/.test(value)) return Math.min(Number(value), MAX_SAFE);
+  const val = value.replace(/\s+/g, "").toLowerCase();
+  const unitMap = {
+    y: 31536e6,
+    w: 6048e5,
+    d: 864e5,
+    h: 36e5,
+    m: 6e4,
+    s: 1e3,
+    ms: 1
+  };
+  const unitKeys = Object.keys(unitMap).sort((a, b) => b.length - a.length);
+  let total = 0;
+  let i = 0;
+  while (i < val.length) {
+    const start = i;
+    while (i < val.length && /\d/.test(val[i])) i++;
+    if (start === i) {
+      throw new Error(`Invalid duration at offset ${i} in "${value}"`);
+    }
+    const num = Number(val.slice(start, i));
+    if (!Number.isSafeInteger(num)) throw new Error(`Invalid number at offset ${start} in "${value}"`);
+    const unit = unitKeys.find((u) => val.startsWith(u, i));
+    if (!unit) throw new Error(`Unknown unit at offset ${i} in "${value}"`);
+    const add = num * unitMap[unit];
+    total = Math.min(total + add, MAX_SAFE);
+    i += unit.length;
+  }
+  return total;
+}
+__name(parseDuration, "parseDuration");
+function getDateFromDuration(input) {
+  const ms = parseDuration(input);
+  if (ms <= 0) {
+    throw new Error(`Invalid duration: "${input}". Duration must be a positive value.`);
+  }
+  return new Date(Date.now() + ms);
+}
+__name(getDateFromDuration, "getDateFromDuration");
+
+exports.addToDate = addToDate;
+exports.dateDiff = dateDiff;
+exports.daysInMonth = daysInMonth;
+exports.endOf = endOf;
+exports.formatDate = formatDate;
+exports.formatDuration = formatDuration;
+exports.formatRelativeTime = formatRelativeTime;
+exports.getDateFromDuration = getDateFromDuration;
+exports.isBetween = isBetween;
+exports.isLeapYear = isLeapYear;
+exports.parseDate = parseDate;
+exports.parseDuration = parseDuration;
+exports.startOf = startOf;