@mohasinac/utils 0.1.0

package/dist/index.cjs

@@ -0,0 +1,673 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  arrayToObject: () => arrayToObject,
+  booleanToString: () => booleanToString,
+  capitalize: () => capitalize,
+  capitalizeWords: () => capitalizeWords,
+  currentYear: () => currentYear,
+  dateToISOString: () => dateToISOString,
+  deleteCookie: () => deleteCookie,
+  escapeHtml: () => escapeHtml,
+  firestoreTimestampToDate: () => firestoreTimestampToDate,
+  formatCompactNumber: () => formatCompactNumber,
+  formatCurrency: () => formatCurrency,
+  formatDate: () => formatDate,
+  formatDateRange: () => formatDateRange,
+  formatDateTime: () => formatDateTime,
+  formatDecimal: () => formatDecimal,
+  formatFileSize: () => formatFileSize,
+  formatMonthYear: () => formatMonthYear,
+  formatNumber: () => formatNumber,
+  formatOrdinal: () => formatOrdinal,
+  formatPercentage: () => formatPercentage,
+  formatRelativeTime: () => formatRelativeTime,
+  formatTime: () => formatTime,
+  generateAuctionId: () => generateAuctionId,
+  generateBidId: () => generateBidId,
+  generateBlogPostId: () => generateBlogPostId,
+  generateCarouselId: () => generateCarouselId,
+  generateCategoryId: () => generateCategoryId,
+  generateCouponId: () => generateCouponId,
+  generateFAQId: () => generateFAQId,
+  generateHomepageSectionId: () => generateHomepageSectionId,
+  generateOrderId: () => generateOrderId,
+  generatePayoutId: () => generatePayoutId,
+  generatePreOrderId: () => generatePreOrderId,
+  generateProductId: () => generateProductId,
+  generateReviewId: () => generateReviewId,
+  generateUserId: () => generateUserId,
+  getCookie: () => getCookie,
+  hasCookie: () => hasCookie,
+  isEmptyString: () => isEmptyString,
+  isFuture: () => isFuture,
+  isPast: () => isPast,
+  isSameMonth: () => isSameMonth,
+  isToday: () => isToday,
+  maskString: () => maskString,
+  nowISO: () => nowISO,
+  nowMs: () => nowMs,
+  objectToArray: () => objectToArray,
+  objectToQueryString: () => objectToQueryString,
+  parseCookies: () => parseCookies,
+  parseFormattedNumber: () => parseFormattedNumber,
+  proseMirrorToHtml: () => proseMirrorToHtml,
+  queryStringToObject: () => queryStringToObject,
+  randomString: () => randomString,
+  resolveDate: () => resolveDate,
+  slugify: () => slugify,
+  stringToBoolean: () => stringToBoolean,
+  stripHtml: () => stripHtml,
+  truncate: () => truncate,
+  truncateWords: () => truncateWords
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/date.formatter.ts
+function resolveDate(value) {
+  if (!value) return null;
+  if (value instanceof Date) return value;
+  if (typeof value === "object" && value !== null && "_seconds" in value && typeof value._seconds === "number") {
+    return new Date(value._seconds * 1e3);
+  }
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+function formatDate(date, format = "medium", locale = "en-US") {
+  const dateObj = resolveDate(date);
+  if (!dateObj) return "";
+  const options = {};
+  switch (format) {
+    case "short":
+      options.year = "2-digit";
+      options.month = "numeric";
+      options.day = "numeric";
+      break;
+    case "medium":
+      options.year = "numeric";
+      options.month = "short";
+      options.day = "numeric";
+      break;
+    case "long":
+      options.year = "numeric";
+      options.month = "long";
+      options.day = "numeric";
+      break;
+    case "full":
+      options.year = "numeric";
+      options.month = "long";
+      options.day = "numeric";
+      options.weekday = "long";
+      break;
+  }
+  return dateObj.toLocaleDateString(locale, options);
+}
+function formatDateTime(date, format = "medium", locale = "en-US") {
+  const dateObj = resolveDate(date);
+  if (!dateObj) return "";
+  const dateOptions = {};
+  const timeOptions = {};
+  switch (format) {
+    case "short":
+      dateOptions.year = "2-digit";
+      dateOptions.month = "2-digit";
+      dateOptions.day = "2-digit";
+      timeOptions.hour = "2-digit";
+      timeOptions.minute = "2-digit";
+      break;
+    case "medium":
+      dateOptions.year = "numeric";
+      dateOptions.month = "short";
+      dateOptions.day = "numeric";
+      timeOptions.hour = "2-digit";
+      timeOptions.minute = "2-digit";
+      break;
+    case "long":
+      dateOptions.year = "numeric";
+      dateOptions.month = "long";
+      dateOptions.day = "numeric";
+      timeOptions.hour = "2-digit";
+      timeOptions.minute = "2-digit";
+      timeOptions.second = "2-digit";
+      break;
+    case "full":
+      dateOptions.year = "numeric";
+      dateOptions.month = "long";
+      dateOptions.day = "numeric";
+      dateOptions.weekday = "long";
+      timeOptions.hour = "2-digit";
+      timeOptions.minute = "2-digit";
+      timeOptions.second = "2-digit";
+      break;
+  }
+  const datePart = dateObj.toLocaleDateString(locale, dateOptions);
+  const timePart = dateObj.toLocaleTimeString(locale, timeOptions);
+  return `${datePart}, ${timePart}`;
+}
+function formatTime(date, format = "long", locale = "en-US") {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  const options = format === "short" ? { hour: "2-digit", minute: "2-digit" } : { hour: "2-digit", minute: "2-digit", second: "2-digit" };
+  return dateObj.toLocaleTimeString(locale, options);
+}
+function formatRelativeTime(date) {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - dateObj.getTime();
+  const diffSec = Math.floor(diffMs / 1e3);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHour = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHour / 24);
+  const diffWeek = Math.floor(diffDay / 7);
+  const diffMonth = Math.floor(diffDay / 30);
+  const diffYear = Math.floor(diffDay / 365);
+  if (diffSec < 60) return "just now";
+  if (diffMin < 60) return `${diffMin} minute${diffMin > 1 ? "s" : ""} ago`;
+  if (diffHour < 24) return `${diffHour} hour${diffHour > 1 ? "s" : ""} ago`;
+  if (diffDay < 7) return `${diffDay} day${diffDay > 1 ? "s" : ""} ago`;
+  if (diffWeek < 4) return `${diffWeek} week${diffWeek > 1 ? "s" : ""} ago`;
+  if (diffMonth < 12)
+    return `${diffMonth} month${diffMonth > 1 ? "s" : ""} ago`;
+  return `${diffYear} year${diffYear > 1 ? "s" : ""} ago`;
+}
+function formatMonthYear(date, locale = "en-US") {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  return dateObj.toLocaleDateString(locale, { month: "long", year: "numeric" });
+}
+function formatDateRange(startDate, endDate, locale = "en-US") {
+  const start = typeof startDate === "string" ? new Date(startDate) : startDate;
+  const end = typeof endDate === "string" ? new Date(endDate) : endDate;
+  const startFormatted = start.toLocaleDateString(locale, {
+    month: "short",
+    day: "numeric",
+    year: start.getFullYear() !== end.getFullYear() ? "numeric" : void 0
+  });
+  const endFormatted = end.toLocaleDateString(locale, {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+  return `${startFormatted} - ${endFormatted}`;
+}
+function isToday(date) {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  const today = /* @__PURE__ */ new Date();
+  return dateObj.getDate() === today.getDate() && dateObj.getMonth() === today.getMonth() && dateObj.getFullYear() === today.getFullYear();
+}
+function isPast(date) {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  return dateObj.getTime() < Date.now();
+}
+function isFuture(date) {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  return dateObj.getTime() > Date.now();
+}
+function nowMs() {
+  return Date.now();
+}
+function isSameMonth(a, b) {
+  const da = new Date(a);
+  const db = new Date(b);
+  return da.getFullYear() === db.getFullYear() && da.getMonth() === db.getMonth();
+}
+function currentYear() {
+  return new Date(nowMs()).getFullYear().toString();
+}
+function nowISO() {
+  return new Date(nowMs()).toISOString();
+}
+
+// src/number.formatter.ts
+function formatCurrency(amount, currency = "USD", locale = "en-US") {
+  return new Intl.NumberFormat(locale, { style: "currency", currency }).format(
+    amount
+  );
+}
+function formatNumber(num, locale = "en-US", options) {
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: options == null ? void 0 : options.decimals,
+    maximumFractionDigits: options == null ? void 0 : options.decimals
+  }).format(num);
+}
+function formatPercentage(num, decimals = 0) {
+  return `${(num * 100).toFixed(decimals)}%`;
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function formatCompactNumber(num) {
+  if (num < 1e3) return num.toString();
+  if (num < 1e6) return `${(num / 1e3).toFixed(1)}K`;
+  if (num < 1e9) return `${(num / 1e6).toFixed(1)}M`;
+  return `${(num / 1e9).toFixed(1)}B`;
+}
+function formatDecimal(num, decimals = 2) {
+  return num.toFixed(decimals);
+}
+function formatOrdinal(num) {
+  const suffixes = ["th", "st", "nd", "rd"];
+  const value = num % 100;
+  return num + (suffixes[(value - 20) % 10] || suffixes[value] || suffixes[0]);
+}
+function parseFormattedNumber(str) {
+  const isNegative = /^-/.test(str) || str.includes("-");
+  let cleaned = str.replace(/[^\d,.]/g, "");
+  if (cleaned === "" || cleaned === "0") return 0;
+  const lastCommaIndex = cleaned.lastIndexOf(",");
+  const lastDotIndex = cleaned.lastIndexOf(".");
+  const commaCount = (cleaned.match(/,/g) || []).length;
+  const dotCount = (cleaned.match(/\./g) || []).length;
+  let decimalSeparator = ".";
+  let thousandsSeparator = ",";
+  if (lastCommaIndex > -1 && lastDotIndex > -1) {
+    if (lastCommaIndex > lastDotIndex) {
+      decimalSeparator = ",";
+      thousandsSeparator = ".";
+    }
+  } else if (lastDotIndex > -1 && lastCommaIndex === -1) {
+    const afterDot = cleaned.substring(lastDotIndex + 1);
+    if (dotCount > 1) {
+      cleaned = cleaned.replace(/\./g, "");
+    } else if (afterDot.length > 3) {
+      cleaned = cleaned.replace(/\./g, "");
+    }
+    decimalSeparator = ".";
+    thousandsSeparator = "";
+  } else if (lastCommaIndex > -1 && lastDotIndex === -1) {
+    const afterComma = cleaned.substring(lastCommaIndex + 1);
+    if (commaCount > 1) {
+      cleaned = cleaned.replace(/,/g, "");
+      decimalSeparator = ".";
+      thousandsSeparator = "";
+    } else if (afterComma.length > 3) {
+      cleaned = cleaned.replace(/,/g, "");
+      decimalSeparator = ".";
+      thousandsSeparator = "";
+    } else {
+      decimalSeparator = ",";
+      thousandsSeparator = "";
+    }
+  }
+  let result = cleaned;
+  if (thousandsSeparator) {
+    result = result.replace(new RegExp("\\" + thousandsSeparator, "g"), "");
+  }
+  result = result.replace(decimalSeparator, ".");
+  const num = parseFloat(result);
+  return isNegative ? -Math.abs(num) : num;
+}
+
+// src/string.formatter.ts
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+function capitalizeWords(str) {
+  return str.split(" ").map((word) => capitalize(word)).join(" ");
+}
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+function truncateWords(str, wordCount, suffix = "...") {
+  const words = str.split(" ");
+  if (words.length <= wordCount) return str;
+  return words.slice(0, wordCount).join(" ") + suffix;
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "");
+}
+function escapeHtml(str) {
+  const map = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "/": "&#x2F;"
+  };
+  return str.replace(/[&<>"'/]/g, (char) => map[char]);
+}
+function slugify(str) {
+  return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function maskString(str, visibleStart = 4, visibleEnd = 4, maskChar = "*") {
+  if (str.length <= visibleStart + visibleEnd) return str;
+  const start = str.slice(0, visibleStart);
+  const end = str.slice(-visibleEnd);
+  const masked = maskChar.repeat(str.length - visibleStart - visibleEnd);
+  return start + masked + end;
+}
+function randomString(length = 10) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const indices = new Uint8Array(length);
+  globalThis.crypto.getRandomValues(indices);
+  return Array.from(indices, (i) => chars[i % chars.length]).join("");
+}
+function isEmptyString(str) {
+  return !str || str.trim().length === 0;
+}
+function renderProseMirrorNodes(nodes) {
+  return nodes.map(renderProseMirrorNode).join("");
+}
+function renderProseMirrorNode(node) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  switch (node.type) {
+    case "doc":
+      return renderProseMirrorNodes((_a = node.content) != null ? _a : []);
+    case "paragraph": {
+      const inner = renderProseMirrorNodes((_b = node.content) != null ? _b : []);
+      return inner ? `<p>${inner}</p>` : "<p></p>";
+    }
+    case "text": {
+      let text = escapeHtml((_c = node.text) != null ? _c : "");
+      if (node.marks) {
+        for (const mark of node.marks) {
+          if (mark.type === "bold") text = `<strong>${text}</strong>`;
+          else if (mark.type === "italic") text = `<em>${text}</em>`;
+          else if (mark.type === "underline") text = `<u>${text}</u>`;
+          else if (mark.type === "strike") text = `<s>${text}</s>`;
+          else if (mark.type === "code") text = `<code>${text}</code>`;
+          else if (mark.type === "link") {
+            const rawHref = String((_e = (_d = mark.attrs) == null ? void 0 : _d.href) != null ? _e : "#").trim();
+            const safe = /^(https?:\/\/|mailto:|\/|#)/i.test(rawHref) ? rawHref : "#";
+            const href = safe.replace(
+              /[&"<>]/g,
+              (c) => {
+                var _a2;
+                return (_a2 = { "&": "&amp;", '"': "&quot;", "<": "&lt;", ">": "&gt;" }[c]) != null ? _a2 : c;
+              }
+            );
+            text = `<a href="${href}" rel="noopener noreferrer">${text}</a>`;
+          }
+        }
+      }
+      return text;
+    }
+    case "heading": {
+      const level = (_g = (_f = node.attrs) == null ? void 0 : _f.level) != null ? _g : 2;
+      return `<h${level}>${renderProseMirrorNodes((_h = node.content) != null ? _h : [])}</h${level}>`;
+    }
+    case "bulletList":
+      return `<ul>${renderProseMirrorNodes((_i = node.content) != null ? _i : [])}</ul>`;
+    case "orderedList":
+      return `<ol>${renderProseMirrorNodes((_j = node.content) != null ? _j : [])}</ol>`;
+    case "listItem":
+      return `<li>${renderProseMirrorNodes((_k = node.content) != null ? _k : [])}</li>`;
+    case "blockquote":
+      return `<blockquote>${renderProseMirrorNodes((_l = node.content) != null ? _l : [])}</blockquote>`;
+    case "codeBlock":
+      return `<pre><code>${renderProseMirrorNodes((_m = node.content) != null ? _m : [])}</code></pre>`;
+    case "hardBreak":
+      return "<br>";
+    case "horizontalRule":
+      return "<hr>";
+    default:
+      return renderProseMirrorNodes((_n = node.content) != null ? _n : []);
+  }
+}
+function proseMirrorToHtml(value) {
+  var _a;
+  if (!value) return value;
+  try {
+    const parsed = JSON.parse(value);
+    if ((parsed == null ? void 0 : parsed.type) === "doc") {
+      return renderProseMirrorNodes((_a = parsed.content) != null ? _a : []);
+    }
+    return value;
+  } catch (e) {
+    return value;
+  }
+}
+
+// src/type.converter.ts
+function stringToBoolean(value) {
+  return ["true", "yes", "1", "on"].includes(value.toLowerCase());
+}
+function booleanToString(value, format = "truefalse") {
+  const formats = {
+    yesno: { true: "Yes", false: "No" },
+    truefalse: { true: "True", false: "False" },
+    onoff: { true: "On", false: "Off" }
+  };
+  return formats[format][value.toString()];
+}
+function arrayToObject(arr, keyField) {
+  return arr.reduce(
+    (acc, item) => {
+      const key = String(item[keyField]);
+      acc[key] = item;
+      return acc;
+    },
+    {}
+  );
+}
+function objectToArray(obj) {
+  return Object.values(obj);
+}
+function queryStringToObject(queryString) {
+  const params = new URLSearchParams(queryString);
+  const result = {};
+  params.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function objectToQueryString(obj) {
+  const params = new URLSearchParams();
+  Object.entries(obj).forEach(([key, value]) => {
+    if (value !== null && value !== void 0) {
+      params.append(key, String(value));
+    }
+  });
+  return params.toString();
+}
+function firestoreTimestampToDate(timestamp) {
+  if (timestamp && typeof timestamp === "object" && "toDate" in timestamp && typeof timestamp.toDate === "function") {
+    return timestamp.toDate();
+  }
+  if (timestamp && typeof timestamp === "object" && "seconds" in timestamp && typeof timestamp.seconds === "number") {
+    return new Date(timestamp.seconds * 1e3);
+  }
+  return new Date(timestamp);
+}
+function dateToISOString(date) {
+  return typeof date === "string" ? new Date(date).toISOString() : date.toISOString();
+}
+
+// src/cookie.converter.ts
+function parseCookies() {
+  if (typeof document === "undefined") return {};
+  const result = {};
+  for (const cookie of document.cookie.split(";")) {
+    const [name, ...valueParts] = cookie.trim().split("=");
+    if (name) result[name.trim()] = decodeURIComponent(valueParts.join("="));
+  }
+  return result;
+}
+function getCookie(name) {
+  if (typeof document === "undefined") return null;
+  for (const cookie of document.cookie.split(";")) {
+    const [cookieName, ...valueParts] = cookie.trim().split("=");
+    if ((cookieName == null ? void 0 : cookieName.trim()) === name)
+      return decodeURIComponent(valueParts.join("="));
+  }
+  return null;
+}
+function hasCookie(name) {
+  return getCookie(name) !== null;
+}
+function deleteCookie(name, path = "/") {
+  if (typeof document === "undefined") return;
+  document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=${path};`;
+}
+
+// src/id-generators.ts
+function generateRandomString(length = 6) {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const indices = new Uint8Array(length);
+  globalThis.crypto.getRandomValues(indices);
+  return Array.from(indices, (i) => chars[i % chars.length]).join("");
+}
+function getTimestamp() {
+  return Date.now().toString();
+}
+function generateCategoryId(input) {
+  const nameSlug = slugify(input.name);
+  if (input.parentName)
+    return `category-${nameSlug}-${slugify(input.parentName)}`;
+  if (input.rootName) return `category-${nameSlug}-${slugify(input.rootName)}`;
+  return `category-${nameSlug}`;
+}
+function generateUserId(input) {
+  const firstSlug = slugify(input.firstName);
+  const lastSlug = slugify(input.lastName);
+  const emailPrefix = input.email.split("@")[0].toLowerCase().substring(0, 8);
+  const emailSlug = slugify(emailPrefix);
+  return `user-${firstSlug}-${lastSlug}-${emailSlug}`;
+}
+function generateProductId(input) {
+  const count = input.count || 1;
+  return `product-${slugify(input.name)}-${slugify(input.category)}-${input.condition}-${slugify(input.sellerName)}-${count}`;
+}
+function generateAuctionId(input) {
+  const count = input.count || 1;
+  return `auction-${slugify(input.name)}-${slugify(input.category)}-${input.condition}-${slugify(input.sellerName)}-${count}`;
+}
+function generatePreOrderId(input) {
+  const count = input.count || 1;
+  return `preorder-${slugify(input.name)}-${slugify(input.category)}-${input.condition}-${slugify(input.sellerName)}-${count}`;
+}
+function generateReviewId(input) {
+  const date = input.date || /* @__PURE__ */ new Date();
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `review-${slugify(input.productName)}-${slugify(input.userFirstName)}-${y}${m}${d}`;
+}
+function generateOrderId(input) {
+  const date = input.date || /* @__PURE__ */ new Date();
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `order-${input.productCount}-${y}${m}${d}-${generateRandomString(6)}`;
+}
+function generateFAQId(input) {
+  return `faq-${slugify(input.category)}-${slugify(input.question).substring(0, 50)}`;
+}
+function generateCouponId(code) {
+  return `coupon-${code.toUpperCase().replace(/[^A-Z0-9]/g, "")}`;
+}
+function generateCarouselId(input) {
+  return `carousel-${slugify(input.title).substring(0, 30)}-${getTimestamp()}`;
+}
+function generateHomepageSectionId(input) {
+  return `section-${slugify(input.type)}-${getTimestamp()}`;
+}
+function generateBidId(input) {
+  const date = input.date || /* @__PURE__ */ new Date();
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const random = input.random || generateRandomString(6);
+  return `bid-${slugify(input.productName).substring(0, 30)}-${slugify(input.userFirstName)}-${y}${m}${d}-${random}`;
+}
+function generateBlogPostId(input) {
+  const titleSlug = slugify(input.title).substring(0, 40).replace(/-+$/, "");
+  const categorySlug = slugify(input.category);
+  const base = `blog-${titleSlug}-${categorySlug}`;
+  if (input.status && input.status !== "published")
+    return `${base}-${input.status}`;
+  return base;
+}
+function generatePayoutId(input) {
+  const sellerSlug = slugify(input.sellerName).substring(0, 25).replace(/-+$/, "");
+  const date = input.date || /* @__PURE__ */ new Date();
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `payout-${sellerSlug}-${y}${m}${d}-${generateRandomString(6)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  arrayToObject,
+  booleanToString,
+  capitalize,
+  capitalizeWords,
+  currentYear,
+  dateToISOString,
+  deleteCookie,
+  escapeHtml,
+  firestoreTimestampToDate,
+  formatCompactNumber,
+  formatCurrency,
+  formatDate,
+  formatDateRange,
+  formatDateTime,
+  formatDecimal,
+  formatFileSize,
+  formatMonthYear,
+  formatNumber,
+  formatOrdinal,
+  formatPercentage,
+  formatRelativeTime,
+  formatTime,
+  generateAuctionId,
+  generateBidId,
+  generateBlogPostId,
+  generateCarouselId,
+  generateCategoryId,
+  generateCouponId,
+  generateFAQId,
+  generateHomepageSectionId,
+  generateOrderId,
+  generatePayoutId,
+  generatePreOrderId,
+  generateProductId,
+  generateReviewId,
+  generateUserId,
+  getCookie,
+  hasCookie,
+  isEmptyString,
+  isFuture,
+  isPast,
+  isSameMonth,
+  isToday,
+  maskString,
+  nowISO,
+  nowMs,
+  objectToArray,
+  objectToQueryString,
+  parseCookies,
+  parseFormattedNumber,
+  proseMirrorToHtml,
+  queryStringToObject,
+  randomString,
+  resolveDate,
+  slugify,
+  stringToBoolean,
+  stripHtml,
+  truncate,
+  truncateWords
+});