arky-sdk 0.1.0 → 0.1.2

package/dist/utils.js

@@ -0,0 +1,680 @@
+// src/config.ts
+
+// src/utils/blocks.ts
+function getBlockLabel(block, locale = "en") {
+  if (!block) return "";
+  if (block.properties?.label) {
+    if (typeof block.properties.label === "object") {
+      return block.properties.label[locale] || block.properties.label.en || Object.values(block.properties.label)[0] || "";
+    }
+    if (typeof block.properties.label === "string") {
+      return block.properties.label;
+    }
+  }
+  return block.key?.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()) || "";
+}
+function formatBlockValue(block) {
+  if (!block || block.value === null || block.value === void 0) {
+    return "";
+  }
+  switch (block.type) {
+    case "BOOLEAN":
+      return block.value ? "Yes" : "No";
+    case "NUMBER":
+      if (block.properties?.variant === "DATE" || block.properties?.variant === "DATE_TIME") {
+        try {
+          return new Date(block.value).toLocaleDateString();
+        } catch (e) {
+          return String(block.value);
+        }
+      }
+      return String(block.value);
+    case "RELATIONSHIP":
+      if (Array.isArray(block.value) && block.value.length > 0) {
+        const firstValue = block.value[0];
+        if (firstValue && firstValue.mimeType) {
+          return firstValue.name || firstValue.id || "Media";
+        }
+        return firstValue.title || firstValue.name || firstValue.id || "Entry";
+      }
+      return String(block.value);
+    default:
+      return String(block.value);
+  }
+}
+function prepareBlocksForSubmission(formData) {
+  const preparedBlocks = [];
+  Object.keys(formData).forEach((key) => {
+    if (formData[key] !== null && formData[key] !== void 0) {
+      preparedBlocks.push({
+        key,
+        value: [formData[key]]
+      });
+    }
+  });
+  return preparedBlocks;
+}
+function extractBlockValues(blocks) {
+  const values = {};
+  blocks.forEach((block) => {
+    if (block.value && block.value.length > 0) {
+      values[block.key] = block.value[0];
+    } else {
+      values[block.key] = null;
+    }
+  });
+  return values;
+}
+function getBlockTextValue(block, locale = "en") {
+  if (!block || !block.value || block.value.length === 0) return "";
+  const firstValue = block.value[0];
+  if (typeof firstValue === "object" && firstValue !== null) {
+    if (firstValue[locale]) return firstValue[locale];
+    if (firstValue.en) return firstValue.en;
+    const values = Object.values(firstValue);
+    return String(values[0] || "");
+  }
+  return String(firstValue);
+}
+var getBlockValue = (entry, blockKey) => {
+  if (!entry || !entry.blocks) return null;
+  const block = entry.blocks.find((f) => f.key === blockKey);
+  if (!block || !block.value || block.value.length === 0) return null;
+  return block.value[0];
+};
+var getBlockValues = (entry, blockKey) => {
+  if (!entry || !entry.blocks) return null;
+  const block = entry.blocks.find((f) => f.key === blockKey);
+  if (!block || !block.value || block.value.length === 0) return null;
+  return block.value;
+};
+function unwrapBlock(block, locale) {
+  if (!block?.type || block.value === void 0) return block;
+  if (block.type === "BLOCK") {
+    return block.value.map((obj) => {
+      const parsed = {};
+      for (const [k, v] of Object.entries(obj)) {
+        parsed[k] = unwrapBlock(v, locale);
+      }
+      return parsed;
+    });
+  }
+  const isLocalized = block.type === "TEXT";
+  const isList = block.properties?.ui === "list" || (block.properties?.maxValues ?? 1) > 1 || block.value.length > 1;
+  if (isList) {
+    return isLocalized ? block.value.map((v) => v[locale] || v["en"]) : [...block.value];
+  }
+  return isLocalized ? block.value[0][locale] || block.value[0]["en"] : block.value[0];
+}
+var getBlockObjectValues = (entry, blockKey, locale = "en") => {
+  if (!entry) {
+    return [];
+  }
+  const values = getBlockValues(entry, blockKey);
+  const parsed = values.map((obj) => {
+    const res = obj.value.reduce((acc, current) => {
+      acc[current.key] = unwrapBlock(current, locale);
+      return acc;
+    }, {});
+    return res;
+  });
+  return parsed;
+};
+var getBlockFromArray = (entry, blockKey, locale = "en") => {
+  if (!entry) {
+    return [];
+  }
+  const values = getBlockValues(entry, blockKey);
+  return values.reduce((acc, current) => {
+    acc[current.key] = unwrapBlock(current, locale);
+    return acc;
+  });
+};
+var getImageUrl = (imageBlock, isBlock = true) => {
+  if (!imageBlock) return null;
+  const storageUrl = "https://storage.arky.io/dev";
+  const isExternalUrl = (url) => {
+    return url.startsWith("http://") || url.startsWith("https://");
+  };
+  if (imageBlock.type === "RELATIONSHIP" && Array.isArray(imageBlock.value)) {
+    const mediaValue = imageBlock.value[0];
+    if (mediaValue && mediaValue.mimeType) {
+      if (mediaValue.resolutions && mediaValue.resolutions.original && mediaValue.resolutions.original.url) {
+        const url = mediaValue.resolutions.original.url;
+        return isExternalUrl(url) ? url : `${storageUrl}/${url}`;
+      }
+      if (mediaValue.url) {
+        return isExternalUrl(mediaValue.url) ? mediaValue.url : `${storageUrl}/${mediaValue.url}`;
+      }
+    }
+    return null;
+  }
+  if (isBlock) {
+    if (typeof imageBlock === "string") {
+      if (isExternalUrl(imageBlock)) {
+        return imageBlock;
+      }
+      return `${storageUrl}/${imageBlock}`;
+    }
+    if (imageBlock.url) {
+      if (isExternalUrl(imageBlock.url)) {
+        return imageBlock.url;
+      }
+      return `${storageUrl}/${imageBlock.url}`;
+    }
+  }
+  if (imageBlock.resolutions && imageBlock.resolutions.original && imageBlock.resolutions.original.url) {
+    const url = imageBlock.resolutions.original.url;
+    if (isExternalUrl(url)) {
+      return url;
+    }
+    return `${storageUrl}/${url}`;
+  }
+  return null;
+};
+function getGalleryThumbnail(gallery) {
+  if (!gallery?.length) return null;
+  const item = gallery.find((g) => g.settings.isThumbnail) || gallery[0];
+  const res = item.media.resolutions.thumbnail || item.media.resolutions.original;
+  return res?.url || null;
+}
+function thumbnailUrl(service) {
+  const storageUrl = "";
+  const path = getGalleryThumbnail(service.gallery);
+  return path ? `${storageUrl}/${path}` : null;
+}
+var translateMap = (labels, lang, fallback = "unknown") => {
+  let parsedLang = "en";
+  if (lang === "sr") {
+    parsedLang = "bih";
+  }
+  if (!labels) {
+    return fallback;
+  }
+  const label = labels[parsedLang];
+  if (!label) {
+    return fallback;
+  }
+  return label;
+};
+
+// src/utils/errors.ts
+var ERROR_CODES = {
+  // General errors
+  "GENERAL.001": "GENERAL.BAD_REQUEST",
+  "GENERAL.002": "GENERAL.VALIDATION_ERROR",
+  "GENERAL.003": "GENERAL.FORBIDDEN_ERROR",
+  "GENERAL.004": "GENERAL.INTERNAL_SERVER_ERROR",
+  "GENERAL.005": "GENERAL.UNAUTHORIZED",
+  "GENERAL.006": "GENERAL.UNAUTHENTICATED",
+  // Google/OAuth errors
+  "GOOGLE.001": "GOOGLE.INVALID_ORIGIN_URI",
+  "GOOGLE.002": "GOOGLE.INVALID_REDIRECT_URI",
+  "GOOGLE.003": "GOOGLE.FAILED_TO_CALL_API",
+  "GOOGLE.004": "GOOGLE.FAILED_LOGIN",
+  "GOOGLE.005": "GOOGLE.FAILED_LOGOUT",
+  "GOOGLE.006": "GOOGLE.FAILED_REFRESH_TOKEN",
+  "GOOGLE.007": "GOOGLE.INVALID_PROVIDER_PASSED",
+  // User errors
+  "USER.001": "USER.NOT_FOUND",
+  "USER.002": "USER.FAILED_TO_CREATE",
+  "USER.003": "USER.FAILED_TO_UPDATE",
+  "USER.004": "USER.FAILED_TO_DELETE",
+  "USER.005": "USER.EMAIL_EXISTS",
+  "USER.006": "USER.FAILED_TO_GET_UPLOAD_URL",
+  // Business errors
+  "BUSINESS.001": "BUSINESS.NOT_FOUND",
+  "BUSINESS.002": "BUSINESS.FAILED_TO_CREATE",
+  "BUSINESS.003": "BUSINESS.FAILED_TO_UPDATE",
+  "BUSINESS.004": "BUSINESS.FAILED_TO_DELETE",
+  "BUSINESS.005": "BUSINESS.FAILED_TO_GET_UPLOAD_URL",
+  "BUSINESS.006": "BUSINESS.NAME_REQUIRED",
+  "BUSINESS.007": "BUSINESS.BUSINESS_ID_REQUIRED",
+  "BUSINESS.010": "BUSINESS.DESCRIPTION_REQUIRED",
+  "BUSINESS.011": "BUSINESS.SLUG_INVALID",
+  // Provider errors  
+  "PROVIDER.001": "PROVIDER.NOT_FOUND",
+  "PROVIDER.002": "PROVIDER.FAILED_TO_CREATE",
+  "PROVIDER.003": "PROVIDER.FAILED_TO_UPDATE",
+  "PROVIDER.004": "PROVIDER.FAILED_TO_DELETE",
+  "PROVIDER.005": "PROVIDER.FAILED_TO_GET_UPLOAD_URL",
+  "PROVIDER.006": "PROVIDER.NAME_REQUIRED",
+  "PROVIDER.007": "PROVIDER.BUSINESS_ID_REQUIRED",
+  "PROVIDER.008": "PROVIDER.DESCRIPTION_REQUIRED"
+};
+var ERROR_CONSTANTS = {
+  GENERAL: {
+    BAD_REQUEST: "GENERAL.BAD_REQUEST",
+    VALIDATION_ERROR: "GENERAL.VALIDATION_ERROR",
+    FORBIDDEN_ERROR: "GENERAL.FORBIDDEN_ERROR",
+    INTERNAL_SERVER_ERROR: "GENERAL.INTERNAL_SERVER_ERROR",
+    UNAUTHORIZED: "GENERAL.UNAUTHORIZED",
+    UNAUTHENTICATED: "GENERAL.UNAUTHENTICATED"
+  },
+  USER: {
+    NOT_FOUND: "USER.NOT_FOUND",
+    FAILED_TO_CREATE: "USER.FAILED_TO_CREATE",
+    FAILED_TO_UPDATE: "USER.FAILED_TO_UPDATE",
+    FAILED_TO_DELETE: "USER.FAILED_TO_DELETE",
+    EMAIL_EXISTS: "USER.EMAIL_EXISTS",
+    FAILED_TO_GET_UPLOAD_URL: "USER.FAILED_TO_GET_UPLOAD_URL"
+  },
+  BUSINESS: {
+    NOT_FOUND: "BUSINESS.NOT_FOUND",
+    FAILED_TO_CREATE: "BUSINESS.FAILED_TO_CREATE",
+    FAILED_TO_UPDATE: "BUSINESS.FAILED_TO_UPDATE",
+    FAILED_TO_DELETE: "BUSINESS.FAILED_TO_DELETE",
+    FAILED_TO_GET_UPLOAD_URL: "BUSINESS.FAILED_TO_GET_UPLOAD_URL",
+    NAME_REQUIRED: "BUSINESS.NAME_REQUIRED",
+    BUSINESS_ID_REQUIRED: "BUSINESS.BUSINESS_ID_REQUIRED",
+    DESCRIPTION_REQUIRED: "BUSINESS.DESCRIPTION_REQUIRED",
+    SLUG_INVALID: "BUSINESS.SLUG_INVALID"
+  }
+};
+function getErrorMessage(code) {
+  return ERROR_CODES[code] || code;
+}
+function isErrorCode(code) {
+  return code in ERROR_CODES;
+}
+var transformErrors = (zodError) => {
+  const customErrors = [];
+  if (!zodError.issues) return customErrors;
+  zodError.issues.forEach((issue) => {
+    const field = issue.path.join(".");
+    const message = issue.message;
+    if (!customErrors.some(
+      (customError) => customError.field === field && customError.message === message
+    )) {
+      customErrors.push({ field, message });
+    }
+  });
+  return customErrors;
+};
+var convertServerErrorToRequestError = (serverError, renameRules) => {
+  return {
+    ...serverError,
+    validationErrors: serverError.validationErrors.map((validationError) => {
+      const field = renameRules && renameRules[validationError.field] ? renameRules[validationError.field] : validationError.field;
+      return {
+        field,
+        message: ERROR_CODES[validationError.code] || "Unknown error"
+      };
+    })
+  };
+};
+var errors = ERROR_CONSTANTS;
+
+// src/utils/currency.ts
+function getCurrencySymbol(currency) {
+  const currencySymbols = {
+    USD: "$",
+    EUR: "\u20AC",
+    GBP: "\xA3",
+    CAD: "C$",
+    AUD: "A$",
+    JPY: "\xA5",
+    CHF: "CHF",
+    SEK: "kr",
+    NOK: "kr",
+    DKK: "kr",
+    PLN: "z\u0142",
+    CZK: "K\u010D",
+    HUF: "Ft",
+    RON: "lei",
+    BGN: "\u043B\u0432",
+    HRK: "kn",
+    RSD: "\u0434\u0438\u043D",
+    BAM: "KM",
+    MKD: "\u0434\u0435\u043D",
+    ALL: "L",
+    TRY: "\u20BA",
+    RUB: "\u20BD",
+    UAH: "\u20B4",
+    BYN: "Br",
+    CNY: "\xA5",
+    INR: "\u20B9",
+    KRW: "\u20A9",
+    THB: "\u0E3F",
+    VND: "\u20AB",
+    SGD: "S$",
+    MYR: "RM",
+    IDR: "Rp",
+    PHP: "\u20B1",
+    BRL: "R$",
+    ARS: "$",
+    CLP: "$",
+    COP: "$",
+    PEN: "S/",
+    MXN: "$",
+    ZAR: "R",
+    EGP: "E\xA3",
+    NGN: "\u20A6",
+    KES: "KSh",
+    GHS: "\u20B5",
+    MAD: "DH",
+    TND: "\u062F.\u062A",
+    DZD: "\u062F.\u062C",
+    LYD: "\u0644.\u062F",
+    AED: "\u062F.\u0625",
+    SAR: "\u0631.\u0633",
+    QAR: "\u0631.\u0642",
+    KWD: "\u062F.\u0643",
+    BHD: "\u0628.\u062F",
+    OMR: "\u0631.\u0639",
+    JOD: "\u062F.\u0623",
+    LBP: "\u0644.\u0644",
+    SYP: "\u0644.\u0633",
+    IQD: "\u0639.\u062F",
+    IRR: "\uFDFC",
+    AFN: "\u060B",
+    PKR: "\u20A8",
+    LKR: "\u20A8",
+    NPR: "\u20A8",
+    BDT: "\u09F3",
+    MMK: "K",
+    LAK: "\u20AD",
+    KHR: "\u17DB",
+    MNT: "\u20AE",
+    KZT: "\u20B8",
+    UZS: "\u043B\u0432",
+    KGS: "\u043B\u0432",
+    TJS: "SM",
+    TMT: "T",
+    AZN: "\u20BC",
+    GEL: "\u20BE",
+    AMD: "\u058F",
+    BYR: "p.",
+    MDL: "L"
+  };
+  return currencySymbols[currency.toUpperCase()] || currency;
+}
+
+// src/utils/price.ts
+var CURRENCY_SYMBOLS = {
+  "USD": "$",
+  "EUR": "\u20AC",
+  "GBP": "\xA3",
+  "CAD": "C$",
+  "AUD": "A$"
+};
+var MARKET_CURRENCIES = {
+  "US": "USD",
+  "EU": "EUR",
+  "UK": "GBP",
+  "CA": "CAD",
+  "AU": "AUD"
+};
+function convertToMajor(minorAmount) {
+  return (minorAmount ?? 0) / 100;
+}
+function convertToMinor(majorAmount) {
+  return Math.round((majorAmount ?? 0) * 100);
+}
+function getSymbol(currency) {
+  return CURRENCY_SYMBOLS[currency] || "$";
+}
+function getCurrencyFromMarket(marketId) {
+  return MARKET_CURRENCIES[marketId] || "USD";
+}
+function formatCurrencyAmount(amount, currency, options = {}) {
+  const { showSymbols = true, decimalPlaces = 2, customSymbol } = options;
+  const roundedAmount = amount.toFixed(decimalPlaces);
+  if (!showSymbols) {
+    return `${roundedAmount} ${currency}`;
+  }
+  const symbol = customSymbol || getSymbol(currency);
+  return `${symbol}${roundedAmount}`;
+}
+function formatMinor(amountMinor, currency, options = {}) {
+  const major = convertToMajor(amountMinor);
+  return formatCurrencyAmount(major, currency, options);
+}
+function formatPayment(payment, options = {}) {
+  if (!payment) return "";
+  const { showSymbols = true, decimalPlaces = 2, showBreakdown = false } = options;
+  if (showBreakdown) {
+    const subtotal = formatMinor(payment.subtotal, payment.currency, { showSymbols, decimalPlaces });
+    const discount = (payment.discount ?? 0) > 0 ? formatMinor(payment.discount, payment.currency, { showSymbols, decimalPlaces }) : null;
+    const tax = (payment.tax ?? 0) > 0 ? formatMinor(payment.tax, payment.currency, { showSymbols, decimalPlaces }) : null;
+    const total = formatMinor(payment.total, payment.currency, { showSymbols, decimalPlaces });
+    let result = `Subtotal: ${subtotal}`;
+    if (discount) result += `, Discount: -${discount}`;
+    if (tax) result += `, Tax: ${tax}`;
+    result += `, Total: ${total}`;
+    return result;
+  }
+  return formatMinor(payment.total, payment.currency, { showSymbols, decimalPlaces });
+}
+function getMarketPrice(prices, marketId, businessMarkets, options = {}) {
+  if (!prices || prices.length === 0) return "";
+  const {
+    showSymbols = true,
+    decimalPlaces = 2,
+    showCompareAt = true,
+    fallbackMarket = "US"
+  } = options;
+  let price = prices.find((p) => p.market === marketId);
+  if (!price) {
+    price = prices.find((p) => p.market === fallbackMarket) || prices[0];
+  }
+  if (!price) return "";
+  let currency;
+  let symbol;
+  if (businessMarkets) {
+    const marketData = businessMarkets.find((m) => m.id === price.market || m.code === price.market);
+    if (marketData?.currency) {
+      currency = marketData.currency;
+      symbol = getCurrencySymbol(currency);
+    } else {
+      currency = getCurrencyFromMarket(price.market);
+      symbol = getSymbol(currency);
+    }
+  } else {
+    currency = getCurrencyFromMarket(price.market);
+    symbol = getSymbol(currency);
+  }
+  const formattedPrice = formatMinor(price.amount ?? 0, currency, {
+    showSymbols,
+    decimalPlaces,
+    customSymbol: symbol
+  });
+  if (showCompareAt && price.compareAt && price.compareAt > (price.amount ?? 0)) {
+    const formattedCompareAt = formatMinor(price.compareAt, currency, {
+      showSymbols,
+      decimalPlaces,
+      customSymbol: symbol
+    });
+    return `${formattedPrice} was ${formattedCompareAt}`;
+  }
+  return formattedPrice;
+}
+function getPriceAmount(prices, marketId, fallbackMarket = "US") {
+  if (!prices || prices.length === 0) return 0;
+  const price = prices.find((p) => p.market === marketId) || prices.find((p) => p.market === fallbackMarket) || prices[0];
+  return price?.amount || 0;
+}
+function createPaymentForCheckout(subtotalMinor, marketId, currency, paymentMethod, options = {}) {
+  const { discount = 0, tax = 0, promoCodeId } = options;
+  const total = subtotalMinor - discount + tax;
+  return {
+    currency,
+    market: marketId,
+    subtotal: subtotalMinor,
+    shipping: 0,
+    discount,
+    tax,
+    total,
+    promoCodeId,
+    method: paymentMethod
+  };
+}
+
+// src/utils/svg.ts
+async function fetchSvgContent(mediaObject) {
+  if (!mediaObject) return null;
+  const svgUrl = getImageUrl(mediaObject, false);
+  try {
+    const response = await fetch(svgUrl);
+    if (!response.ok) {
+      console.error(`Failed to fetch SVG: ${response.status} ${response.statusText}`);
+      return null;
+    }
+    const svgContent = await response.text();
+    return svgContent;
+  } catch (error) {
+    console.error("Error fetching SVG:", error);
+    return null;
+  }
+}
+async function getSvgContentForAstro(mediaObject) {
+  try {
+    const svgContent = await fetchSvgContent(mediaObject);
+    return svgContent || "";
+  } catch (error) {
+    console.error("Error getting SVG content for Astro:", error);
+    return "";
+  }
+}
+async function injectSvgIntoElement(mediaObject, targetElement, className) {
+  if (!targetElement) return;
+  try {
+    const svgContent = await fetchSvgContent(mediaObject);
+    if (svgContent) {
+      targetElement.innerHTML = svgContent;
+      if (className) {
+        const svgElement = targetElement.querySelector("svg");
+        if (svgElement) {
+          svgElement.classList.add(...className.split(" "));
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error injecting SVG:", error);
+  }
+}
+
+// src/utils/text.ts
+var locales = ["en", "sr-latn"];
+var localeMap = {
+  "en": "en-US",
+  "sr-latn": "sr-RS"
+};
+function slugify(text) {
+  return text.toString().toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function humanize(text) {
+  const slugifiedText = slugify(text);
+  return slugifiedText.replace(/-/g, " ").replace(
+    // upper case first letter of every word, and lower case the rest
+    /\w\S*/g,
+    (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
+  );
+}
+function categorify(text) {
+  const slugifiedText = slugify(text);
+  return slugifiedText.replace(/-/g, " ").toUpperCase();
+}
+function formatDate(date, locale) {
+  let localeString = "en-US";
+  if (locales.includes(locale)) {
+    localeString = localeMap[locale];
+  }
+  return new Date(date).toLocaleDateString(localeString, {
+    timeZone: "UTC",
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+
+// src/utils/timezone.ts
+var tzGroups = [
+  {
+    label: "US",
+    zones: [
+      { label: "Eastern Time", value: "America/New_York" },
+      { label: "Central Time", value: "America/Chicago" },
+      { label: "Mountain Time", value: "America/Denver" },
+      { label: "Pacific Time", value: "America/Los_Angeles" }
+    ]
+  },
+  {
+    label: "Europe",
+    zones: [
+      { label: "London", value: "Europe/London" },
+      { label: "Paris", value: "Europe/Paris" },
+      { label: "Berlin", value: "Europe/Berlin" },
+      { label: "Rome", value: "Europe/Rome" }
+    ]
+  },
+  {
+    label: "Asia",
+    zones: [
+      { label: "Tokyo", value: "Asia/Tokyo" },
+      { label: "Shanghai", value: "Asia/Shanghai" },
+      { label: "Mumbai", value: "Asia/Kolkata" },
+      { label: "Dubai", value: "Asia/Dubai" }
+    ]
+  }
+];
+function findTimeZone(groups) {
+  try {
+    const detected = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    for (const group of groups) {
+      for (const zone of group.zones) {
+        if (zone.value === detected) {
+          return detected;
+        }
+      }
+    }
+    return "UTC";
+  } catch (e) {
+    return "UTC";
+  }
+}
+
+// src/utils/validation.ts
+function validatePhoneNumber(phone) {
+  if (!phone) {
+    return { isValid: false, error: "Phone number is required" };
+  }
+  const cleaned = phone.replace(/\D/g, "");
+  if (cleaned.length < 8) {
+    return { isValid: false, error: "Phone number is too short" };
+  }
+  if (cleaned.length > 15) {
+    return { isValid: false, error: "Phone number is too long" };
+  }
+  return { isValid: true };
+}
+function validateEmail(email) {
+  if (!email) {
+    return { isValid: false, error: "Email is required" };
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return { isValid: false, error: "Please enter a valid email address" };
+  }
+  return { isValid: true };
+}
+function validateVerificationCode(code) {
+  if (!code) {
+    return { isValid: false, error: "Verification code is required" };
+  }
+  const cleaned = code.replace(/\D/g, "");
+  if (cleaned.length !== 4) {
+    return { isValid: false, error: "Please enter a 4-digit verification code" };
+  }
+  return { isValid: true };
+}
+function validateRequired(value, fieldName = "This field") {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+  return { isValid: true };
+}
+
+export { ERROR_CODES, ERROR_CONSTANTS, categorify, convertServerErrorToRequestError, convertToMajor, convertToMinor, createPaymentForCheckout, errors, extractBlockValues, fetchSvgContent, findTimeZone, formatBlockValue, formatCurrencyAmount, formatDate, formatMinor, formatPayment, getBlockFromArray, getBlockLabel, getBlockObjectValues, getBlockTextValue, getBlockValue, getBlockValues, getCurrencyFromMarket, getCurrencySymbol, getErrorMessage, getGalleryThumbnail, getImageUrl, getMarketPrice, getPriceAmount, getSvgContentForAstro, getSymbol, humanize, injectSvgIntoElement, isErrorCode, prepareBlocksForSubmission, slugify, thumbnailUrl, transformErrors, translateMap, tzGroups, validateEmail, validatePhoneNumber, validateRequired, validateVerificationCode };
+//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=utils.js.map