@afosto/checkout-ui 0.0.1-alpha.1

package/dist/hooks/useCheckoutOrder.js

@@ -0,0 +1,461 @@
+import { useCheckoutForm as H } from "./useCheckoutForm.js";
+import { useCheckoutState as J } from "./useCheckoutState.js";
+import { useCheckoutAuth as V } from "./useCheckoutAuth.js";
+import { useQueryClient as W, useMutation as i } from "@tanstack/react-query";
+import { useCheckoutSummary as X } from "./useCheckoutSummary.js";
+import { isDefined as Y } from "@afosto/utils";
+import { useCheckoutAnalytics as Z } from "./useCheckoutAnalytics.js";
+const ft = (k) => {
+  const {
+    orderId: c,
+    analytics: S,
+    defaultOperations: R,
+    isLoadingChannel: f,
+    locale: F,
+    settings: u,
+    storefront: g,
+    operations: e,
+    steps: q
+  } = k || {}, m = W(), y = V({ operations: e, settings: u, storefront: g }), { isInitializingAuth: A } = y, P = X(), h = H({
+    locale: F,
+    settings: u,
+    steps: q
+  }), { initializeSteps: O } = h, w = Z({
+    analytics: S,
+    settings: u
+  }), r = {
+    ...y,
+    ...P,
+    ...h,
+    ...w,
+    defaultOperations: R,
+    operations: e,
+    settings: u,
+    storefront: g
+  }, M = J({
+    enabled: !!c && !A && !f,
+    notFound: !c,
+    onError: e.initial.error,
+    onFormat: async (t) => {
+      const o = await e.initial.formatter(
+        t,
+        r
+      );
+      return o?.order ? o : null;
+    },
+    onSuccess: async (t) => {
+      await e.initial.success(t, r);
+      try {
+        const { skipCheckCompletedSteps: o } = t || {};
+        O(t.order, t, { skipCheckCompletedSteps: o });
+      } catch {
+      }
+    },
+    queryKey: ["initialCheckoutOrderState", c],
+    queryFn: async () => e.initial.queryFn({ id: c }, r)
+  }), { isInitializing: D, setIsAddingExpressPaymentMethod: C } = M, T = D || f, E = i({
+    mutationFn: async (t) => e.addCustomer.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.addCustomer.formatter(
+        t,
+        r
+      );
+      e.addCustomer.success(o, r);
+    },
+    onError: (t) => {
+      e.addCustomer.error(t);
+    }
+  }), I = i({
+    mutationFn: async (t) => e.addCustomerCountryCode.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.addCustomerCountryCode.formatter(
+        t,
+        r
+      );
+      e.addCustomerCountryCode.success(
+        o,
+        r
+      );
+    },
+    onError: (t) => {
+      e.addCustomerCountryCode.error(t);
+    }
+  }), v = i({
+    mutationFn: async (t) => e.addInformation.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.addInformation.formatter(
+        t,
+        r
+      );
+      e.addInformation.success(o, r);
+    },
+    onError: (t) => {
+      e.addInformation.error(t);
+    }
+  }), N = i({
+    mutationFn: async (t) => e.addNote.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.addNote.formatter(
+        t,
+        r
+      );
+      e.addNote.success(o, r);
+    },
+    onError: (t) => {
+      e.addNote.error(t);
+    }
+  }), x = i({
+    mutationFn: async (t) => e.addPaymentMethod.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.addPaymentMethod.formatter(
+        t,
+        r
+      );
+      e.addPaymentMethod.success(o, r);
+    },
+    onError: (t) => {
+      e.addPaymentMethod.error(t);
+    }
+  }), K = i({
+    mutationFn: async (t) => e.addPickupPoint.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.addPickupPoint.formatter(
+        t,
+        r
+      );
+      e.addPickupPoint.success(o, r);
+    },
+    onError: (t) => {
+      e.addPickupPoint.error(t);
+    }
+  }), Q = i({
+    mutationFn: async (t) => e.addShippingMethod.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.addShippingMethod.formatter(
+        t,
+        r
+      );
+      e.addShippingMethod.success(o, r);
+    },
+    onError: (t) => {
+      e.addShippingMethod.error(t);
+    }
+  }), j = i({
+    mutationFn: async (t) => e.checkout.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.checkout.formatter(
+        t,
+        r
+      );
+      e.checkout.success(o, r);
+    },
+    onError: (t) => {
+      e.checkout.error(t);
+    }
+  }), L = i({
+    mutationFn: async (t) => e.setAgreementTemplate.queryFn(t, r),
+    onSuccess: async (t) => {
+      const o = await e.setAgreementTemplate.formatter(
+        t,
+        r
+      );
+      e.setAgreementTemplate.success(
+        o,
+        r
+      );
+    },
+    onError: (t) => {
+      e.setAgreementTemplate.error(t);
+    }
+  }), z = async ({
+    customer: t
+  }) => {
+    const o = await E.mutateAsync({
+      orderId: c,
+      customer: t
+    }), n = await e.addCustomer.formatter(
+      o,
+      r
+    ), { order: s, ...a } = n || {};
+    return {
+      ...s,
+      ...a
+    };
+  }, b = async ({
+    countryCode: t
+  }) => {
+    const o = await I.mutateAsync({
+      orderId: c,
+      countryCode: t
+    }), n = await e.addCustomerCountryCode.formatter(
+      o,
+      r
+    ), { order: s, ...a } = n || {};
+    return {
+      ...s,
+      ...a
+    };
+  }, $ = async ({
+    billingAddress: t,
+    customer: o,
+    phoneNumber: n,
+    shippingAddress: s
+  }) => {
+    const a = await v.mutateAsync({
+      orderId: c,
+      billingAddress: t,
+      customer: o,
+      phoneNumber: n,
+      shippingAddress: s
+    }), d = await e.addInformation.formatter(
+      a,
+      r
+    ), { order: p, ...G } = d || {};
+    return {
+      ...p,
+      ...G
+    };
+  }, U = async ({ note: t }) => {
+    const o = await N.mutateAsync({
+      orderId: c,
+      note: t
+    }), n = await e.addNote.formatter(
+      o,
+      r
+    ), { order: s, ...a } = n || {};
+    return {
+      ...s,
+      ...a
+    };
+  }, _ = async () => {
+    const t = await j.mutateAsync({
+      id: c
+    }), o = await e.checkout.formatter(
+      t,
+      r
+    );
+    if (!o?.order)
+      return;
+    if (o?.order?.billing?.payment?.method?.code?.toLowerCase() === "pin") {
+      const { checkout: p } = u?.channelLinks || {};
+      window.location.href = `${p}/payment/execute?order_id=${o?.order?.id}`;
+      return;
+    }
+    const [s] = o?.order?.options?.proceedingStep?.proceeding?.options || [], { method: a, url: d } = s || {};
+    a?.toLowerCase() === "follow" && Y(d) && (window.location.href = d);
+  }, B = async () => {
+    try {
+      const t = await m.fetchQuery({
+        queryKey: ["getOrderInitialPaymentStep", c],
+        queryFn: async () => e.initialPaymentStep.queryFn(
+          { id: c },
+          r
+        )
+      }), o = await e.initialPaymentStep.formatter(
+        t,
+        r
+      ), { agreementOptions: n, agreementTemplate: s, paymentMethods: a } = o || {};
+      return e.initialPaymentStep.success(
+        o,
+        r
+      ), {
+        agreementOptions: n,
+        agreementTemplate: s,
+        paymentMethods: a
+      };
+    } catch (t) {
+      return e.initialPaymentStep.error(t), Promise.reject(t);
+    }
+  }, l = async ({
+    methodId: t,
+    issuerId: o,
+    terminalId: n
+  }) => {
+    const s = await x.mutateAsync({
+      orderId: c,
+      methodId: t,
+      issuerId: o,
+      terminalId: n
+    }), a = await e.addPaymentMethod.formatter(
+      s,
+      r
+    ), { order: d, ...p } = a || {};
+    return {
+      ...d,
+      ...p
+    };
+  };
+  return {
+    ...M,
+    ...y,
+    ...P,
+    ...h,
+    ...w,
+    addCustomer: z,
+    addCustomerCountryCode: b,
+    addExpressPaymentMethod: async ({
+      methodId: t
+    }) => {
+      try {
+        return C(!0), l({ methodId: t });
+      } catch {
+        C(!1);
+      }
+    },
+    addInformation: $,
+    addNote: U,
+    addPaymentMethod: l,
+    addPickupPoint: async ({
+      pickupPointId: t
+    }) => {
+      const o = await K.mutateAsync({
+        orderId: c,
+        pickupPointId: t
+      }), n = await e.addPickupPoint.formatter(
+        o,
+        r
+      ), { order: s, ...a } = n || {};
+      return {
+        ...s,
+        ...a
+      };
+    },
+    addShippingMethod: async ({
+      methodId: t
+    }) => {
+      const o = await Q.mutateAsync({
+        orderId: c,
+        methodId: t
+      }), n = await e.addShippingMethod.formatter(
+        o,
+        r
+      ), { order: s, ...a } = n || {};
+      return {
+        ...s,
+        ...a
+      };
+    },
+    checkout: _,
+    getInitialPaymentStep: B,
+    getPaymentMethods: async () => {
+      try {
+        const t = await m.fetchQuery({
+          queryKey: ["getOrderPaymentMethods", c],
+          queryFn: async () => e.getPaymentMethods.queryFn(
+            { id: c },
+            r
+          )
+        }), o = await e.getPaymentMethods.formatter(
+          t,
+          r
+        ), {
+          currentPaymentMethod: n,
+          paymentMethods: s,
+          payments: a = []
+        } = o || {};
+        return e.getPaymentMethods.success(o, r), {
+          currentPaymentMethod: n,
+          paymentMethods: s,
+          payments: a
+        };
+      } catch (t) {
+        return e.getPaymentMethods.error(t), Promise.reject(t);
+      }
+    },
+    getPickupPoints: async ({
+      countryCode: t,
+      postalCode: o
+    }) => {
+      try {
+        const n = await m.fetchQuery({
+          queryKey: ["getOrderPickupPoints", t, o],
+          queryFn: async () => e.getPickupPoints.queryFn(
+            {
+              id: c,
+              countryCode: t,
+              postalCode: o
+            },
+            r
+          )
+        }), s = await e.getPickupPoints.formatter(
+          n,
+          r
+        ), { pickupPoints: a } = s || {};
+        return e.getPickupPoints.success(s, r), {
+          pickupPoints: a
+        };
+      } catch (n) {
+        return e.getPickupPoints.error(n), Promise.reject(n);
+      }
+    },
+    getReviewCheckoutData: async () => {
+      try {
+        const t = await m.fetchQuery({
+          queryKey: ["getOrderReviewCheckoutData", c],
+          queryFn: async () => e.getReviewCheckoutData.queryFn(
+            { id: c },
+            r
+          )
+        }), o = await e.getReviewCheckoutData.formatter(
+          t,
+          r
+        ), { order: n, ...s } = o || {};
+        return e.getReviewCheckoutData.success(
+          o,
+          r
+        ), s;
+      } catch (t) {
+        return e.getReviewCheckoutData.error(t), Promise.reject(t);
+      }
+    },
+    getShippingMethods: async ({
+      countryCode: t,
+      postalCode: o
+    }) => {
+      try {
+        const n = await m.fetchQuery({
+          queryKey: ["getOrderShippingMethods", t, o],
+          queryFn: async () => e.getShippingMethods.queryFn(
+            {
+              id: c,
+              countryCode: t,
+              postalCode: o
+            },
+            r
+          )
+        }), s = await e.getShippingMethods.formatter(
+          n,
+          r
+        ), { currentShippingMethod: a, shippingMethods: d } = s || {};
+        return e.getShippingMethods.success(
+          s,
+          r
+        ), {
+          currentShippingMethod: a,
+          shippingMethods: d
+        };
+      } catch (n) {
+        return e.getShippingMethods.error(n), Promise.reject(n);
+      }
+    },
+    isLoading: T,
+    setAgreementTemplate: async ({
+      agreementId: t
+    }) => {
+      const o = await L.mutateAsync({
+        orderId: c,
+        agreementId: t
+      }), n = await e.setAgreementTemplate.formatter(
+        o,
+        r
+      ), { order: s, ...a } = n || {};
+      return {
+        ...s,
+        ...a
+      };
+    }
+  };
+};
+export {
+  ft as useCheckoutOrder
+};

package/dist/hooks/useCheckoutPaymentMethods.d.ts

@@ -0,0 +1,6 @@
+import { CheckoutPaymentMethodOptionType } from '../types';
+export declare const useCheckoutPaymentMethods: () => {
+    isInitializingPaymentMethods: boolean;
+    paymentMethods: CheckoutPaymentMethodOptionType[];
+};
+//# sourceMappingURL=useCheckoutPaymentMethods.d.ts.map

package/dist/hooks/useCheckoutPaymentMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCheckoutPaymentMethods.d.ts","sourceRoot":"","sources":["../../libs/checkout-ui/src/hooks/useCheckoutPaymentMethods.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,UAAU,CAAC;AAMhE,eAAO,MAAM,yBAAyB;;;CA8IrC,CAAC"}

package/dist/hooks/useCheckoutPaymentMethods.js

@@ -0,0 +1,89 @@
+import { useFormContext as H } from "@afosto/components";
+import { useCheckout as V } from "../CheckoutStateProvider/CheckoutStateProvider.js";
+import { useGetLatest as g } from "@afosto/hooks";
+import { useState as S, useEffect as F } from "react";
+import { camelize as I, isDefined as K } from "@afosto/utils";
+import { CHECKOUT_EXPRESS_PAYMENT_METHOD_CODES as N } from "../constants/expressPaymentMethods.js";
+const W = () => {
+  const [b, n] = S(!0), [x, h] = S([]), {
+    activeStep: E,
+    addPaymentMethod: z,
+    getPaymentMethods: T,
+    setSubmitButtonDisabled: k
+  } = V(), l = g({
+    activeStep: E,
+    addPaymentMethod: z,
+    getPaymentMethods: T,
+    setSubmitButtonDisabled: k
+  }), D = H(), u = g(D);
+  return F(() => {
+    (async () => {
+      const {
+        activeStep: y,
+        addPaymentMethod: L,
+        getPaymentMethods: v,
+        setSubmitButtonDisabled: M
+      } = l();
+      try {
+        const P = await v(), {
+          currentPaymentMethod: w,
+          paymentMethods: A,
+          payments: B = []
+        } = P || {}, e = A.filter(
+          (t) => {
+            const s = I(
+              t.code?.toLowerCase() || ""
+            ), a = B.some((o) => {
+              const i = I(
+                o.method?.code?.toLowerCase() || ""
+              ), d = o.details?.express?.isPreAuthorized ?? !1;
+              return i === s && d;
+            });
+            return !N.includes(s) || a;
+          }
+        );
+        if (h(e), !e.length) {
+          M(!0), n(!1);
+          return;
+        }
+        let f = e.find(
+          (t) => t.id === w?.id
+        );
+        if (!K(f)) {
+          const [t] = e;
+          try {
+            const s = u(), { formProps: a, getValues: o, reset: i } = s || {}, { setData: d } = a || {}, _ = (t.issuers || []).length > 0, r = t.terminals || [], O = r.length > 0, G = r.length > 1, [p] = r, m = !G && p ? p?.id : "";
+            await L({
+              methodId: t.id,
+              ...m ? { terminalId: m } : {}
+            }), f = t;
+            const C = {
+              hasIssuers: _,
+              hasTerminals: O,
+              issuerId: "",
+              methodId: t.id,
+              terminalId: m
+            };
+            i({
+              ...o(),
+              ...C
+            }), d((c) => (c.splice(y, 1, {
+              ...c[y],
+              ...C
+            }), c));
+          } catch {
+          }
+        }
+        n(!1);
+      } catch {
+        M(!0), h([]), n(!1);
+      }
+    })();
+  }, [l, u]), {
+    isInitializingPaymentMethods: b,
+    paymentMethods: x
+  };
+};
+export {
+  W as useCheckoutPaymentMethods
+};

package/dist/hooks/useCheckoutPaymentStep.d.ts

@@ -0,0 +1,7 @@
+import { CheckoutAgreementOptionType, CheckoutPaymentMethodOptionType } from '../types';
+export declare const useCheckoutPaymentStep: () => {
+    agreementOptions: CheckoutAgreementOptionType[];
+    isInitializing: boolean;
+    paymentMethods: CheckoutPaymentMethodOptionType[];
+};
+//# sourceMappingURL=useCheckoutPaymentStep.d.ts.map

package/dist/hooks/useCheckoutPaymentStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCheckoutPaymentStep.d.ts","sourceRoot":"","sources":["../../libs/checkout-ui/src/hooks/useCheckoutPaymentStep.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,2BAA2B,EAC3B,+BAA+B,EAChC,MAAM,UAAU,CAAC;AAKlB,eAAO,MAAM,sBAAsB;;;;CA+HlC,CAAC"}

package/dist/hooks/useCheckoutPaymentStep.js

@@ -0,0 +1,76 @@
+import { useGetLatest as g } from "@afosto/hooks";
+import { useState as i, useEffect as E } from "react";
+import { useCheckout as F } from "../CheckoutStateProvider/CheckoutStateProvider.js";
+import { isDefined as j, camelize as h } from "@afosto/utils";
+import { useFormContext as q } from "@afosto/components";
+const W = () => {
+  const [y, m] = i([]), [f, p] = i([]), [b, n] = i(!0), {
+    activeStep: C,
+    getInitialPaymentStep: P,
+    setAgreementTemplate: I,
+    setSubStep: k,
+    setSubmitButtonDisabled: A
+  } = F(), c = g({
+    activeStep: C,
+    getInitialPaymentStep: P,
+    setAgreementTemplate: I,
+    setSubmitButtonDisabled: A,
+    setSubStep: k
+  }), M = q(), r = g(M);
+  return E(() => {
+    (async () => {
+      const {
+        activeStep: u,
+        getInitialPaymentStep: O,
+        setAgreementTemplate: T,
+        setSubmitButtonDisabled: x,
+        setSubStep: s
+      } = c();
+      try {
+        const S = await O(), { agreementOptions: t, agreementTemplate: w, paymentMethods: z } = S || {};
+        if (m(t), p(z), !t.length) {
+          s("paymentMethods"), n(!1);
+          return;
+        }
+        const o = t.find(
+          (e) => e.id === w?.id
+        );
+        if (j(o))
+          o && t.length === 1 && h(o.type?.toLowerCase() || "") === "default" && s("paymentMethods");
+        else {
+          const [e] = t, l = h(
+            e.type?.toLowerCase() || ""
+          ), L = !["cod", "postPaid"].includes(l) && t.length === 1 && l === "default";
+          try {
+            const v = r(), { formProps: B, getValues: D, reset: G } = v || {}, { setData: V } = B || {};
+            await T({
+              agreementId: e.id
+            });
+            const d = {
+              agreementId: e.id || "",
+              agreementType: e.type || ""
+            };
+            G({
+              ...D(),
+              ...d
+            }), V((a) => (a.splice(u, 1, {
+              ...a[u],
+              ...d
+            }), a)), L && s("paymentMethods");
+          } catch {
+          }
+        }
+        n(!1);
+      } catch {
+        x(!0), m([]), p([]), n(!1);
+      }
+    })();
+  }, [c, r]), {
+    agreementOptions: y,
+    isInitializing: b,
+    paymentMethods: f
+  };
+};
+export {
+  W as useCheckoutPaymentStep
+};

package/dist/hooks/useCheckoutReviewStep.d.ts

@@ -0,0 +1,6 @@
+import { CheckoutReviewData } from '../types';
+export declare const useCheckoutReviewStep: () => {
+    isInitializing: boolean;
+    reviewData: CheckoutReviewData | null;
+};
+//# sourceMappingURL=useCheckoutReviewStep.d.ts.map

package/dist/hooks/useCheckoutReviewStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCheckoutReviewStep.d.ts","sourceRoot":"","sources":["../../libs/checkout-ui/src/hooks/useCheckoutReviewStep.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD,eAAO,MAAM,qBAAqB;;;CAiCjC,CAAC"}

package/dist/hooks/useCheckoutReviewStep.js

@@ -0,0 +1,24 @@
+import { useState as a, useEffect as r } from "react";
+import { useCheckout as l } from "../CheckoutStateProvider/CheckoutStateProvider.js";
+import { useGetLatest as w } from "@afosto/hooks";
+const C = () => {
+  const [s, e] = a(!0), [c, t] = a(null), { getReviewCheckoutData: n } = l(), i = w({
+    getReviewCheckoutData: n
+  });
+  return r(() => {
+    (async () => {
+      try {
+        const { getReviewCheckoutData: o } = i(), u = await o();
+        t(u), e(!1);
+      } catch {
+        t(null), e(!1);
+      }
+    })();
+  }, [i]), {
+    isInitializing: s,
+    reviewData: c
+  };
+};
+export {
+  C as useCheckoutReviewStep
+};

package/dist/hooks/useCheckoutShippingMethods.d.ts

@@ -0,0 +1,14 @@
+import { CheckoutShippingMethodOptionType, CheckoutShippingMethodPickupPoint } from '../types';
+export declare const useCheckoutShippingMethods: ({ countryCode, postalCode }: {
+    countryCode: string;
+    postalCode: string;
+}) => {
+    hasSearchPickupPointsError: boolean;
+    isInitializingShippingMethods: boolean;
+    isSearchingPickupPoints: boolean;
+    pickupPoints: CheckoutShippingMethodPickupPoint[];
+    searchPickupPoints: (...args: unknown[]) => Promise<void>;
+    setPickupPoints: import('react').Dispatch<import('react').SetStateAction<CheckoutShippingMethodPickupPoint[]>>;
+    shippingMethods: CheckoutShippingMethodOptionType[];
+};
+//# sourceMappingURL=useCheckoutShippingMethods.d.ts.map

package/dist/hooks/useCheckoutShippingMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCheckoutShippingMethods.d.ts","sourceRoot":"","sources":["../../libs/checkout-ui/src/hooks/useCheckoutShippingMethods.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,UAAU,CAAC;AAGlB,eAAO,MAAM,0BAA0B,GAAI,6BAGxC;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB;;;;;;;;CAgKA,CAAC"}