@justifi/webcomponents 6.7.3 → 6.8.1

package/dist/esm/{bank-account-document-form-inputs_8.entry.js → bank-account-document-form-inputs_9.entry.js}

@@ -1,12 +1,12 @@
 import { r as registerInstance, h, H as Host, c as createEvent, g as getElement } from './index-CV0Pyo1O.js';
 import './config-state-kKn89dp1.js';
 import './dinero-HXpYMWUU.js';
-import './ComponentError-Cjcsf8ku.js';
-import { E as EntityDocumentType } from './GooglePay-5EiPffHy.js';
+import { C as ComponentErrorSeverity } from './ComponentError-Cjcsf8ku.js';
+import { E as EntityDocumentType, m as PLAID_ERROR_SEVERITY, n as PLAID_ERROR_MESSAGES, o as PlaidErrorCodes } from './Plaid-CBrksnBN.js';
 import './Pagination-CLHwhyvu.js';
-import './Business-CHJTjG_5.js';
+import './Business-GgW1g7FQ.js';
 import './Dispute-BH0Xfn-F.js';
-import { a as bankAccountTypeOptions } from './business-form-options-Bm89rMmk.js';
+import { a as bankAccountTypeOptions } from './business-form-options-DamBLV7N.js';
 import './event-types-XYgDHrVL.js';
 import { n as numberOnlyHandler } from './utils-BnjCmwMr.js';
 import { B as text, $ as card, D as heading2, ap as table, P as tableHeadCell, ay as tableCell, U as input, V as label, R as inputInvalid, S as inputDisabled, T as inputFocused, ag as buttonSecondary } from './parts-DrquDBSk.js';
@@ -14,11 +14,14 @@ import { s as snakeCaseToHumanReadable, e as formatDate, d as formatTime } from
 import { S as Skeleton } from './skeleton-D9UXuoik.js';
 import './event-types-CZfYo5-1.js';
 import { F as FormControlErrorText } from './form-control-error-text-CTQxgr7_.js';
-import { u as updateFormValues, a as updateAddressFormValues, b as updateDateOfBirthFormValues } from './input-handlers-AgwQ-yKX.js';
+import { u as updateFormValues, a as updateAddressFormValues, b as updateDateOfBirthFormValues } from './input-handlers-CzWCJ849.js';
 import { P as PHONE_MASKS, I as IDENTITY_MASKS } from './form-input-masks-CVaOFfrI.js';
-import { c as countryLabels } from './country-config-CQxaTFuP.js';
+import { c as countryLabels } from './country-config-D-9YmU94.js';
 import { c as makeGetIdentity, d as makePatchIdentity, e as makePostIdentity } from './payment-provisioning-actions-ONP8lDnV.js';
-import { I as IdentityService } from './business.service-C7smiL6_.js';
+import { I as IdentityService } from './business.service-BWm7Kqs4.js';
+import { B as Button } from './button-DMeChykB.js';
+import { S as StyledHost } from './styled-host-D6byRazK.js';
+import { P as PlaidService, p as plaidIconSvg } from './plaid-icon-wJLd-2NX.js';
 import './index-cDVGjRkU.js';
 import './index-DkoufM1t.js';
 import './utils-BeQLScSm.js';
@@ -198,4 +201,322 @@ const BusinessOwnerForm = class {
     }
 };
 
-export { BankAccountDocumentFormInputs as bank_account_document_form_inputs, BankAccountFormInputs as bank_account_form_inputs, BankAccountFormInputsCanada as bank_account_form_inputs_canada, BankAccountReadOnlyValue as bank_account_read_only_value, BusinessDocumentsOnFile as business_documents_on_file, FileInput as form_control_file, RepresentativeFormInputs as justifi_business_representative_form_inputs, BusinessOwnerForm as justifi_owner_form };
+const PlaidVerification = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.plaidVerificationSuccess = createEvent(this, "plaidVerificationSuccess", 7);
+        this.plaidVerificationError = createEvent(this, "plaidVerificationError", 7);
+        this.linkToken = null;
+        this.linkTokenId = null;
+        this.plaidLink = null;
+        this.isAuthenticating = false;
+        this.isSuccess = false;
+        this.error = null;
+        this.isLoading = false;
+        this.plaidService = new PlaidService();
+        this.abortController = null;
+        this.timeoutId = null;
+        this.initializePlaidLink = async () => {
+            try {
+                // Check if Plaid is available globally
+                if (typeof window.Plaid === 'undefined') {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_SDK_LOAD_FAILED,
+                        message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                        severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                        retryable: true,
+                        userAction: 'Refresh the page and try again',
+                    });
+                    return;
+                }
+                // Get link token from backend
+                await this.getLinkToken();
+                if (!this.linkToken) {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED,
+                        message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED],
+                        severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED],
+                        retryable: true,
+                        userAction: 'Click to try again',
+                    });
+                    return;
+                }
+                // Initialize Plaid Link
+                const Plaid = window.Plaid;
+                this.plaidLink = Plaid.create({
+                    token: this.linkToken,
+                    onSuccess: this.handlePlaidSuccess,
+                    onExit: this.handlePlaidExit,
+                    onEvent: this.handlePlaidEvent,
+                    onLoad: this.handlePlaidLoad,
+                });
+            }
+            catch (error) {
+                this.handleError({
+                    code: PlaidErrorCodes.PLAID_LINK_INIT_FAILED,
+                    message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_LINK_INIT_FAILED],
+                    severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_LINK_INIT_FAILED],
+                    originalError: error,
+                    retryable: true,
+                    userAction: 'Click to try again',
+                });
+            }
+        };
+        this.getLinkToken = async () => {
+            var _a, _b, _c, _d;
+            try {
+                if (!this.authToken || !this.accountId) {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED,
+                        message: 'Missing authentication. Please provide authToken and accountId.',
+                        severity: ComponentErrorSeverity.ERROR,
+                        retryable: false,
+                        userAction: 'Provide required props',
+                    });
+                    return;
+                }
+                // Create abort controller for timeout handling
+                this.abortController = new AbortController();
+                // Set timeout for the request
+                this.timeoutId = setTimeout(() => {
+                    var _a;
+                    (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+                }, 30000); // 30 second timeout
+                const response = await this.plaidService.getLinkTokenForVerification(this.authToken, this.businessId, this.abortController.signal);
+                // Clear timeout
+                if (this.timeoutId) {
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                if (response.error) {
+                    const errorMessage = typeof response.error === 'string'
+                        ? response.error
+                        : response.error.message || 'Failed to get link token';
+                    throw new Error(errorMessage);
+                }
+                this.linkToken = response.data.link_token;
+                this.linkTokenId = response.data.id;
+            }
+            catch (error) {
+                // Clear timeout
+                if (this.timeoutId) {
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                let errorCode = PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED;
+                let message = PLAID_ERROR_MESSAGES[errorCode];
+                let retryable = true;
+                // Handle specific error types
+                if (error.name === 'AbortError') {
+                    errorCode = PlaidErrorCodes.PLAID_TIMEOUT;
+                    message = PLAID_ERROR_MESSAGES[errorCode];
+                    retryable = true;
+                }
+                else if (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('network')) || ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('fetch'))) {
+                    errorCode = PlaidErrorCodes.PLAID_NETWORK_ERROR;
+                    message = PLAID_ERROR_MESSAGES[errorCode];
+                    retryable = true;
+                }
+                else if (((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('401')) || ((_d = error.message) === null || _d === void 0 ? void 0 : _d.includes('unauthorized'))) {
+                    errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                    message = 'Authentication failed. Please check your credentials.';
+                    retryable = false;
+                }
+                this.handleError({
+                    code: errorCode,
+                    message: message,
+                    severity: PLAID_ERROR_SEVERITY[errorCode],
+                    originalError: error,
+                    retryable,
+                    userAction: retryable ? 'Click to try again' : 'Check your credentials',
+                });
+            }
+        };
+        this.openPlaidLink = () => {
+            if (this.plaidLink && this.linkToken) {
+                this.isAuthenticating = true;
+                this.clearError();
+                this.plaidLink.open();
+            }
+        };
+        this.handlePlaidSuccess = async (publicToken, _metadata) => {
+            var _a;
+            this.isAuthenticating = false;
+            this.isLoading = true;
+            this.clearError();
+            try {
+                // Send publicToken to backend
+                const response = await this.plaidService.postPlaidVerifiedBankAccountData(this.authToken, this.businessId, { public_token: publicToken, link_token_id: this.linkTokenId }, (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal);
+                if (response.error) {
+                    const errorMessage = typeof response.error === 'string'
+                        ? response.error
+                        : response.error.message || 'Failed to verify bank account';
+                    throw new Error(errorMessage);
+                }
+                // Success - display success message
+                this.isSuccess = true;
+                this.isLoading = false;
+                // Emit success event
+                this.plaidVerificationSuccess.emit({ publicToken, bankAccount: response.data });
+            }
+            catch (error) {
+                this.isLoading = false;
+                this.handleError({
+                    code: PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED,
+                    message: (error === null || error === void 0 ? void 0 : error.message) || 'Failed to verify bank account',
+                    severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED],
+                    originalError: error,
+                    retryable: true,
+                    userAction: 'Click to try again',
+                });
+            }
+        };
+        this.handlePlaidExit = (err, _metadata) => {
+            this.isAuthenticating = false;
+            if (err) {
+                this.handlePlaidError(err);
+            }
+        };
+        this.handlePlaidEvent = (eventName, metadata) => {
+            // Handle specific events if needed
+            switch (eventName) {
+                case 'OPEN':
+                    this.isAuthenticating = true;
+                    break;
+                case 'CLOSE':
+                    this.isAuthenticating = false;
+                    break;
+                case 'ERROR':
+                    this.handlePlaidError(metadata);
+                    break;
+            }
+        };
+        this.handlePlaidLoad = () => {
+            // Plaid Link loaded successfully
+        };
+        this.handlePlaidError = (error) => {
+            let errorCode = PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED;
+            let message = PLAID_ERROR_MESSAGES[errorCode];
+            let retryable = true;
+            let userAction = 'Click to try again';
+            // Map Plaid error codes to our error codes
+            if (error.error_code) {
+                switch (error.error_code) {
+                    case 'INVALID_CREDENTIALS':
+                        errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    case 'ITEM_LOGIN_REQUIRED':
+                        errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                        message = 'Your bank requires re-authentication. Please try again.';
+                        retryable = true;
+                        break;
+                    case 'ITEM_LOCKED':
+                        errorCode = PlaidErrorCodes.PLAID_ACCOUNT_LOCKED;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = false;
+                        userAction = 'Contact your bank';
+                        break;
+                    case 'INSTITUTION_NOT_RESPONDING':
+                        errorCode = PlaidErrorCodes.PLAID_MAINTENANCE;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    case 'RATE_LIMIT_EXCEEDED':
+                        errorCode = PlaidErrorCodes.PLAID_RATE_LIMITED;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    default:
+                        if (error.error_message) {
+                            message = error.error_message;
+                        }
+                        break;
+                }
+            }
+            this.handleError({
+                code: errorCode,
+                message,
+                severity: PLAID_ERROR_SEVERITY[errorCode],
+                originalError: error,
+                retryable,
+                userAction,
+            });
+            this.isAuthenticating = false;
+        };
+        this.handleError = (plaidError) => {
+            this.error = plaidError;
+            this.isLoading = false;
+            // Emit error event for parent components
+            this.plaidVerificationError.emit(plaidError);
+            console.error('Plaid verification error:', plaidError);
+        };
+        this.clearError = () => {
+            if (this.error) {
+                this.error = null;
+            }
+        };
+    }
+    componentDidRender() {
+        if (!this.scriptRef)
+            return;
+        this.scriptRef.onload = () => {
+            this.initializePlaidLink();
+        };
+        this.scriptRef.onerror = () => {
+            this.handleError({
+                code: PlaidErrorCodes.PLAID_SDK_LOAD_FAILED,
+                message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                retryable: true,
+                userAction: 'Refresh the page and try again',
+            });
+        };
+    }
+    disconnectedCallback() {
+        // Clean up timeouts and abort controllers
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+        }
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    render() {
+        const renderErrorState = () => {
+            if (!this.error)
+                return null;
+            const errorClass = this.error.severity === ComponentErrorSeverity.ERROR
+                ? 'text-danger'
+                : this.error.severity === ComponentErrorSeverity.WARNING
+                    ? 'text-warning'
+                    : 'text-info';
+            return (h("div", { class: `${errorClass} mt-2` }, h("small", null, this.error.message), h("br", null), this.error.userAction && (h("small", { class: "text-muted" }, this.error.userAction))));
+        };
+        const renderStatusState = () => {
+            if (this.error)
+                return null;
+            if (this.isLoading) {
+                return (h("div", { class: "text-info mt-2" }, h("small", null, "Verifying bank account...")));
+            }
+            if (this.isSuccess) {
+                return (h("div", { class: "text-success mt-2" }, h("small", null, "\u2713 Bank account verified successfully")));
+            }
+            if (this.isAuthenticating) {
+                return (h("div", { class: "text-info mt-2" }, h("small", null, "Connecting to your bank...")));
+            }
+            return null;
+        };
+        const plaidLogo = (h("img", { class: "plaid-logo-img", src: plaidIconSvg, alt: "Plaid", title: "Plaid", style: {
+                display: 'inline',
+                width: '20px',
+                height: '20px',
+                marginLeft: '5px',
+                marginTop: '-2px',
+            } }));
+        return (h(StyledHost, null, h("script", { src: "https://cdn.plaid.com/link/v2/stable/link-initialize.js", async: true, ref: (el) => (this.scriptRef = el) }), h("div", null, h("div", { class: "mb-3" }, h(Button, { variant: "secondary", type: "button", onClick: (event) => { event.preventDefault(); this.openPlaidLink(); }, disabled: this.isLoading, part: buttonSecondary }, "Link Bank Account with ", plaidLogo)), renderErrorState(), renderStatusState())));
+    }
+};
+
+export { BankAccountDocumentFormInputs as bank_account_document_form_inputs, BankAccountFormInputs as bank_account_form_inputs, BankAccountFormInputsCanada as bank_account_form_inputs_canada, BankAccountReadOnlyValue as bank_account_read_only_value, BusinessDocumentsOnFile as business_documents_on_file, FileInput as form_control_file, RepresentativeFormInputs as justifi_business_representative_form_inputs, BusinessOwnerForm as justifi_owner_form, PlaidVerification as plaid_verification };

package/dist/esm/{business-additional-questions-schema-DQb10ehS.js → business-additional-questions-schema-CQ8CuEfQ.js}

@@ -1,7 +1,7 @@
 import { c as create$3, a as create$6 } from './index.esm-IWS0494Y.js';
-import { m as makeTaxIdValidation, d as dateOfIncorporationValidation, i as industryValidation, b as businessClassificationValidation, a as doingBusinessAsValidation, p as phoneValidation, e as emailValidation, w as websiteUrlValidation, c as businessNameValidation, t as taxIdValidation, o as otherPaymentDetailsValidation, f as whenServiceReceivedValidation, r as revenueValidation, g as paymentVolumeValidation } from './schema-validations-jBrJ0mYI.js';
-import { C as CountryCode } from './Business-CHJTjG_5.js';
-import { c as countryLabels } from './country-config-CQxaTFuP.js';
+import { m as makeTaxIdValidation, d as dateOfIncorporationValidation, i as industryValidation, b as businessClassificationValidation, a as doingBusinessAsValidation, p as phoneValidation, e as emailValidation, w as websiteUrlValidation, c as businessNameValidation, t as taxIdValidation, o as otherPaymentDetailsValidation, f as whenServiceReceivedValidation, r as revenueValidation, g as paymentVolumeValidation } from './schema-validations-CfHWzMvr.js';
+import { C as CountryCode } from './Business-GgW1g7FQ.js';
+import { c as countryLabels } from './country-config-D-9YmU94.js';
 
 // Base schema (no country-specific rules for classification/tax id)
 const baseBusinessCoreInfoSchema = (allowOptionalFields) => {

package/dist/esm/{business-form-options-Bm89rMmk.js → business-form-options-DamBLV7N.js}

@@ -1,4 +1,4 @@
-import { a as BusinessClassification } from './Business-CHJTjG_5.js';
+import { a as BusinessClassification } from './Business-GgW1g7FQ.js';
 
 const businessClassificationOptions = [
     {

package/dist/esm/{business-identity-schema-CaMnpPqx.js → business-identity-schema-BTyJz7M9.js}

@@ -1,6 +1,6 @@
 import { c as create$3, a as create$6 } from './index.esm-IWS0494Y.js';
-import { h as cityValidation, l as lineTwoValidation, j as lineOneValidation, k as makePostalValidation, n as ownershipPercentageValidation, s as ssnValidation, q as dobValidation, p as phoneValidation, e as emailValidation, u as identityTitleValidation, v as identityNameValidation, x as makeIdentityNumberValidation } from './schema-validations-jBrJ0mYI.js';
-import { C as CountryCode } from './Business-CHJTjG_5.js';
+import { h as cityValidation, l as lineTwoValidation, j as lineOneValidation, k as makePostalValidation, n as ownershipPercentageValidation, s as ssnValidation, q as dobValidation, p as phoneValidation, e as emailValidation, u as identityTitleValidation, v as identityNameValidation, x as makeIdentityNumberValidation } from './schema-validations-CfHWzMvr.js';
+import { C as CountryCode } from './Business-GgW1g7FQ.js';
 
 // Internal USA schemas
 const schemaUSA$1 = () => create$3({

package/dist/esm/{business.service-C7smiL6_.js → business.service-BWm7Kqs4.js}

@@ -1,8 +1,8 @@
 import { A as Api } from './Api-ohkSjyhl.js';
 import './ComponentError-Cjcsf8ku.js';
-import './GooglePay-5EiPffHy.js';
+import './Plaid-CBrksnBN.js';
 import './Pagination-CLHwhyvu.js';
-import './Business-CHJTjG_5.js';
+import './Business-GgW1g7FQ.js';
 import './Dispute-BH0Xfn-F.js';
 
 const api = Api();

package/dist/esm/{check-pkg-version-DIZ2yD72.js → check-pkg-version-BEQSf1m2.js}

@@ -1,9 +1,9 @@
-import { p as packageJson } from './package-ZkBwsSuI.js';
+import { p as packageJson } from './package-C6OQPUis.js';
 import { A as Api } from './Api-ohkSjyhl.js';
 import './ComponentError-Cjcsf8ku.js';
-import './GooglePay-5EiPffHy.js';
+import './Plaid-CBrksnBN.js';
 import './Pagination-CLHwhyvu.js';
-import './Business-CHJTjG_5.js';
+import './Business-GgW1g7FQ.js';
 import './Dispute-BH0Xfn-F.js';
 
 const api = Api();
@@ -22,6 +22,7 @@ class AnalyticsService {
  */
 class JustifiAnalytics {
     constructor(component) {
+        this.eventListeners = new Map();
         this.handleCustomEvent = async (data) => {
             // Track the event
             await this.service.record(data);
@@ -61,10 +62,12 @@ class JustifiAnalytics {
         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({
+                const boundHandler = (event) => this.handleCustomEvent({
                     event_type: eventName,
                     data: Object.assign(Object.assign({}, this.basicData), { error: event.detail }),
-                }));
+                });
+                this.eventListeners.set(eventName, boundHandler);
+                this.componentInstance.addEventListener(eventName, boundHandler);
             }
         });
     }
@@ -79,12 +82,10 @@ class JustifiAnalytics {
     }
     cleanup() {
         // Remove event listeners
-        if (!this.eventEmitters) {
-            return;
-        }
-        this.eventEmitters.forEach((event) => {
-            this.componentInstance.removeEventListener(event, this.handleCustomEvent);
+        this.eventListeners.forEach((handler, eventName) => {
+            this.componentInstance.removeEventListener(eventName, handler);
         });
+        this.eventListeners.clear();
     }
 }
 

package/dist/esm/{checkout.service-CYq6KXZv.js → checkout.service-D4Mljqjr.js}

@@ -1,8 +1,8 @@
 import { A as Api } from './Api-ohkSjyhl.js';
 import './ComponentError-Cjcsf8ku.js';
-import './GooglePay-5EiPffHy.js';
+import './Plaid-CBrksnBN.js';
 import './Pagination-CLHwhyvu.js';
-import './Business-CHJTjG_5.js';
+import './Business-GgW1g7FQ.js';
 import './Dispute-BH0Xfn-F.js';
 
 const api = Api();

package/dist/esm/checkouts-list-core.entry.js

@@ -2,9 +2,9 @@ import { r as registerInstance, c as createEvent, h } from './index-CV0Pyo1O.js'
 import './config-state-kKn89dp1.js';
 import './dinero-HXpYMWUU.js';
 import './ComponentError-Cjcsf8ku.js';
-import './GooglePay-5EiPffHy.js';
+import './Plaid-CBrksnBN.js';
 import { p as pagingDefaults } from './Pagination-CLHwhyvu.js';
-import './Business-CHJTjG_5.js';
+import './Business-GgW1g7FQ.js';
 import './Dispute-BH0Xfn-F.js';
 import { T as Table, a as TableComponent, b as TableHead, c as TableHeadRow, d as TableBody, e as TableLoadingState, f as TableEmptyState, g as TableErrorState, h as TableRow, i as TableFoot, j as TableFootRow, k as TableFootCell, l as TableWrapper } from './table-BbMG2jg9.js';
 import { T as TableClickActions } from './event-types-CZfYo5-1.js';

package/dist/esm/{country-config-CQxaTFuP.js → country-config-D-9YmU94.js}

@@ -1,4 +1,4 @@
-import { S as StateOptions } from './Business-CHJTjG_5.js';
+import { S as StateOptions } from './Business-GgW1g7FQ.js';
 
 const ProvinceOptions = [
     {

package/dist/esm/custom-popper_2.entry.js

@@ -1798,38 +1798,66 @@ const CustomPopper = class {
         this.placement = 'bottom';
         this.offset = [0, 10];
         this.strategy = 'absolute';
-        this.trigger = 'click'; // 'click', 'hover', 'focus'
+        this.trigger = 'click';
         this.isOpen = false;
+        this.initialized = false;
+        this.boundHandlers = {
+            show: null,
+            hide: null,
+            handleClick: null,
+        };
+    }
+    onAnchorRefChange(newValue) {
+        if (newValue && this.popperContentRef && !this.initialized) {
+            this.initPopper();
+        }
     }
     componentDidLoad() {
+        if (this.anchorRef && this.popperContentRef) {
+            this.initPopper();
+        }
+    }
+    initPopper() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        // Store bound references
+        this.boundHandlers.show = this.show.bind(this);
+        this.boundHandlers.hide = this.hide.bind(this);
+        this.boundHandlers.handleClick = this.handleClick.bind(this);
         this.popperInstance = createPopper(this.anchorRef, this.popperContentRef, this.popperOptions);
         if (this.trigger === 'click') {
-            window.addEventListener('click', this.handleClick.bind(this));
+            window.addEventListener('click', this.boundHandlers.handleClick);
         }
         else if (this.trigger === 'hover') {
-            this.anchorRef.addEventListener('mouseenter', this.show.bind(this));
-            this.anchorRef.addEventListener('mouseleave', this.hide.bind(this));
-            this.popperContentRef.addEventListener('mouseenter', this.show.bind(this));
-            this.popperContentRef.addEventListener('mouseleave', this.hide.bind(this));
+            this.anchorRef.addEventListener('mouseenter', this.boundHandlers.show);
+            this.anchorRef.addEventListener('mouseleave', this.boundHandlers.hide);
+            this.popperContentRef.addEventListener('mouseenter', this.boundHandlers.show);
+            this.popperContentRef.addEventListener('mouseleave', this.boundHandlers.hide);
         }
         else if (this.trigger === 'focus') {
-            this.anchorRef.addEventListener('focus', this.show.bind(this));
-            this.anchorRef.addEventListener('blur', this.hide.bind(this));
+            this.anchorRef.addEventListener('focus', this.boundHandlers.show);
+            this.anchorRef.addEventListener('blur', this.boundHandlers.hide);
         }
     }
     disconnectedCallback() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!this.initialized)
+            return;
+        // Clean up popper instance
+        (_a = this.popperInstance) === null || _a === void 0 ? void 0 : _a.destroy();
         if (this.trigger === 'click') {
-            window.removeEventListener('click', this.handleClick.bind(this));
+            window.removeEventListener('click', this.boundHandlers.handleClick);
         }
         else if (this.trigger === 'hover') {
-            this.anchorRef.removeEventListener('mouseenter', this.show.bind(this));
-            this.anchorRef.removeEventListener('mouseleave', this.hide.bind(this));
-            this.popperContentRef.removeEventListener('mouseenter', this.show.bind(this));
-            this.popperContentRef.removeEventListener('mouseleave', this.hide.bind(this));
+            (_b = this.anchorRef) === null || _b === void 0 ? void 0 : _b.removeEventListener('mouseenter', this.boundHandlers.show);
+            (_c = this.anchorRef) === null || _c === void 0 ? void 0 : _c.removeEventListener('mouseleave', this.boundHandlers.hide);
+            (_d = this.popperContentRef) === null || _d === void 0 ? void 0 : _d.removeEventListener('mouseenter', this.boundHandlers.show);
+            (_e = this.popperContentRef) === null || _e === void 0 ? void 0 : _e.removeEventListener('mouseleave', this.boundHandlers.hide);
         }
         else if (this.trigger === 'focus') {
-            this.anchorRef.removeEventListener('focus', this.show.bind(this));
-            this.anchorRef.removeEventListener('blur', this.hide.bind(this));
+            (_f = this.anchorRef) === null || _f === void 0 ? void 0 : _f.removeEventListener('focus', this.boundHandlers.show);
+            (_g = this.anchorRef) === null || _g === void 0 ? void 0 : _g.removeEventListener('blur', this.boundHandlers.hide);
         }
     }
     handleClick(event) {
@@ -1873,7 +1901,7 @@ const CustomPopper = class {
         this.hideEvent.emit();
     }
     render() {
-        return (h("div", { key: 'd9ed696150f2def459af17d43a2a06e0fb24b2d1' }, h("style", { key: 'eb3f2a09ace3aa7d0d6225947a0d511cf73b107b' }, `
+        return (h("div", { key: '2d57f47cc668826c2a72d70d3a0404837398a646' }, h("style", { key: '6d02bdb47dd36a529d2e8ae3f2b4adad6c8cdf88' }, `
           .popper-content {
             display: none;
           }
@@ -1881,8 +1909,11 @@ const CustomPopper = class {
             display: block;
             z-index: 1030;
           }
-          `), h("div", { key: '3221d4cc026a4b9ef06aaaa38a5ad4bc5f190f81', class: "popper-content", ref: (el) => this.popperContentRef = el }, h("slot", { key: '6481dcba1041571349cb8c91c350c497453fe054' }))));
+          `), h("div", { key: 'fdcb769c70b92532427e09fdaa5bbdffc59c8ac3', class: "popper-content", ref: (el) => this.popperContentRef = el }, h("slot", { key: '1cdd517d323181dee0f2a345406d07432889ee21' }))));
     }
+    static get watchers() { return {
+        "anchorRef": ["onAnchorRefChange"]
+    }; }
 };
 
 const TooltipComponent = class {

package/dist/esm/{dispute.service-D7Dv8LTn.js → dispute.service-ZpqfPDC0.js}

@@ -1,8 +1,8 @@
 import { A as Api } from './Api-ohkSjyhl.js';
 import './ComponentError-Cjcsf8ku.js';
-import './GooglePay-5EiPffHy.js';
+import './Plaid-CBrksnBN.js';
 import './Pagination-CLHwhyvu.js';
-import './Business-CHJTjG_5.js';
+import './Business-GgW1g7FQ.js';
 import './Dispute-BH0Xfn-F.js';
 
 const api = Api();

package/dist/esm/form-alert_5.entry.js

@@ -1,9 +1,9 @@
 import { r as registerInstance, h, H as Host } from './index-CV0Pyo1O.js';
 import { az as alertDanger, D as heading2, V as label, S as inputDisabled, ag as buttonSecondary } from './parts-DrquDBSk.js';
-import { b as businessServiceReceivedOptions, r as recurringPaymentsOptions, s as seasonalBusinessOptions, c as businessClassificationOptions } from './business-form-options-Bm89rMmk.js';
+import { b as businessServiceReceivedOptions, r as recurringPaymentsOptions, s as seasonalBusinessOptions, c as businessClassificationOptions } from './business-form-options-DamBLV7N.js';
 import { C as CURRENCY_MASK, I as IDENTITY_MASKS, P as PHONE_MASKS } from './form-input-masks-CVaOFfrI.js';
-import { e as CoreBusinessInfo, d as deconstructDate } from './Business-CHJTjG_5.js';
-import { c as countryLabels } from './country-config-CQxaTFuP.js';
+import { e as CoreBusinessInfo, d as deconstructDate } from './Business-GgW1g7FQ.js';
+import { c as countryLabels } from './country-config-D-9YmU94.js';
 
 const FormAlert = class {
     constructor(hostRef) {

package/dist/esm/form-control-number-masked_3.entry.js

@@ -3,9 +3,9 @@ import { I as IMask } from './index-Ce_F4E0f.js';
 import { R as inputInvalid, S as inputDisabled, T as inputFocused, U as input, V as label } from './parts-DrquDBSk.js';
 import { F as FormControlErrorText } from './form-control-error-text-CTQxgr7_.js';
 import './event-types-CZfYo5-1.js';
-import { C as CountryCode } from './Business-CHJTjG_5.js';
+import { C as CountryCode } from './Business-GgW1g7FQ.js';
 import { n as numberOnlyHandler } from './utils-BnjCmwMr.js';
-import { b as countryOptions, c as countryLabels } from './country-config-CQxaTFuP.js';
+import { b as countryOptions, c as countryLabels } from './country-config-D-9YmU94.js';
 
 const NumberInputMasked = class {
     constructor(hostRef) {