@merchi/cart 1.4.4

package/src/utilities/currency.ts

@@ -0,0 +1,216 @@
+export const currencyMap: any =
+  {ALL: 'L',
+    AFN: '؋',
+    ARS: '$',
+    AWG: 'ƒ',
+    AUD: '$',
+    AZN: '₼',
+    BSD: '$',
+    BBD: '$',
+    BYR: 'p.',
+    BZD: 'BZ$',
+    BMD: '$',
+    BOB: 'Bs.',
+    BAM: 'KM',
+    BWP: 'P',
+    BGN: 'лв',
+    BRL: 'R$',
+    BND: '$',
+    KHR: '៛',
+    CAD: '$',
+    KYD: '$',
+    CLP: '$',
+    CNY: '¥',
+    COP: '$',
+    CRC: '₡',
+    HRK: 'kn',
+    CUP: '₱',
+    CZK: 'Kč',
+    DKK: 'kr',
+    DOP: 'RD$',
+    XCD: '$',
+    EGP: '£',
+    SVC: '$',
+    EEK: 'kr',
+    EUR: '€',
+    FKP: '£',
+    FJD: '$',
+    GHC: '₵',
+    GIP: '£',
+    GTQ: 'Q',
+    GGP: '£',
+    GYD: '$',
+    HNL: 'L',
+    HKD: '$',
+    HUF: 'Ft',
+    ISK: 'kr',
+    INR: '₹',
+    IDR: 'Rp',
+    IRR: '﷼',
+    IMP: '£',
+    ILS: '₪',
+    JMD: '`J$',
+    JPY: '¥',
+    JEP: '£',
+    KES: 'KSh',
+    KZT: 'лв',
+    KPW: '₩',
+    KRW: '₩',
+    KGS: 'лв',
+    LAK: '₭',
+    LVL: 'Ls',
+    LBP: '£',
+    LRD: '$',
+    LTL: 'Lt',
+    MKD: 'ден',
+    MYR: 'RM',
+    MUR: '₨',
+    MXN: '$',
+    MNT: '₮',
+    MZN: 'MT',
+    NAD: '$',
+    NPR: '₨',
+    ANG: 'ƒ',
+    NZD: '$',
+    NIO: 'C$',
+    NGN: '₦',
+    NOK: 'kr',
+    OMR: '﷼',
+    PKR: '₨',
+    PAB: 'B/.',
+    PYG: 'Gs',
+    PEN: 'S/.',
+    PHP: '₱',
+    PLN: 'zł',
+    QAR: '﷼',
+    RON: 'lei',
+    RUB: '₽',
+    RMB: '￥',
+    SHP: '£',
+    SAR: '﷼',
+    RSD: 'Дин.',
+    SCR: '₨',
+    SGD: '$',
+    SBD: '$',
+    SOS: 'S',
+    ZAR: 'R',
+    LKR: '₨',
+    SEK: 'kr',
+    CHF: 'CHF',
+    SRD: '$',
+    SYP: '£',
+    TZS: 'TSh',
+    TWD: 'NT$',
+    THB: '฿',
+    TTD: 'TT$',
+    TRY: '₺',
+    TRL: '₤',
+    TVD: '$',
+    UGX: 'USh',
+    UAH: '₴',
+    GBP: '£',
+    USD: '$',
+    UYU: '$U',
+    UZS: 'лв',
+    VEF: 'Bs',
+    VND: '₫',
+    YER: '﷼',
+    ZWD: 'Z$'};
+
+export function formatCurrency(amount: any, options: any) {
+  /*
+    *   Example usage:
+
+            formatCurrency(-222.123456, {currency: 'EGP',
+                                         showCodeIfNoSymbol: true,
+                                         financialNegative: true,
+                                         decimalPlaces: 3})
+
+            --> '(£222.123)'
+    */
+
+  let symbol;
+  let negative = false;
+  let result;
+  options = options || {};
+  options.currency = options.currency || 'AUD';
+  options.showCodeIfNoSymbol = options.showCodeIfNoSymbol || true;
+  options.symbolAfterAmount = options.symbolAfterAmount || false;
+  options.financialNegative = options.financialNegative || false;
+  options.codeAfterSymbol = options.codeAfterSymbol || false;
+  options.codeBeforeSymbol = options.codeBeforeSymbol || false;
+  options.spaceBetweenSymbol = options.spaceBetweenSymbol || false;
+  options.decimalPlaces = options.decimalPlaces || 2;
+  options.decimalSeperator = options.decimalSeperator || '.';
+  options.codeAfterAmount = options.codeAfterAmount || false;
+  if (amount < 0.0) {
+    negative = true;
+        amount *= -1.0; // eslint-disable-line
+  }
+  if (Object.prototype.hasOwnProperty.call(currencyMap, options.currency)) {
+    symbol = currencyMap[options.currency];
+    if (options.codeAfterSymbol) {
+      symbol += '(' + options.currency + ') ';
+    }
+    if (options.codeBeforeSymbol) {
+      symbol = `(${options.currency}) ${symbol}`;
+    }
+  } else if (options.showCodeIfNoSymbol) {
+    symbol = options.currency;
+  } else {
+    symbol = '';
+  }
+    amount = amount.toFixed(options.decimalPlaces);
+    amount = amount.replace('.', options.decimalSeperator);
+  if (options.symbolAfterAmount) {
+    result = amount;
+    if (options.spaceBetweenSymbol) {
+      result += ' ';
+    }
+    result += symbol;
+  } else {
+    result = symbol;
+    if (options.spaceBetweenSymbol) {
+      result += ' ';
+    }
+    result += amount;
+  }
+  if (negative) {
+    if (options.financialNegative) {
+      result = `(${result})`;
+    } else {
+      result = `-${result}`;
+    }
+  }
+  if (options.codeAfterAmount === true) {
+    result += ` (${options.currency})`;
+  }
+  return result;
+}
+
+function formatCountryTax(countryTax: any) {
+  const { taxName, taxPercent } = countryTax;
+  return taxPercent > 0 ? ` inc ${taxName} (${taxPercent}%)` : '';
+}
+
+export function calculateTotalWithTax(total: number, tax: any) {
+  let taxMultiplier = 1.0;
+  if (tax && tax.taxPercent() > 0) {
+    taxMultiplier += tax.taxPercent() / 100;
+    taxMultiplier = parseFloat(taxMultiplier.toFixed(2));
+  }
+  let grandTotal = total * taxMultiplier;
+  return parseFloat(grandTotal.toFixed(2));
+}
+
+export function cartItemCurrencyAndCost(cartItem: any) {
+  const { currency, totalCost, taxType } = cartItem;
+  const tax = taxType ? formatCountryTax(taxType) : '';
+  return`${currency} ${formatCurrency(totalCost, { currency, showCodeIfNoSymbol: false })} ${tax}`;
+}
+
+export function currencyTaxAndCost(currency: string, tax: any, theCost: number) {
+  const totalCost = calculateTotalWithTax(theCost, tax);
+  const _tax = tax ? formatCountryTax(tax) : '';
+  return `${currency} ${formatCurrency(totalCost, {currency, showCodeIfNoSymbol: false})} ${_tax}`;
+}

package/src/utilities/customForm.ts

@@ -0,0 +1,71 @@
+/**
+ * Helpers for loading a product's published custom form bundle in cart edit.
+ * Mirrors the product-embed loader: SRI script tag → window.MERCHI_PRODUCT_FORM_<id>.
+ */
+import type { ComponentType } from 'react';
+
+export interface FormBundleRef {
+  url: string;
+  integrity?: string;
+  globalName: string;
+}
+
+/** If the product has a published custom form with a compiled bundle, return
+ * the info needed to load it; otherwise null (caller falls back). */
+export function publishedFormBundle(product: any): FormBundleRef | null {
+  const form = product?.productForm;
+  if (!form || form.status !== 'published') return null;
+  const version = form.activeVersion;
+  if (!version || !version.compiledBundleUrl) return null;
+  return {
+    url: version.compiledBundleUrl,
+    integrity: version.bundleSha || undefined,
+    globalName: `MERCHI_PRODUCT_FORM_${form.id}`,
+  };
+}
+
+/** Dynamically load a compiled form bundle and resolve its default export. */
+export function loadFormBundle(
+  bundle: FormBundleRef,
+  opts: { timeoutMs?: number } = {},
+): Promise<ComponentType<any>> {
+  const { url, integrity, globalName } = bundle;
+  const timeoutMs = opts.timeoutMs || 15000;
+  const w = window as any;
+
+  const existing = w[globalName] && w[globalName].default;
+  if (existing) return Promise.resolve(existing);
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (fn: (arg: any) => void, arg: any) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn(arg);
+    };
+    const timer = setTimeout(
+      () => finish(reject, new Error(`form bundle ${globalName} timed out`)),
+      timeoutMs,
+    );
+
+    const script = document.createElement('script');
+    script.src = url;
+    if (integrity) script.integrity = integrity;
+    script.crossOrigin = 'anonymous';
+    script.async = true;
+    script.onload = () => {
+      const mod = w[globalName];
+      if (mod && mod.default) finish(resolve, mod.default);
+      else {
+        finish(
+          reject,
+          new Error(`form bundle ${globalName} did not register a default export`),
+        );
+      }
+    };
+    script.onerror = () =>
+      finish(reject, new Error(`failed to load form bundle ${globalName}`));
+    document.head.appendChild(script);
+  });
+}

package/src/utilities/helpers.ts

@@ -0,0 +1,213 @@
+import camelCase from 'lodash/camelCase';
+import snakeCase from 'lodash/snakeCase';
+
+interface JsonObject {
+  [key: string]: any;
+}
+
+enum TransformationType {
+  CAMEL = "camel",
+  UNDERSCORE = "underscore"
+}
+
+const functionDict: { [key in TransformationType]: (word: string) => string } = {
+  [TransformationType.CAMEL]: camelCase,
+  [TransformationType.UNDERSCORE]: snakeCase
+};
+
+function parseJsonKeyNames(jsonObject: any, standard: keyof typeof functionDict): any {
+  if (typeof jsonObject === 'object' && jsonObject !== null) {
+    if (Array.isArray(jsonObject)) {
+      for (let item of jsonObject) {
+        parseJsonKeyNames(item, standard);
+      }
+    } else {
+      const oldKeys = Object.keys(jsonObject);
+      for (let old of oldKeys) {
+        const newKey = functionDict[standard](old);
+        if (newKey !== old) {
+          jsonObject[newKey] = jsonObject[old];
+          delete jsonObject[old];
+          parseJsonKeyNames(jsonObject[newKey], standard);
+        } else {
+          parseJsonKeyNames(jsonObject[old], standard);
+        }
+      }
+    }
+  }
+  return jsonObject;
+}
+
+function parseJsonKeyCamel(jsonObject: any) {
+  return parseJsonKeyNames(jsonObject, TransformationType.CAMEL);
+}
+
+interface Counter {
+  value: number;
+}
+
+interface SerialiseOptions {
+  existing?: FormData;
+  excludeOld?: boolean;
+  _prefix?: string;
+}
+
+export function unpackRecursiveJsonIter(jsonObject: JsonObject, options?: SerialiseOptions, fileIndex?: Counter): FormData {
+  if (!options) options = {};
+  const result = options.existing || new FormData();
+  const prefix = options._prefix || '';
+
+  if (!fileIndex) fileIndex = { value: 0 };
+
+  const appendData = (name: string, value: any) => {
+    if (prefix) {
+      name = prefix + '-' + name;
+    }
+    if (value !== undefined && value !== null) {
+      result.set(name, value.toString());  // Convert to string since FormData accepts only strings or Blobs.
+    }
+  };
+
+  const processSingleEntityProperty = (key: string, value: any) => {
+    let innerPrefix = key + '-0';
+    if (prefix) {
+      innerPrefix = prefix + '-' + innerPrefix;
+    }
+    unpackRecursiveJsonIter(value, { existing: result, _prefix: innerPrefix }, fileIndex);
+    appendData(key + '-count', '1');
+  };
+
+  for (const key in jsonObject) {
+    if ([undefined, '', null].includes(jsonObject[key]) || key === 'rights') {
+      continue;
+    }
+
+    if (Array.isArray(jsonObject[key])) {
+      jsonObject[key].forEach((item: any, index: number) => {
+        if ((typeof item === "object" || Array.isArray(item)) && item !== null) {
+          const arrayPrefix = prefix ? `${prefix}-${key}-${index}` : `${key}-${index}`;
+          unpackRecursiveJsonIter(item, { existing: result, _prefix: arrayPrefix }, fileIndex);
+        } else {
+          appendData(`${key}-${index}`, item);
+        }
+      });
+      appendData(key + '-count', jsonObject[key].length.toString());
+    } else if (typeof jsonObject[key] === "object" && jsonObject[key] !== null) {
+      processSingleEntityProperty(key, jsonObject[key]);
+    } else {
+      appendData(key, jsonObject[key]);
+    }
+  }
+
+  return result;
+}
+
+export function encodeMerchiApiData(dataDict: { [key: string]: any }): { [key: string]: any } {
+  const dataJson = parseJsonKeyCamel(dataDict);
+  return unpackRecursiveJsonIter(dataJson);
+}
+
+const supportedNumbers: any = {
+  AU: 'Australia (+61)',
+  AE: 'United Arab Emirates (+971)',
+  BH: 'Bahrain (+973)',
+  CN: 'China (+86)',
+  DK: 'Denmark (+45)',
+  ES: 'Spain (+34)',
+  FR: 'France (+33)',
+  GB: 'United Kingdom (+44)',
+  HK: 'Hong Kong (+852)',
+  ID: 'Indonesia (+62)',
+  IN: 'India (+91)',
+  IT: 'Italy (+39)',
+  KR: 'South Korea (+82)',
+  NC: 'New Caledonia (+687)',
+  NZ: 'New Zealand (+64)',
+  OM: 'Oman (+968)',
+  PH: 'Philippines (+63)',
+  PT: 'Portugal (+351)',
+  QA: 'Qatar (+974)',
+  SE: 'Sweden (+46)',
+  SG: 'Singapore (+65)',
+  TH: 'Thailand (+66)',
+  US: 'United States (+1)',
+  ZA: 'South Africa (+27)',
+};
+
+export const phoneOptions = Object.keys(supportedNumbers).map((key) => ({
+  value: key,
+  label: supportedNumbers[key],
+}));
+
+export function appendStyleSheetText(css: string, callback?: () => void) {
+  if (document && document !== undefined) {
+    const newStyleSheet = document.createElement('style');
+    newStyleSheet.textContent = css;
+    if (callback) {
+      newStyleSheet.onload = callback;
+    }
+    document.head.appendChild(newStyleSheet);
+  }
+}
+
+const optionsEmbed: any = {
+  options: {
+    linkedFile: {},
+    variationCostDiscountGroup: {},
+    variationUnitCostDiscountGroup: {}},
+  variationCostDiscountGroup: {},
+  variationUnitCostDiscountGroup: {},
+};
+
+const variationsEmbed: any = {
+  selectedOptions: {},
+  variationField: optionsEmbed,
+  variationFiles: {}
+};
+
+const variationsGroupsEmbed: any = {variations: variationsEmbed};
+
+const productWithImagesEmbed: any = {
+  domain: {company: {defaultTaxType: {}, taxTypes: {}}},
+  featureImage: {},
+  groupVariationFields: {options: {linkedFile: {}}},
+  images: {},
+  independentVariationFields: {options: {linkedFile: {}}},
+  // Published custom form pointer for cart-item edit (same shape as product embed).
+  productForm: {activeVersion: {}},
+  taxType: {},
+};
+
+const cartShipmentQuote: any = {
+  shipmentMethod: {originAddress: {}, taxType: {}},
+};
+
+export const cartEmbed: any = {
+  cartItems: {
+    product: productWithImagesEmbed,
+    taxType: {},
+    variations: variationsEmbed,
+    variationsGroups: variationsGroupsEmbed,
+  },
+  client: {
+    emailAddresses: {},
+    phoneNumbers: {},
+    profilePicture: {},
+  },
+  clientCompany: {},
+  discountItems: {},
+  domain: {
+    company: {
+      defaultTaxType: {},
+      isStripeAccountEnabled: {},
+      taxTypes: {},
+    },
+  },
+  invoice: {},
+  receiverAddress: {},
+  shipmentGroups: {
+    cartItems: {product: {}},
+    quotes: cartShipmentQuote,
+    selectedQuote: cartShipmentQuote,
+  },
+};

package/src/utilities/index.ts

@@ -0,0 +1,14 @@
+export * from './address';
+export * from './cart';
+export * from './company';
+export * from './cookie';
+export * from './currency';
+export * from './helpers';
+export * from './invoice';
+export * from './job';
+export * from './local_storage';
+export * from './product';
+export * from './shipment';
+export * from './tabs';
+export * from './user';
+export * from './variations';

package/src/utilities/invoice.ts

@@ -0,0 +1,60 @@
+const urlToFile = async (url: string, filename: string, type: string) => {
+  const res = await fetch(url);
+  const buf = await res.arrayBuffer();
+  return new File([buf], filename, { type });
+};
+
+const urlToFilePdf = async (url: string, filename: string) => {
+  const file = await urlToFile(url, filename, 'application/pdf');
+  return file;
+};
+
+export async function generatePublicInvoicePdf(apiUrl: string, invoice: any, receipt?: boolean) {
+  const id = invoice.id;
+  const domain = invoice.domain.emailDomain;
+
+  const queryString = new URLSearchParams({
+    invoice_token: invoice.invoiceToken
+  }).toString();
+
+  const fetchOptions: any = {
+    method: 'GET',
+    mode: 'cors'
+  };
+  const uri = receipt ? '/generate/receipt/pdf/' : '/generate/pdf/';
+  try {
+    const response = await fetch(
+      `${apiUrl}invoices/${id}${uri}?${queryString}`,
+      fetchOptions
+    );
+
+    if (!response.ok) {
+      throw new Error("Error fetching PDF.");
+    }
+
+    const r = await response.json();
+    const pdf = await urlToFilePdf(
+      `data:application/pdf;base64,${r.pdf}`,
+      `${domain}-invoice-${id}.pdf`
+    );
+
+    const url = URL.createObjectURL(pdf);
+    const doc = (document as any);
+    const anchor = doc.createElement('a');
+    anchor.href = url;
+    anchor.download = pdf.name;
+
+    // Append to the DOM
+    doc.body.appendChild(anchor);
+
+    // Trigger `click` event
+    anchor.click();
+
+    // Remove element from DOM
+    doc.body.removeChild(anchor);
+
+    return { success: true };
+  } catch (e: any) {
+    throw e;
+  }
+}

package/src/utilities/job.ts

@@ -0,0 +1,13 @@
+import { Merchi } from '@merchi/sdk';
+
+export function makeJob(
+  jobJson: any, makeDirty?: boolean, arrayValueStrict?: boolean
+) {
+  const merchi = new Merchi();
+  const job = new merchi.Job();
+
+  return job.fromJson(
+    jobJson,
+    {makeDirty: !!makeDirty, arrayValueStrict: !!arrayValueStrict}
+  );
+}