@getmicdrop/venue-calendar 3.2.0 → 3.3.1

package/src/lib/utils/utils.js

@@ -0,0 +1,806 @@
+import Cookies from "js-cookie";
+import { 
+  transformEvent as transformEventNew,
+  TransformMode,
+  calculateTicketStatus as calculateTicketStatusNew,
+  findLowestPrice as findLowestPriceNew,
+} from './event-transform.js';
+
+// Re-export datetime functions from consolidated module
+export {
+  getIANATimezone,
+  formatEventTime,
+  formatTimeRange,
+  formatCleanTimeRange,
+  formatDayOfWeek,
+  formatMonth,
+  formatHour,
+  getDateParts,
+  formatEventDateTime,
+  formatNotificationTime,
+  isToday,
+  DEFAULT_TIMEZONE,
+} from './datetime.js';
+
+// Re-export from consolidated module for backward compatibility
+export { transformEventNew as transformEvent };
+export { calculateTicketStatusNew as calculateTicketStatus };
+export { findLowestPriceNew as findLowestPrice };
+
+/**
+ * Get the number of days in a month for a given date
+ * @param {Date} date - Any date in the target month
+ * @returns {number} - Number of days in that month (28-31)
+ */
+export function getDaysInMonth(date) {
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+}
+
+/**
+ * Navigation utility that works in both SvelteKit and standalone environments
+ * @param {string} url - The URL to navigate to
+ * @param {Object} options - Navigation options
+ * @param {boolean} options.replaceState - Whether to replace current history entry
+ * @param {Function} options.navigateFn - Optional custom navigation function (for SvelteKit)
+ */
+export function navigate(url, options = {}) {
+  const { replaceState = false, navigateFn } = options;
+
+  // Use custom navigation function if provided (for SvelteKit)
+  if (navigateFn && typeof navigateFn === 'function') {
+    navigateFn(url, { replaceState });
+    return;
+  }
+
+  // Standalone environment - use browser navigation
+  if (typeof window !== 'undefined') {
+    if (replaceState) {
+      window.history.replaceState({}, '', url);
+    } else {
+      window.history.pushState({}, '', url);
+    }
+
+    // Dispatch a custom event for standalone environments to handle navigation
+    window.dispatchEvent(new CustomEvent('micdrop-navigate', { detail: { url, replaceState } }));
+  }
+}
+
+export function classNames(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+
+export function truncateTitle(title, maxLength) {
+  if (title.length > maxLength) {
+    return title.slice(0, maxLength) + "...";
+  }
+  return title;
+}
+
+export function getDays(params) {
+  if (params === "weeks") {
+    return [
+      { value: "monday", label: "Monday" },
+      { value: "tuesday", label: "Tuesday" },
+      { value: "wednesday", label: "Wednesday" },
+      { value: "thursday", label: "Thursday" },
+      { value: "friday", label: "Friday" },
+    ];
+  } else {
+    return Array.from({ length: 31 }, (_, i) => {
+      const day = i + 1;
+      const suffix =
+        day % 10 === 1 && day !== 11
+          ? "st"
+          : day % 10 === 2 && day !== 12
+          ? "nd"
+          : day % 10 === 3 && day !== 13
+          ? "rd"
+          : "th";
+      return {
+        value: day.toString(),
+        label: day + suffix,
+      };
+    });
+  }
+}
+
+export function getDaysNumberOptions(timeUnit) {
+  if (timeUnit === "months") {
+    return Array.from({ length: 12 }, (_, i) => ({
+      value: (i + 1).toString(),
+      label: (i + 1).toString(),
+    }));
+  } else if (timeUnit === "weeks") {
+    return Array.from({ length: 10 }, (_, i) => ({
+      value: (i + 1).toString(),
+      label: (i + 1).toString(),
+    }));
+  } else {
+    return Array.from({ length: 31 }, (_, i) => ({
+      value: (i + 1).toString(),
+      label: (i + 1).toString(),
+    }));
+  }
+}
+
+// =============================================================================
+// DEPRECATED: Date formatting functions
+// These are now re-exported from datetime.js (see top of file).
+// The functions below are kept temporarily for any legacy code that imports them
+// directly. They will be removed in a future version.
+// =============================================================================
+
+/**
+ * @deprecated Use formatEventDateTime from datetime.js instead
+ */
+export function convertToDate(value, timeZone = "UTC") {
+  if (!value) return null;
+
+  const date = new Date(value);
+  return date.toLocaleString("en-US", {
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZone: timeZone,
+  });
+}
+
+/**
+ * @deprecated This is a legacy date conversion function
+ */
+export function convertToCustomDateTimeFormat(isoDateString) {
+  const date = new Date(isoDateString);
+  return new Date(
+    Date.UTC(
+      date.getUTCFullYear(),
+      date.getUTCMonth(),
+      date.getUTCDate(),
+      date.getUTCHours(),
+      date.getUTCMinutes()
+    )
+  );
+}
+
+/**
+ * @deprecated Use formatEventTime from datetime.js instead
+ */
+export const formatTimeline = (startDateTime, timeZone = "UTC") => {
+  if (!startDateTime) return "";
+
+  const date = new Date(startDateTime);
+  if (isNaN(date.getTime())) return "";
+
+  return new Intl.DateTimeFormat("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZone: timeZone,
+  }).format(date);
+};
+
+/**
+ * @deprecated Use formatDayOfWeek from datetime.js instead
+ */
+export const getDay = (dateString, timeZone = "UTC") => {
+  if (!dateString) return "";
+
+  const date = new Date(dateString);
+  if (isNaN(date.getTime())) return "";
+
+  return new Intl.DateTimeFormat("en-US", {
+    weekday: "short",
+    timeZone: timeZone,
+  }).format(date);
+};
+
+/**
+ * @deprecated Use getDateParts from datetime.js instead
+ */
+export const getMonth = (dateString, timeZone = "UTC") => {
+  if (!dateString) return "";
+
+  const date = new Date(dateString);
+  if (isNaN(date.getTime())) return "";
+
+  return new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    timeZone: timeZone,
+  }).format(date);
+};
+
+/**
+ * @deprecated Use getDateParts from datetime.js instead
+ */
+export const getDateOfMonth = (dateString, timeZone = "UTC") => {
+  if (!dateString) return "";
+
+  const date = new Date(dateString);
+  if (isNaN(date.getTime())) return "";
+
+  return new Intl.DateTimeFormat("en-US", {
+    day: "numeric",
+    timeZone: timeZone,
+  }).format(date);
+};
+
+export function resize(node, callback) {
+  const updateDimensions = () => {
+    callback({
+      width: window.innerWidth,
+      height: window.innerHeight,
+    });
+  };
+
+  updateDimensions();
+  window.addEventListener("resize", updateDimensions);
+
+  return {
+    destroy() {
+      window.removeEventListener("resize", updateDimensions);
+    },
+  };
+}
+
+export function convertToCustomDateFormat(isoString) {
+  const date = new Date(isoString);
+
+  const year = date.getUTCFullYear();
+  const month = date.getUTCMonth();
+  const day = date.getUTCDate();
+
+  const customDate = new Date(year, month, day);
+
+  return customDate;
+}
+
+export function validateNegativeNumber(value) {
+  if (value === null || value === undefined || value === "") {
+    return "Must be greater than zero.";
+  }
+
+  const stringValue = String(value).trim();
+
+  if (
+    stringValue.includes("--") ||
+    stringValue.includes("++") ||
+    stringValue.match(/^-+$/) ||
+    stringValue.match(/^\++$/)
+  ) {
+    return "Please enter a valid number";
+  }
+
+  if (stringValue.match(/^-?\d+-$/)) {
+    return "Please enter a valid number";
+  }
+
+  if ((stringValue.match(/\./g) || []).length > 1) {
+    return "Please enter a valid number";
+  }
+
+  const numValue = Number(value);
+  if (isNaN(numValue)) {
+    return "Please enter a valid number";
+  }
+
+  if (numValue < 0 || numValue === 0) {
+    return "Price must be greater than zero.";
+  }
+
+  return "";
+}
+/**
+ * @deprecated Use formatEventDateTime and formatEventTime from datetime.js instead
+ */
+export function formatDateTimeWithDoors(startDateTime, doorsOpenTime, timeZone = "UTC") {
+  if (!startDateTime) return "";
+
+  const date = new Date(startDateTime);
+  const options = {
+    weekday: "short",
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZone: timeZone,
+  };
+
+  const formattedDateTime = new Intl.DateTimeFormat("en-US", options).format(
+    date
+  );
+  if (doorsOpenTime) {
+    const doorsDate = new Date(doorsOpenTime);
+    const doorsFormatted = new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true,
+      timeZone: timeZone,
+    }).format(doorsDate);
+
+    return `${formattedDateTime} (Doors: ${doorsFormatted})`;
+  }
+
+  return formattedDateTime;
+}
+
+export async function getClientIP() {
+  try {
+    const res = await fetch("https://api.ipify.org?format=json");
+    const { ip } = await res.json();
+    return ip;
+  } catch (err) {
+    console.error("Failed to fetch IP:", err);
+    return null;
+  }
+}
+
+/**
+ * Generate a URL-friendly slug from a string
+ * @param {string} text - The text to slugify
+ * @returns {string} - A URL-safe slug
+ */
+export function generateSlug(text) {
+  if (!text) return "";
+
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/\s+/g, "-")
+    .replace(/--+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+// calculateTicketStatus - now re-exported from event-transform.js at top of file
+
+// findLowestPrice - now re-exported from event-transform.js at top of file
+
+export function getImageUrl(
+  imagePath,
+  baseUrl = "https://moxy.sfo3.cdn.digitaloceanspaces.com"
+) {
+  if (!imagePath) return "";
+
+  if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+    return imagePath;
+  }
+
+  return `${baseUrl}${imagePath}`;
+}
+
+/**
+ * Get the display avatar path for a performer based on their profileImageSource setting.
+ * This mirrors the backend logic in auth/utils/avatar.go
+ * @param {Object} profile - The performer profile object
+ * @returns {string} - The avatar path (relative or absolute URL)
+ */
+export function getDisplayAvatarPath(profile) {
+  if (!profile) return "";
+
+  const source = profile.profileImageSource || "1";
+
+  // Map source number to the corresponding avatar field
+  switch (source) {
+    case "1":
+      return profile.avatarPosition1 || profile.profileImage || "";
+    case "2":
+      return profile.avatarPosition2 || "";
+    case "3":
+      return profile.avatarPosition3 || "";
+    case "4":
+      return profile.avatarPosition4 || "";
+    case "5":
+      return profile.avatarPosition5 || "";
+    case "6":
+      return profile.avatarPosition6 || "";
+    default:
+      // Fallback to position 1 or profileImage
+      return profile.avatarPosition1 || profile.profileImage || "";
+  }
+}
+
+/**
+ * Get the full display avatar URL for a performer.
+ * Combines getDisplayAvatarPath with CDN URL resolution.
+ * @param {Object} profile - The performer profile object
+ * @param {string} baseUrl - CDN base URL (default: DigitalOcean Spaces)
+ * @returns {string} - The full avatar URL
+ */
+export function getDisplayAvatarUrl(profile, baseUrl = "https://moxy.sfo3.cdn.digitaloceanspaces.com") {
+  const path = getDisplayAvatarPath(profile);
+  if (!path) return "";
+  return getImageUrl(path, baseUrl);
+}
+
+/**
+ * Get the performer display name based on their profile settings.
+ * This mirrors the backend logic in auth/utils/avatar.go
+ * @param {Object} profile - The performer profile object
+ * @returns {string} - The display name
+ */
+export function getPerformerDisplayName(profile) {
+  if (!profile) return "";
+
+  // If useStageName is set and stageName exists, use it
+  if (profile.useStageName && profile.stageName) {
+    return profile.stageName;
+  }
+
+  // Otherwise use first + last name
+  const firstName = profile.firstName || "";
+  const lastName = profile.lastName || "";
+  const fullName = `${firstName} ${lastName}`.trim();
+
+  // Fallback to stageName if no real name
+  return fullName || profile.stageName || "";
+}
+
+// transformEvent - now re-exported from event-transform.js at top of file
+
+
+
+export async function getVenueDetails(venueID) {
+  try {
+    const response = await fetch(
+      `https://get-micdrop.com/api/v2/public/venues/${venueID}`
+    );
+
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error("getVenueDetails error:", error);
+    throw error;
+  }
+}
+
+export function setCookie(name, value, options = {}) {
+  Cookies.set(name, value, options);
+}
+
+export function getCookie(name) {
+  return Cookies.get(name);
+}
+
+export function removeCookie(name) {
+  Cookies.remove(name);
+}
+
+/**
+ * Load checkout state from localStorage (preferred) with cookie fallback for migration
+ * @param {string} eventID - The event ID
+ * @returns {Object} - Checkout state with quantities, promocode, promoDiscountAmount, tickets
+ */
+export function loadCheckoutStateFromCookies(eventID) {
+  let quantities = {};
+  let donationAmounts = {};
+  let tickets = [];
+  let promocode = "";
+  let promoDiscountAmount = 0;
+
+  if (typeof window === 'undefined') {
+    return { quantities, donationAmounts, promocode, promoDiscountAmount, tickets };
+  }
+
+  // Try localStorage first (new approach)
+  try {
+    const stored = localStorage.getItem(`checkout-state-${eventID}`);
+    if (stored) {
+      const parsed = JSON.parse(stored);
+      return {
+        quantities: parsed.quantities || {},
+        donationAmounts: parsed.donationAmounts || {},
+        promocode: parsed.promocode || "",
+        promoDiscountAmount: parseFloat(parsed.promoDiscountAmount) || 0,
+        tickets: parsed.tickets || [],
+      };
+    }
+  } catch (e) {
+    console.warn("Failed to parse checkout state from localStorage:", e);
+  }
+
+  // Fallback to cookies for migration (old approach)
+  try {
+    quantities = JSON.parse(getCookie(`checkout-quantities-${eventID}`) || "{}");
+  } catch (e) {
+    console.warn("Failed to parse checkout quantities cookie:", e);
+    quantities = {};
+  }
+
+  try {
+    tickets = JSON.parse(getCookie(`checkout-tickets-${eventID}`) || "[]");
+  } catch (e) {
+    console.warn("Failed to parse checkout tickets cookie:", e);
+    tickets = [];
+  }
+
+  promocode = getCookie(`checkout-promocode-${eventID}`) || "";
+  promoDiscountAmount = parseFloat(getCookie("checkout-promo-discount") || 0);
+
+  // If we found data in cookies, migrate it to localStorage and clear cookies
+  if (Object.keys(quantities).length > 0 || tickets.length > 0 || promocode) {
+    persistCheckoutState({ eventID, quantities, donationAmounts, promocode, promoDiscountAmount, tickets });
+    clearCheckoutCookies(eventID);
+  }
+
+  return { quantities, donationAmounts, promocode, promoDiscountAmount, tickets };
+}
+
+/**
+ * Clear checkout state from both localStorage and cookies
+ * @param {string} eventID - The event ID
+ */
+export function clearCheckoutCookies(eventID) {
+  // Clear localStorage (new approach)
+  if (typeof window !== 'undefined') {
+    localStorage.removeItem(`checkout-state-${eventID}`);
+  }
+
+  // Clear cookies (for migration cleanup)
+  removeCookie(`checkout-quantities-${eventID}`);
+  removeCookie(`checkout-promocode-${eventID}`);
+  removeCookie(`checkout-promo-discount`);
+  removeCookie(`checkout-tickets-${eventID}`);
+}
+
+/**
+ * Persist checkout state to localStorage
+ * Uses localStorage instead of cookies to avoid size limits and reduce request overhead
+ * @param {Object} params - Checkout state parameters
+ * @param {string} params.eventID - The event ID
+ * @param {Object} params.quantities - Ticket quantities by ID
+ * @param {string} params.promocode - Applied promo code
+ * @param {number} params.promoDiscountAmount - Discount amount
+ * @param {Array} params.tickets - Selected tickets (minimal data only)
+ */
+export function persistCheckoutState({
+  eventID,
+  quantities,
+  donationAmounts,
+  promocode,
+  promoDiscountAmount,
+  tickets,
+}) {
+  if (typeof window === 'undefined') return;
+
+  // Store minimal ticket data to avoid storage bloat
+  const minimalTickets = (tickets || []).map(t => ({
+    ID: t.ID,
+    name: t.name,
+    price: t.price,
+    type: t.type, // Include type for donation ticket detection
+    visibility: t.visibility,
+    salesChannel: t.salesChannel,
+  }));
+
+  const state = {
+    quantities: quantities || {},
+    donationAmounts: donationAmounts || {},
+    promocode: promocode || "",
+    promoDiscountAmount: promoDiscountAmount || 0,
+    tickets: minimalTickets,
+    updatedAt: Date.now(),
+  };
+
+  try {
+    localStorage.setItem(`checkout-state-${eventID}`, JSON.stringify(state));
+  } catch (e) {
+    console.warn("Failed to persist checkout state to localStorage:", e);
+  }
+}
+
+/**
+ * Ensure order ID exists, create if not
+ * @param {string} eventId - The event ID
+ * @returns {Promise<string>} - Order ID
+ */
+export async function ensureOrderIdExists(eventId) {
+  const existingOrderId = getCookie(`order-id-${eventId}`);
+
+  if (existingOrderId) {
+    return existingOrderId;
+  }
+
+  const newOrderId = `order-${eventId}-${Date.now()}`;
+  setCookie(`order-id-${eventId}`, newOrderId);
+
+  return newOrderId;
+}
+
+// Note: Parameter is named venueID for backwards compatibility but actually represents eventID
+export async function trackUTMSource(venueID) {
+  const urlParams = new URLSearchParams(window.location.search);
+  const utmSource = urlParams.get("utm_source") || "Direct";
+
+  try {
+    await fetch(
+      `https://get-micdrop.com/api/v2/public/utm/${venueID}/${utmSource}`
+    );
+  } catch (err) {
+    console.error("UTM tracking failed:", err);
+  }
+}
+
+export async function initiateOrder(cartData = {}) {
+  try {
+    const ip = await getClientIP();
+
+    // Note: donationAmounts is not yet supported by backend API
+    // TODO: Remove this filter once Gus adds backend support for donationAmounts
+    const { donationAmounts, eventID, quantities, ...restCartData } = cartData;
+
+    // Convert quantities keys to numbers and eventID to number (API expects numeric types)
+    const numericQuantities = quantities ? Object.fromEntries(
+      Object.entries(quantities).map(([k, v]) => [parseInt(k, 10), v])
+    ) : {};
+
+    const orderPayload = {
+      purchaserIP: ip,
+      eventID: eventID ? parseInt(eventID, 10) : undefined,
+      quantities: numericQuantities,
+      ...restCartData,
+    };
+
+    const res = await fetch(`https://get-micdrop.com/api/v2/public/orders/create`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(orderPayload),
+    });
+
+    const data = await res.json();
+
+    // Check for API errors
+    if (!res.ok || data.error) {
+      const errorMessage = data.error || data.message || 'Order creation failed';
+      // Check for inventory-related errors
+      const isInventoryError = errorMessage.toLowerCase().includes('inventory') ||
+                               errorMessage.toLowerCase().includes('sold out') ||
+                               errorMessage.toLowerCase().includes('not available') ||
+                               errorMessage.toLowerCase().includes('insufficient') ||
+                               res.status === 409; // Conflict status often used for inventory issues
+
+      return {
+        success: false,
+        error: errorMessage,
+        errorType: isInventoryError ? 'inventory' : 'server'
+      };
+    }
+
+    setCookie("checkout-cartid", data.uuid);
+    return { success: true, uuid: data.uuid };
+  } catch (err) {
+    console.error("Order initiation failed:", err);
+    return {
+      success: false,
+      error: err.message || 'Network error',
+      errorType: 'network'
+    };
+  }
+}
+
+export async function getOrder(orderId) {
+  try {
+    const response = await fetch(
+      `https://get-micdrop.com/api/v2/public/orders/${orderId}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      const errorMessage =
+        errorData.error || `Failed to fetch order (${response.status})`;
+      console.error("getOrder error response:", errorData);
+      throw new Error(errorMessage);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (err) {
+    console.error("getOrder error:", err);
+    throw err;
+  }
+}
+
+export async function createPaymentIntent(cartId, quantities) {
+  let ip = '';
+  try {
+    const ipRes = await fetch('https://api.ipify.org?format=json', {
+      signal: AbortSignal.timeout(5000) // 5 second timeout
+    });
+    if (ipRes.ok) {
+      const ipData = await ipRes.json();
+      ip = ipData.ip || '';
+    }
+  } catch (ipErr) {
+    console.warn('Failed to fetch IP address, continuing without it:', ipErr);
+    // Continue without IP if the service is unavailable
+  }
+
+  const token = getCookie('operator_token');
+
+  // Create an AbortController for timeout
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
+
+  try {
+    const res = await fetch(
+      `https://get-micdrop.com/api/v2/public/orders/${cartId}/payment-intent`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: token ? `Bearer ${token}` : '',
+        },
+        credentials: 'include',
+        signal: controller.signal,
+        body: JSON.stringify({
+          IP: ip,
+          productQuantities: quantities,
+        }),
+      }
+    );
+
+    clearTimeout(timeoutId);
+
+    if (!res.ok) {
+      const errorData = await res.json().catch(() => ({}));
+      console.error('Payment intent creation failed:', errorData);
+      throw new Error(errorData.error || `Failed to create payment intent: ${res.status} ${res.statusText}`);
+    }
+
+    const data = await res.json();
+    return data;
+  } catch (err) {
+    clearTimeout(timeoutId);
+    
+    // Provide more specific error messages
+    if (err.name === 'AbortError') {
+      console.error('createPaymentIntent error: Request timeout');
+      throw new Error('Request timed out. Please check your connection and try again.');
+    } else if (err.message && err.message.includes('Failed to fetch')) {
+      console.error('createPaymentIntent error: Network/CORS issue', err);
+      throw new Error('Unable to connect to payment server. Please check your internet connection or try again later.');
+    } else {
+      console.error('createPaymentIntent error:', err);
+      // Re-throw the error so the caller can handle it
+      throw err;
+    }
+  }
+}
+
+export async function validatePaymentIntent(cartId, payload) {
+  try {
+    const token = getCookie('operator_token');
+
+    const res = await fetch(`https://get-micdrop.com/api/v2/public/orders/${cartId}/validate-payment`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: token ? `Bearer ${token}` : '',
+      },
+      credentials: 'include',
+      body: JSON.stringify(payload),
+    });
+
+    const data = await res.json();
+    return data;
+  } catch (err) {
+    console.error('validatePaymentIntent error:', err);
+    return null;
+  }
+}