@dev.smartpricing/message-composer-utils 3.1.2

package/src/types/meta-webhook.ts

@@ -0,0 +1,32 @@
+export interface MetaWebhookPayload {
+  entry: MetaWebhookEntry;
+  object: "whatsapp_business_account";
+}
+
+export interface MetaWebhookEntry {
+  id: string;
+  time: number;
+  changes: MetaWebhookChange[];
+}
+
+export interface MetaWebhookChange {
+  value: MetaTemplateStatusUpdate | MetaTemplateCategoryUpdate;
+  field: "message_template_status_update" | "template_category_update";
+}
+
+export interface MetaTemplateCategoryUpdate {
+  message_template_id: number;
+  message_template_name: string;
+  message_template_language: string;
+  new_category: "MARKETING" | "UTILITY";
+}
+
+export type MetaTemplateStatus = "APPROVED" | "REJECTED" | "PENDING";
+export type InternalTemplateStatus = "approved" | "rejected" | "pending";
+export interface MetaTemplateStatusUpdate {
+  event: MetaTemplateStatus;
+  message_template_id: number;
+  message_template_name: string;
+  message_template_language: string;
+  reason: string;
+}

package/src/types/submission-job.ts

@@ -0,0 +1,30 @@
+export type SubmissionJobStatus =
+  | "queued"
+  | "processing"
+  | "completed"
+  | "failed";
+
+export interface SubmissionJob {
+  id: string;
+  message_group_id: string;
+  status: SubmissionJobStatus;
+  submitted_count: number;
+  failed_count: number;
+  errors: Array<{
+    messageId: string;
+    error: string;
+  }>;
+  meta_config: {
+    wabaId: string;
+    accessToken: string;
+    apiVersion?: string;
+  };
+  created_at: string;
+  updated_at: string;
+}
+
+export interface SubmissionJobResponse {
+  jobId: string;
+  status: "queued";
+  message: string;
+}

package/src/types/tag.ts

@@ -0,0 +1,8 @@
+import type { DbEntity, WithDbTimestamps } from "./utils.js";
+
+export interface Tag extends DbEntity {
+  id: string;
+  name: string;
+}
+
+export type TagFromDb = WithDbTimestamps<Tag>;

package/src/types/utils.ts

@@ -0,0 +1,14 @@
+export type WithDbTimestamps<T> = {
+  [k in keyof T]: T[k] extends Date ? string : T[k];
+};
+
+export type DbEntity = {
+  id: string;
+  created_at: Date;
+  updated_at: Date;
+};
+
+export type PostEntity<T extends DbEntity> = Omit<
+  T,
+  "id" | "created_at" | "updated_at"
+>;

package/src/types/whatsappblocks.v1.ts

@@ -0,0 +1,102 @@
+import type { JSONContent } from "@tiptap/core";
+
+export const WA_HEADER_TYPES_V1 = [
+  "none",
+  "text",
+  "video",
+  "image",
+  "document",
+] as const;
+
+export type WaHeaderTypeV1 = (typeof WA_HEADER_TYPES_V1)[number];
+
+interface WaHeaderTypeV1Base {
+  type: WaHeaderTypeV1;
+}
+
+export interface WaHeaderTypeV1Text extends WaHeaderTypeV1Base {
+  type: "text";
+  content: JSONContent | undefined;
+}
+
+export interface WaHeaderTypeV1Url extends WaHeaderTypeV1Base {
+  type: "video" | "document" | "image";
+  url: string;
+  metaMediaId?: string;
+  smartchatMediaId?: string;
+}
+
+export interface WaHeaderTypeV1None extends WaHeaderTypeV1Base {
+  type: "none";
+}
+
+export type HeaderBlockV1 =
+  | WaHeaderTypeV1Text
+  | WaHeaderTypeV1Url
+  | WaHeaderTypeV1None;
+
+export type BodyBlockV1 = {
+  enabled: true;
+  content: undefined | JSONContent;
+};
+
+export type FooterBlockV1 = {
+  enabled: boolean;
+  content: string;
+};
+
+export const WA_BUTTON_TYPES_V1 = [
+  "unsubscribe",
+  "phone",
+  "link",
+  "quick_reply",
+] as const;
+
+export type WaButtonTypeV1 = (typeof WA_BUTTON_TYPES_V1)[number];
+
+interface WaButtonV1Base {
+  id: string;
+  type: WaButtonTypeV1;
+  text: string; // max 20 characters
+}
+
+interface WaButtonV1Unsubscribe extends WaButtonV1Base {
+  type: "unsubscribe";
+}
+
+interface WaButtonV1Phone extends WaButtonV1Base {
+  type: "phone";
+  phoneNumber: string;
+}
+
+interface WaButtonV1Link extends WaButtonV1Base {
+  type: "link";
+  url: string;
+}
+
+interface WaButtonV1QuickReply extends WaButtonV1Base {
+  type: "quick_reply";
+}
+
+export type WaButtonV1 =
+  | WaButtonV1Unsubscribe
+  | WaButtonV1Phone
+  | WaButtonV1Link
+  | WaButtonV1QuickReply;
+
+export type ButtonBlockV1 = {
+  enabled: boolean;
+  buttons: WaButtonV1[];
+};
+
+// Validation constants
+export const WA_HEADER_TEXT_MAX_LENGTH = 60;
+export const WA_BODY_MAX_LENGTH = 1024;
+export const WA_FOOTER_MAX_LENGTH = 60;
+export const WA_BUTTON_TEXT_MAX_LENGTH = 20;
+export const WA_BUTTON_MAX_LINK_BUTTONS = 1;
+export const WA_BUTTON_MAX_PHONE_BUTTONS = 1;
+export const WA_BUTTON_MAX_UNSUBSCRIBE_BUTTONS = 1;
+export const WA_BUTTON_MAX_QUICK_REPLY_BUTTONS = 3;
+
+export const WA_BUTTON_MAX_BUTTONS = 10;

package/src/utils/array.ts

@@ -0,0 +1,33 @@
+// Array utility functions
+export const unique = <T>(array: T[]): T[] => {
+  return [...new Set(array)];
+};
+
+export const uniqueBy = <T, K>(array: T[], keyFn: (item: T) => K): T[] => {
+  const seen = new Set<K>();
+  return array.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+};
+
+export const groupBy = <T, K extends string | number>(
+  array: T[],
+  keyFn: (item: T) => K,
+): Record<K, T[]> => {
+  return array.reduce(
+    (groups, item) => {
+      const key = keyFn(item);
+      if (!groups[key]) {
+        groups[key] = [];
+      }
+      groups[key].push(item);
+      return groups;
+    },
+    {} as Record<K, T[]>,
+  );
+};

package/src/utils/async.ts

@@ -0,0 +1,30 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export const sleep = (ms: number): Promise<void> => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+export const debounce = <T extends (...args: any[]) => void>(
+  func: T,
+  delay: number,
+): ((...args: Parameters<T>) => void) => {
+  let timeoutId: ReturnType<typeof setTimeout>;
+  return (...args: Parameters<T>) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => func(...args), delay);
+  };
+};
+
+export const throttle = <T extends (...args: any[]) => void>(
+  func: T,
+  limit: number,
+): ((...args: Parameters<T>) => void) => {
+  let inThrottle: boolean;
+  return (...args: Parameters<T>) => {
+    if (!inThrottle) {
+      func(...args);
+      inThrottle = true;
+      setTimeout(() => (inThrottle = false), limit);
+    }
+  };
+};

package/src/utils/date.ts

@@ -0,0 +1,39 @@
+function parseDate(date: Date | string | number): Date {
+  if (typeof date === "number") {
+    return new Date(date);
+  }
+  if (typeof date === "string") {
+    return new Date(date);
+  }
+  return date;
+}
+
+// Date utility functions
+export const formatDate = (date: Date | string | number): string => {
+  date = parseDate(date);
+  return new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).format(date);
+};
+
+export const formatDateTime = (date: Date | string): string => {
+  date = parseDate(date);
+  return new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  }).format(date);
+};
+
+export const formatTime = (date: Date | string): string => {
+  date = parseDate(date);
+  return new Intl.DateTimeFormat("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  }).format(date);
+};

package/src/utils/index.ts

@@ -0,0 +1,44 @@
+// Export all utilities by category
+export * from "./async.js";
+export * from "./array.js";
+export * from "./date.js";
+export * from "./number.js";
+export * from "./object.js";
+export * from "./string.js";
+export * from "./intl.js";
+export * from "./templates/messages.js";
+export * from "./templates/whatsapp.js";
+export * from "./templates/email.js";
+export * from "./templates/meta.js";
+export * from "./templates/tiptap.js";
+export * from "./templates/whatsapp-compiler.js";
+export * from "./templates/email-compiler.js";
+export * from "./templates/email-mjml.js";
+export * from "./templates/brand-cascade.js";
+export * from "./templates/html-sanitizer.js";
+export * from "./validations.js";
+export * from "./meta-status.js";
+
+// Also export as namespaced modules for cleaner imports
+export * as AsyncUtils from "./async.js";
+export * as ArrayUtils from "./array.js";
+export * as DateUtils from "./date.js";
+export * as NumberUtils from "./number.js";
+export * as ObjectUtils from "./object.js";
+export * as StringUtils from "./string.js";
+export * as WhatsappUtils from "./templates/whatsapp.js";
+export * as ValidationsUtils from "./validations.js";
+export * as IntlUtils from "./intl.js";
+
+// Re-export specific functions with aliases for clarity
+export {
+  normalizeParameters,
+  compileWhatsappTemplate,
+  extractRequiredParameters,
+  validateParameters as validateWhatsappParameters,
+} from "./templates/whatsapp-compiler.js";
+
+export {
+  extractEmailParameters,
+  validateEmailParameters,
+} from "./templates/email-compiler.js";

package/src/utils/intl.ts

@@ -0,0 +1,51 @@
+function getIntlDisplayName(settings: {
+  locale: string;
+  type: Intl.DisplayNamesType;
+  of: string;
+}) {
+  if (settings.of.trim() === "") {
+    return "-";
+  }
+  try {
+    const x = new Intl.DisplayNames([settings.locale], {
+      type: settings.type,
+    }).of(settings.of.toUpperCase());
+    return x;
+  } catch (e) {
+    console.log(e);
+    return settings.of;
+  }
+}
+
+export function getLanguageDisplayName(
+  language: string | null,
+  locale: string = "en",
+) {
+  return getIntlDisplayName({
+    locale: locale,
+    type: "language",
+    of: language ?? "",
+  });
+}
+
+export function getCountryDisplayName(
+  country: string | null,
+  locale: string = "en",
+) {
+  return getIntlDisplayName({
+    locale: locale,
+    type: "region",
+    of: country ?? "",
+  });
+}
+
+export function getNationalityDisplayName(
+  nationality: string | null,
+  locale: string = "en",
+) {
+  return getIntlDisplayName({
+    locale: locale,
+    type: "region",
+    of: nationality ?? "",
+  });
+}

package/src/utils/meta-status.ts

@@ -0,0 +1,24 @@
+import { MetaTemplateStatus, InternalTemplateStatus } from "../types/index.js";
+
+/**
+ * Converts Meta API status to internal status format
+ * @param metaStatus The status from Meta API
+ * @returns The internal status representation
+ */
+export function mapMetaStatusToInternal(
+  metaStatus?: MetaTemplateStatus,
+): InternalTemplateStatus | null {
+  if (!metaStatus) {
+    return null;
+  }
+  switch (metaStatus) {
+    case "PENDING":
+      return "pending";
+    case "APPROVED":
+      return "approved";
+    case "REJECTED":
+      return "rejected";
+    default:
+      return "pending";
+  }
+}

package/src/utils/number.ts

@@ -0,0 +1,36 @@
+// Number utility functions
+export const randomBetween = (min: number, max: number): number => {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+
+export const clamp = (value: number, min: number, max: number): number => {
+  return Math.min(Math.max(value, min), max);
+};
+
+export const formatNumber = (
+  value: number,
+  options: Intl.NumberFormatOptions = {},
+): string => {
+  return new Intl.NumberFormat("en-US", options).format(value);
+};
+
+export const formatCurrency = (
+  value: number,
+  currency: string = "USD",
+): string => {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency,
+  }).format(value);
+};
+
+export const formatPercentage = (
+  value: number,
+  decimals: number = 2,
+): string => {
+  return new Intl.NumberFormat("en-US", {
+    style: "percent",
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+  }).format(value);
+};

package/src/utils/object.ts

@@ -0,0 +1,101 @@
+/**
+ * Object utility functions
+ */
+
+/**
+ * Checks if value is a function
+ */
+export function isFunction<T>(
+  value: unknown,
+): value is (...args: unknown[]) => T {
+  return typeof value === "function";
+}
+
+/**
+ * Gets the value at path of object. Similar to lodash get.
+ */
+export function get<T = unknown>(
+  object: unknown,
+  path: string | string[],
+): T | undefined {
+  if (!object || !path) {
+    return undefined;
+  }
+
+  const pathArray = Array.isArray(path) ? path : path.split(".");
+
+  let result = object;
+  for (let i = 0; i < pathArray.length; i++) {
+    if (result == null) {
+      return undefined;
+    }
+    result = result[pathArray[i] as keyof typeof result];
+  }
+
+  return result as T;
+}
+
+/**
+ * Checks if a value exists and is not null or undefined
+ */
+export function isDefined<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined;
+}
+
+export function isEmpty(value: unknown): boolean {
+  if (value === null || value === undefined) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+
+export function deepClone<T>(value: T): T {
+  try {
+    return structuredClone(value) as T;
+  } catch {
+    // Fallback to JSON serialization for objects that can't be structuredClone'd
+    // (e.g., Vue reactive proxies, objects with symbols, etc.)
+    return JSON.parse(JSON.stringify(value)) as T;
+  }
+}
+
+/**
+ * Deep equality comparison between two values
+ */
+export function deepEqual(a: unknown, b: unknown): boolean {
+  // Handle identical references and primitive equality
+  if (a === b) return true;
+
+  // Handle null/undefined
+  if (a == null || b == null) return a === b;
+
+  // Handle dates
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+
+  // Handle arrays
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+
+  // Handle objects
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a as object);
+    const keysB = Object.keys(b as object);
+
+    if (keysA.length !== keysB.length) return false;
+
+    return keysA.every(
+      (key) =>
+        Object.prototype.hasOwnProperty.call(b, key) &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        deepEqual((a as any)[key], (b as any)[key]),
+    );
+  }
+
+  // Handle other types (strings, numbers, etc)
+  return a === b;
+}

package/src/utils/string.ts

@@ -0,0 +1,24 @@
+// String utility functions
+export const capitalize = (str: string): string => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+export const truncate = (str: string, length: number): string => {
+  if (str.length <= length) return str;
+  return str.substring(0, length) + "...";
+};
+
+export const snakeCase = (str: string): string => {
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/\s+/g, "_")
+    .toLowerCase();
+};
+
+export const removeWhitespace = (str: string): string => {
+  return str.replaceAll(" ", "");
+};
+
+export const isEmptyOrWhitespace = (str: string): boolean => {
+  return !str || !str.trim();
+};