@mohasinac/utils 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,3 +1,20 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
 // src/date.formatter.ts
 function resolveDate(value) {
   if (!value) return null;
@@ -150,6 +167,17 @@ function currentYear() {
 function nowISO() {
   return new Date(nowMs()).toISOString();
 }
+function formatCustomDate(date, format = "medium") {
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+  const formatOptions = {
+    short: { month: "numeric", day: "numeric", year: "2-digit" },
+    medium: { month: "short", day: "numeric", year: "numeric" },
+    long: { month: "long", day: "numeric", year: "numeric" },
+    full: { weekday: "long", month: "long", day: "numeric", year: "numeric" }
+  };
+  const options = formatOptions[format] || formatOptions.medium;
+  return dateObj.toLocaleDateString("en-US", options);
+}
 
 // src/number.formatter.ts
 function formatCurrency(amount, currency = "USD", locale = "en-US") {
@@ -525,18 +553,370 @@ function generatePayoutId(input) {
   const d = String(date.getDate()).padStart(2, "0");
   return `payout-${sellerSlug}-${y}${m}${d}-${generateRandomString(6)}`;
 }
+
+// src/array.helper.ts
+function groupBy(array, key) {
+  return array.reduce(
+    (result, item) => {
+      const groupKey = String(item[key]);
+      if (!result[groupKey]) {
+        result[groupKey] = [];
+      }
+      result[groupKey].push(item);
+      return result;
+    },
+    {}
+  );
+}
+function unique(array) {
+  return Array.from(new Set(array));
+}
+function uniqueBy(array, key) {
+  const seen = /* @__PURE__ */ new Set();
+  return array.filter((item) => {
+    const value = item[key];
+    if (seen.has(value)) return false;
+    seen.add(value);
+    return true;
+  });
+}
+function sortBy(array, key, order = "asc") {
+  return [...array].sort((a, b) => {
+    const aVal = a[key];
+    const bVal = b[key];
+    if (aVal < bVal) return order === "asc" ? -1 : 1;
+    if (aVal > bVal) return order === "asc" ? 1 : -1;
+    return 0;
+  });
+}
+function chunk(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+function paginate(array, page, perPage) {
+  const total = array.length;
+  const totalPages = Math.ceil(total / perPage);
+  const start = (page - 1) * perPage;
+  const end = start + perPage;
+  return { data: array.slice(start, end), total, page, perPage, totalPages };
+}
+
+// src/object.helper.ts
+function deepMerge(target, source) {
+  const output = __spreadValues({}, target);
+  Object.keys(source).forEach((key) => {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+      output[key] = deepMerge(targetValue, sourceValue);
+    } else {
+      output[key] = sourceValue;
+    }
+  });
+  return output;
+}
+function pick(obj, keys) {
+  const result = {};
+  keys.forEach((key) => {
+    if (key in obj) result[key] = obj[key];
+  });
+  return result;
+}
+function omit(obj, keys) {
+  const result = __spreadValues({}, obj);
+  keys.forEach((key) => {
+    delete result[key];
+  });
+  return result;
+}
+function isEmptyObject(obj) {
+  return Object.keys(obj).length === 0;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj))
+    return obj.map((item) => deepClone(item));
+  const cloned = {};
+  Object.keys(obj).forEach((key) => {
+    cloned[key] = deepClone(obj[key]);
+  });
+  return cloned;
+}
+function isEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (typeof obj1 !== "object" || typeof obj2 !== "object" || obj1 === null || obj2 === null) {
+    return false;
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  return keys1.every((key) => isEqual(obj1[key], obj2[key]));
+}
+function cleanObject(obj, options = {}) {
+  const {
+    removeEmpty = true,
+    removeNull = true,
+    removeUndefined = true
+  } = options;
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const shouldRemove = removeUndefined && value === void 0 || removeNull && value === null || removeEmpty && value === "";
+    if (!shouldRemove) acc[key] = value;
+    return acc;
+  }, {});
+}
+
+// src/pagination.helper.ts
+function calculatePagination(options) {
+  const { page, perPage, total } = options;
+  const totalPages = Math.ceil(total / perPage);
+  const currentPage = Math.max(1, Math.min(page, totalPages));
+  const startIndex = (currentPage - 1) * perPage;
+  const endIndex = Math.min(startIndex + perPage, total);
+  return {
+    currentPage,
+    perPage,
+    total,
+    totalPages,
+    hasNextPage: currentPage < totalPages,
+    hasPrevPage: currentPage > 1,
+    nextPage: currentPage < totalPages ? currentPage + 1 : null,
+    prevPage: currentPage > 1 ? currentPage - 1 : null,
+    startIndex,
+    endIndex
+  };
+}
+
+// src/sorting.helper.ts
+function sort(array, key, order = "asc") {
+  return [...array].sort((a, b) => {
+    const aVal = a[key];
+    const bVal = b[key];
+    if (aVal < bVal) return order === "asc" ? -1 : 1;
+    if (aVal > bVal) return order === "asc" ? 1 : -1;
+    return 0;
+  });
+}
+
+// src/filter.helper.ts
+function buildSieveFilters(...entries) {
+  return entries.filter((entry) => !!entry[1]).map(([expr, value]) => `${expr}${value}`).join(",");
+}
+
+// src/animation.helper.ts
+var easings = {
+  linear: (t) => t,
+  easeInQuad: (t) => t * t,
+  easeOutQuad: (t) => t * (2 - t),
+  easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+  easeInCubic: (t) => t * t * t,
+  easeOutCubic: (t) => --t * t * t + 1,
+  easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+  easeInQuart: (t) => t * t * t * t,
+  easeOutQuart: (t) => 1 - --t * t * t * t,
+  easeInOutQuart: (t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t
+};
+
+// src/color.helper.ts
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : null;
+}
+function rgbToHex(r, g, b) {
+  return "#" + [r, g, b].map((x) => {
+    const hex = x.toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  }).join("");
+}
+function getContrastColor(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return "#000000";
+  const luminance = (0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b) / 255;
+  return luminance > 0.5 ? "#000000" : "#ffffff";
+}
+
+// src/event-manager.ts
+var GlobalEventManager = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.handlerIds = /* @__PURE__ */ new Map();
+  }
+  generateId(type, target) {
+    var _a;
+    const targetId = this.getTargetId(target);
+    const key = `${type}-${targetId}`;
+    const count = ((_a = this.handlerIds.get(key)) != null ? _a : 0) + 1;
+    this.handlerIds.set(key, count);
+    return `${key}-${count}`;
+  }
+  getTargetId(target) {
+    if (target === window) return "window";
+    if (target === document) return "document";
+    if (target instanceof HTMLElement && target.id) return target.id;
+    return `element-${crypto.randomUUID()}`;
+  }
+  add(target, type, callback, options) {
+    const id = this.generateId(type, target);
+    if (!this.handlers.has(id)) this.handlers.set(id, []);
+    this.handlers.get(id).push({ type, target, callback, options });
+    target.addEventListener(type, callback, options);
+    return id;
+  }
+  remove(id) {
+    const handlers = this.handlers.get(id);
+    if (!handlers) return;
+    handlers.forEach(({ type, target, callback, options }) => target.removeEventListener(type, callback, options));
+    this.handlers.delete(id);
+  }
+  removeAllForTarget(target, type) {
+    const toRemove = [];
+    this.handlers.forEach((handlers, id) => {
+      const matchesTarget = handlers.some((h) => h.target === target);
+      const matchesType = !type || handlers.some((h) => h.type === type);
+      if (matchesTarget && matchesType) toRemove.push(id);
+    });
+    toRemove.forEach((id) => this.remove(id));
+  }
+  clear() {
+    this.handlers.forEach(
+      (handlers) => handlers.forEach(({ type, target, callback, options }) => target.removeEventListener(type, callback, options))
+    );
+    this.handlers.clear();
+    this.handlerIds.clear();
+  }
+  getHandlerCount() {
+    return this.handlers.size;
+  }
+  has(id) {
+    return this.handlers.has(id);
+  }
+};
+var globalEventManager = new GlobalEventManager();
+function throttle(func, delay) {
+  let timeoutId = null;
+  let lastRun = 0;
+  return (...args) => {
+    const now = Date.now();
+    if (now - lastRun >= delay) {
+      func(...args);
+      lastRun = now;
+    } else {
+      if (timeoutId) clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        func(...args);
+        lastRun = Date.now();
+      }, delay - (now - lastRun));
+    }
+  };
+}
+function debounce(func, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => func(...args), delay);
+  };
+}
+function addGlobalScrollHandler(callback, options) {
+  const { throttle: throttleDelay = 100, target = window } = options != null ? options : {};
+  const handler = throttleDelay > 0 ? throttle(callback, throttleDelay) : callback;
+  return globalEventManager.add(target, "scroll", handler, { passive: true });
+}
+function addGlobalResizeHandler(callback, options) {
+  const { throttle: throttleDelay = 200 } = options != null ? options : {};
+  const handler = throttleDelay > 0 ? throttle(callback, throttleDelay) : callback;
+  return globalEventManager.add(window, "resize", handler);
+}
+function addGlobalClickHandler(selector, callback, options) {
+  const handler = (event) => {
+    const element = event.target.closest(selector);
+    if (element) {
+      if (options == null ? void 0 : options.preventDefault) event.preventDefault();
+      callback(event, element);
+    }
+  };
+  return globalEventManager.add(document, "click", handler);
+}
+function addGlobalKeyHandler(key, callback, options) {
+  const keys = Array.isArray(key) ? key : [key];
+  const { preventDefault = false, ctrl = false, shift = false, alt = false, meta = false } = options != null ? options : {};
+  const handler = (event) => {
+    const e = event;
+    if (!keys.some((k) => e.key === k || e.code === k)) return;
+    if (e.ctrlKey !== ctrl || e.shiftKey !== shift || e.altKey !== alt || e.metaKey !== meta) return;
+    if (preventDefault) event.preventDefault();
+    callback(e);
+  };
+  return globalEventManager.add(document, "keydown", handler);
+}
+function removeGlobalHandler(id) {
+  globalEventManager.remove(id);
+}
+function isMobileDevice() {
+  if (typeof window === "undefined") return false;
+  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+function hasTouchSupport() {
+  if (typeof window === "undefined") return false;
+  return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+}
+function getViewportDimensions() {
+  if (typeof window === "undefined") return { width: 0, height: 0 };
+  return { width: window.innerWidth || document.documentElement.clientWidth, height: window.innerHeight || document.documentElement.clientHeight };
+}
+function isInViewport(element, offset = 0) {
+  if (typeof window === "undefined") return false;
+  const rect = element.getBoundingClientRect();
+  const { width, height } = getViewportDimensions();
+  return rect.top >= -offset && rect.left >= -offset && rect.bottom <= height + offset && rect.right <= width + offset;
+}
+function smoothScrollTo(element, options) {
+  const target = typeof element === "string" ? document.querySelector(element) : element;
+  if (!target) return;
+  const { offset = 0 } = options != null ? options : {};
+  window.scrollTo({ top: target.getBoundingClientRect().top + window.pageYOffset - offset, behavior: "smooth" });
+}
+function preventBodyScroll(prevent) {
+  if (typeof document === "undefined") return;
+  if (prevent) {
+    document.body.style.overflow = "hidden";
+    document.body.style.paddingRight = `${window.innerWidth - document.documentElement.clientWidth}px`;
+  } else {
+    document.body.style.overflow = "";
+    document.body.style.paddingRight = "";
+  }
+}
 export {
+  GlobalEventManager,
+  addGlobalClickHandler,
+  addGlobalKeyHandler,
+  addGlobalResizeHandler,
+  addGlobalScrollHandler,
   arrayToObject,
   booleanToString,
+  buildSieveFilters,
+  calculatePagination,
   capitalize,
   capitalizeWords,
+  chunk,
+  cleanObject,
   currentYear,
   dateToISOString,
+  debounce,
+  deepClone,
+  deepMerge,
   deleteCookie,
+  easings,
   escapeHtml,
   firestoreTimestampToDate,
   formatCompactNumber,
   formatCurrency,
+  formatCustomDate,
   formatDate,
   formatDateRange,
   formatDateTime,
@@ -562,10 +942,20 @@ export {
   generateProductId,
   generateReviewId,
   generateUserId,
+  getContrastColor,
   getCookie,
+  getViewportDimensions,
+  globalEventManager,
+  groupBy,
   hasCookie,
+  hasTouchSupport,
+  hexToRgb,
+  isEmptyObject,
   isEmptyString,
+  isEqual,
   isFuture,
+  isInViewport,
+  isMobileDevice,
   isPast,
   isSameMonth,
   isToday,
@@ -574,15 +964,27 @@ export {
   nowMs,
   objectToArray,
   objectToQueryString,
+  omit,
+  paginate,
   parseCookies,
   parseFormattedNumber,
+  pick,
+  preventBodyScroll,
   proseMirrorToHtml,
   queryStringToObject,
   randomString,
+  removeGlobalHandler,
   resolveDate,
+  rgbToHex,
   slugify,
+  smoothScrollTo,
+  sort,
+  sortBy,
   stringToBoolean,
   stripHtml,
+  throttle,
   truncate,
-  truncateWords
+  truncateWords,
+  unique,
+  uniqueBy
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mohasinac/utils",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "private": false,
   "publishConfig": {