@justifi/webcomponents 4.19.3-rc-1 → 4.19.3-rc-2

package/dist/webcomponents/p-15eafa87.js

@@ -0,0 +1,77 @@
+import { p as packageJson } from './p-2e8f4937.js';
+import { A as Api } from './p-29c0b182.js';
+
+class AnalyticsService {
+    async record(body) {
+        const endpoint = 'analytics';
+        return Api({ apiOrigin: "" }).post(endpoint, JSON.stringify(body));
+    }
+}
+
+/**
+ * @class JustifiAnalytics
+ * @description A class to track analytics for a component
+ * @param { component } ComponentInterface - The component to track
+ *
+ */
+class JustifiAnalytics {
+    constructor(component) {
+        this.handleCustomEvent = async (data) => {
+            // Track the event
+            await this.service.record(data);
+        };
+        this.service = new AnalyticsService();
+        this.componentInstance = component;
+        this.setUpBasicData();
+        this.setupLifecycleTracking();
+        this.trackCustomEvents();
+    }
+    get resourceId() {
+        return (this.componentInstance.accountId ||
+            this.componentInstance.businessId ||
+            this.componentInstance.paymentId ||
+            this.componentInstance.payoutId ||
+            this.componentInstance.checkoutId);
+    }
+    setUpBasicData() {
+        this.basicData = {
+            component_name: this.componentInstance.tagName,
+            component_version: packageJson.version,
+            client_user_agent: navigator.userAgent,
+            // navigator.platform is deprecated, use navigator.userAgent instead
+            client_platform: navigator.userAgent,
+            client_origin: window.location.origin,
+            resource_id: this.resourceId,
+        };
+    }
+    trackCustomEvents() {
+        this.eventEmitters = ['submitted', 'error-event'];
+        // for each event, add an event listener
+        this.eventEmitters.forEach((eventName) => {
+            // if this.componentInstance.addEventListener is a function add the event listener
+            if (typeof this.componentInstance.addEventListener === 'function') {
+                this.componentInstance.addEventListener(eventName, (event) => this.handleCustomEvent({
+                    event_type: eventName,
+                    data: Object.assign(Object.assign({}, this.basicData), { error: event.detail }),
+                }));
+            }
+        });
+    }
+    setupLifecycleTracking() {
+        const originalComponentDidLoad = this.componentInstance.componentDidLoad;
+        this.componentInstance.componentDidLoad = () => {
+            this.service.record({ event_type: 'init', data: this.basicData });
+            if (originalComponentDidLoad) {
+                return originalComponentDidLoad.apply(this.componentInstance);
+            }
+        };
+    }
+    cleanup() {
+        // Remove event listeners
+        this.eventEmitters.forEach((event) => {
+            this.componentInstance.removeEventListener(event, this.handleCustomEvent);
+        });
+    }
+}
+
+export { JustifiAnalytics as J };

package/dist/webcomponents/p-18fa0479.entry.js

@@ -0,0 +1,131 @@
+import { r as registerInstance, c as createEvent, h } from './p-fad19d75.js';
+import { A as Api } from './p-29c0b182.js';
+import './p-56f6ce4c.js';
+import './p-df21aaad.js';
+import './p-e3fab0e2.js';
+import { g as getErrorMessage, a as getErrorCode } from './p-8115b2f4.js';
+import { C as ComponentErrorSeverity, a as ComponentErrorCodes } from './p-14c91ffd.js';
+import { J as JustifiAnalytics } from './p-15eafa87.js';
+import './p-2e8f4937.js';
+
+class InsuranceService {
+    async fetchQuote(authToken, payload) {
+        const endpoint = 'insurance/quotes';
+        return Api({ authToken, apiOrigin: "" }).post(endpoint, JSON.stringify(payload));
+    }
+    async toggleCoverage(authToken, quoteId, payload) {
+        const endpoint = `insurance/quotes/${quoteId}/toggle`;
+        return Api({ authToken, apiOrigin: "" }).post(endpoint, JSON.stringify(payload));
+    }
+}
+
+const makeGetQuote = ({ authToken, service }) => async ({ payload, onSuccess, onError }) => {
+    var _a;
+    try {
+        const response = await service.fetchQuote(authToken, payload);
+        if (!response.error) {
+            const quote = response.data;
+            onSuccess({ quote });
+        }
+        else {
+            const responseError = getErrorMessage(response.error);
+            const code = getErrorCode((_a = response.error) === null || _a === void 0 ? void 0 : _a.code);
+            return onError({
+                error: responseError,
+                code,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+    }
+    catch (error) {
+        const code = getErrorCode(error === null || error === void 0 ? void 0 : error.code);
+        return onError({
+            error: error.message || error,
+            code,
+            severity: ComponentErrorSeverity.ERROR,
+        });
+    }
+};
+const makeToggleCoverage = ({ authToken, service }) => async ({ quoteId, payload, onSuccess, onError }) => {
+    var _a;
+    try {
+        const response = await service.toggleCoverage(authToken, quoteId, payload);
+        if (!response.error) {
+            const quote = response.data;
+            onSuccess({ quote });
+        }
+        else {
+            const responseError = getErrorMessage(response.error);
+            const code = getErrorCode((_a = response.error) === null || _a === void 0 ? void 0 : _a.code);
+            return onError({
+                error: responseError,
+                code,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+    }
+    catch (error) {
+        const code = getErrorCode(error === null || error === void 0 ? void 0 : error.code);
+        return onError({
+            error: error.message || error,
+            code,
+            severity: ComponentErrorSeverity.ERROR,
+        });
+    }
+};
+
+const SeasonInterruptionInsurance = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.errorEvent = createEvent(this, "error-event", 7);
+        this.authToken = undefined;
+        this.checkoutId = undefined;
+        this.primaryIdentityFirstName = undefined;
+        this.primaryIdentityLastName = undefined;
+        this.primaryIdentityState = undefined;
+        this.primaryIdentityPostalCode = undefined;
+        this.primaryIdentityCountry = undefined;
+        this.primaryIdentityEmailAddress = undefined;
+        this.policyAttributesInsurableAmount = undefined;
+        this.policyAttributesStartDate = undefined;
+        this.policyAttributesEndDate = undefined;
+        this.coveredIdentityFirstName = undefined;
+        this.coveredIdentityLastName = undefined;
+        this.getQuote = undefined;
+        this.toggleCoverage = undefined;
+        this.quote = undefined;
+    }
+    async validate() {
+        return this.seasonInterruptionCoreRef.validate();
+    }
+    componentWillLoad() {
+        this.analytics = new JustifiAnalytics(this);
+        this.initializeServiceMethods();
+    }
+    disconnectedCallback() {
+        this.analytics.cleanup();
+    }
+    initializeServiceMethods() {
+        if (!this.authToken) {
+            this.errorEvent.emit({
+                errorCode: ComponentErrorCodes.MISSING_PROPS,
+                message: 'Missing authToken',
+                severity: ComponentErrorSeverity.ERROR,
+            });
+            return;
+        }
+        this.getQuote = makeGetQuote({
+            authToken: this.authToken,
+            service: new InsuranceService(),
+        });
+        this.toggleCoverage = makeToggleCoverage({
+            authToken: this.authToken,
+            service: new InsuranceService(),
+        });
+    }
+    render() {
+        return (h("justifi-season-interruption-insurance-core", { key: '256d45d39c5d297abb7f955229b0e0e9fbc9504a', ref: (el) => (this.seasonInterruptionCoreRef = el), "checkout-id": this.checkoutId, getQuote: this.getQuote, toggleCoverage: this.toggleCoverage, "primary-identity-first-name": this.primaryIdentityFirstName, "primary-identity-last-name": this.primaryIdentityLastName, "primary-identity-state": this.primaryIdentityState, "primary-identity-postal-code": this.primaryIdentityPostalCode, "primary-identity-country": this.primaryIdentityCountry, "primary-identity-email-address": this.primaryIdentityEmailAddress, "policy-attributes-insurable-amount": this.policyAttributesInsurableAmount, "policy-attributes-start-date": this.policyAttributesStartDate, "policy-attributes-end-date": this.policyAttributesEndDate, "covered-identity-first-name": this.coveredIdentityFirstName, "covered-identity-last-name": this.coveredIdentityLastName }));
+    }
+};
+
+export { SeasonInterruptionInsurance as justifi_season_interruption_insurance };

package/dist/webcomponents/p-1a5120f4.entry.js

@@ -0,0 +1,145 @@
+import { r as registerInstance, c as createEvent, h } from './p-fad19d75.js';
+import { C as ComponentErrorSeverity, a as ComponentErrorCodes } from './p-14c91ffd.js';
+import { g as getErrorMessage, a as getErrorCode } from './p-8115b2f4.js';
+import { A as Api } from './p-29c0b182.js';
+import './p-56f6ce4c.js';
+import './p-df21aaad.js';
+import './p-e3fab0e2.js';
+import { J as JustifiAnalytics } from './p-15eafa87.js';
+import './p-2e8f4937.js';
+
+const makeGetCheckout = ({ authToken, checkoutId, service }) => async ({ onSuccess, onError }) => {
+    var _a;
+    try {
+        const response = await service.fetchCheckout(authToken, checkoutId);
+        if (!response.error) {
+            const checkout = response.data;
+            onSuccess({ checkout });
+        }
+        else {
+            const responseError = getErrorMessage(response.error);
+            const code = getErrorCode((_a = response.error) === null || _a === void 0 ? void 0 : _a.code);
+            return onError({
+                error: responseError,
+                code,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+    }
+    catch (error) {
+        const code = getErrorCode(error === null || error === void 0 ? void 0 : error.code);
+        return onError({
+            error: error.message || error,
+            code,
+            severity: ComponentErrorSeverity.ERROR,
+        });
+    }
+};
+const makeCheckoutComplete = ({ authToken, checkoutId, service }) => async ({ payment, onSuccess, onError }) => {
+    var _a;
+    try {
+        const response = await service.complete(authToken, checkoutId, payment);
+        if (!response.error) {
+            onSuccess(response);
+        }
+        else {
+            const responseError = getErrorMessage(response.error);
+            const code = getErrorCode((_a = response.error) === null || _a === void 0 ? void 0 : _a.code);
+            return onError({
+                error: responseError,
+                code,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+    }
+    catch (error) {
+        const code = getErrorCode(error === null || error === void 0 ? void 0 : error.code);
+        return onError({
+            error: error.message || error,
+            code,
+            severity: ComponentErrorSeverity.ERROR,
+        });
+    }
+};
+
+class CheckoutService {
+    async fetchCheckout(authToken, checkoutId) {
+        const endpoint = `checkouts/${checkoutId}`;
+        return Api({ authToken, apiOrigin: "" }).get(endpoint);
+    }
+    async complete(authToken, checkoutId, payment) {
+        const endpoint = `checkouts/${checkoutId}/complete`;
+        const payload = {
+            payment_mode: payment.payment_mode,
+        };
+        if (payment.payment_token) {
+            payload.payment_token = payment.payment_token;
+        }
+        return Api({ authToken, apiOrigin: "" }).post(endpoint, JSON.stringify(payload));
+    }
+}
+
+const Checkout = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.errorEvent = createEvent(this, "error-event", 7);
+        this.loadedEvent = createEvent(this, "loaded", 7);
+        this.iframeOrigin = undefined;
+        this.authToken = undefined;
+        this.checkoutId = undefined;
+        this.disableCreditCard = undefined;
+        this.disableBankAccount = undefined;
+        this.disableBnpl = undefined;
+        this.disablePaymentMethodGroup = undefined;
+        this.getCheckout = undefined;
+        this.complete = undefined;
+        this.errorMessage = '';
+    }
+    componentWillLoad() {
+        this.analytics = new JustifiAnalytics(this);
+        this.initializeGetCheckout();
+    }
+    disconnectedCallback() {
+        this.analytics.cleanup();
+    }
+    initializeGetCheckout() {
+        if (this.authToken && this.checkoutId) {
+            this.getCheckout = makeGetCheckout({
+                authToken: this.authToken,
+                checkoutId: this.checkoutId,
+                service: new CheckoutService()
+            });
+            this.complete = makeCheckoutComplete({
+                authToken: this.authToken,
+                checkoutId: this.checkoutId,
+                service: new CheckoutService()
+            });
+        }
+        else {
+            this.errorEvent.emit({
+                message: 'auth-token and checkout-id are required',
+                errorCode: ComponentErrorCodes.MISSING_PROPS,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+    }
+    propChanged() {
+        this.initializeGetCheckout();
+    }
+    async fillBillingForm(fields) {
+        this.checkoutCoreRef.fillBillingForm(fields);
+    }
+    render() {
+        return (h("justifi-checkout-core", { key: 'd2f6bfed1be767edcf4ba21cddc503ff5efbec1a', getCheckout: this.getCheckout, authToken: this.authToken, complete: this.complete, disableCreditCard: this.disableCreditCard, disableBankAccount: this.disableBankAccount, disableBnpl: this.disableBnpl, disablePaymentMethodGroup: this.disablePaymentMethodGroup, ref: el => {
+                if (el) {
+                    this.checkoutCoreRef = el;
+                }
+            } }, h("div", { key: '45ac1bea74ca8ef7999211b51fe7791225d61f00', slot: "insurance" }, h("slot", { key: '13e051844cc7cb4aed98076ccd64954b2dd68228', name: "insurance" }))));
+    }
+    static get watchers() { return {
+        "authToken": ["propChanged"],
+        "checkoutId": ["propChanged"]
+    }; }
+};
+
+export { Checkout as justifi_checkout };