@justifi/webcomponents 6.5.1-rc.2 → 6.6.0

package/dist/collection/components/business-forms/payment-provisioning/bank-account/business-bank-account-form-step-core.js

@@ -1,466 +0,0 @@
-import { h } from "@stencil/core";
-import { bankAccountSchemaByCountry } from "../../schemas/business-bank-account-schema";
-import { CountryCode } from "../../../../utils/country-codes";
-import { FormController } from "../../../../ui-components/form/form";
-import { BusinessFormStep } from "../../utils";
-import { heading2 } from "../../../../styles/parts";
-import { PaymentProvisioningLoading } from "../payment-provisioning-loading";
-import { BankAccount, EntityDocument, EntityDocumentStorage, ComponentErrorCodes, ComponentErrorSeverity, } from "../../../../api";
-export class BusinessBankAccountFormStepCore {
-    constructor() {
-        this.errors = {};
-        this.bankAccount = {};
-        this.existingDocuments = [];
-        this.documentData = new EntityDocumentStorage();
-        this.isLoading = false;
-        this.getSchema = () => {
-            const schema = bankAccountSchemaByCountry[this.country];
-            return schema(this.allowOptionalFields, this.existingDocuments);
-        };
-        this.initializeFormController = () => {
-            this.formController = new FormController(this.getSchema());
-            this.formController.setInitialValues(Object.assign({}, this.bankAccount));
-            this.formController.errors.subscribe(errors => {
-                this.errors = Object.assign({}, errors);
-            });
-        };
-        this.inputHandler = (name, value) => {
-            this.formController.setValues(Object.assign(Object.assign({}, this.formController.values.getValue()), { [name]: value }));
-        };
-        this.storeFiles = (e) => {
-            const fileList = Array.from(e.detail.fileList);
-            const docType = e.detail.document_type;
-            const documentList = fileList.map(file => new EntityDocument({ file, document_type: docType }, this.businessId));
-            this.documentData[docType] = documentList;
-        };
-        this.getData = () => {
-            this.isLoading = true;
-            this.getBusiness({
-                onSuccess: (response) => {
-                    if (response.data.bank_accounts.length > 0) {
-                        this.bankAccount = new BankAccount(response.data.bank_accounts[0]);
-                    }
-                    else {
-                        this.bankAccount = new BankAccount({});
-                        this.bankAccount.business_id = this.businessId;
-                    }
-                    this.existingDocuments = response.data.documents;
-                },
-                onError: ({ error, code, severity }) => {
-                    this.errorEvent.emit({
-                        message: error,
-                        errorCode: code,
-                        severity: severity
-                    });
-                },
-                final: () => {
-                    this.initializeFormController();
-                    this.isLoading = false;
-                }
-            });
-        };
-        this.postDocumentRecordData = async (docData) => {
-            this.isLoading = true;
-            const payload = docData.record_data;
-            return new Promise((resolve) => {
-                this.postDocumentRecord({
-                    payload,
-                    onSuccess: (response) => {
-                        resolve(this.handleDocRecordResponse(docData, response));
-                    },
-                    onError: ({ error, code, severity }) => {
-                        this.errorEvent.emit({
-                            message: error,
-                            errorCode: code,
-                            severity: severity
-                        });
-                        resolve(false);
-                    },
-                });
-            });
-        };
-        this.handleDocRecordResponse = (docData, response) => {
-            if (response.error) {
-                this.errorEvent.emit({
-                    errorCode: ComponentErrorCodes.POST_ERROR,
-                    message: response.error.message,
-                    severity: ComponentErrorSeverity.ERROR,
-                    data: response.error,
-                });
-                return false;
-            }
-            else {
-                docData.setPresignedUrl(response.data.presigned_url);
-                return true;
-            }
-        };
-        this.uploadDocument = async (docData) => {
-            if (!docData.presigned_url) {
-                throw new Error('Presigned URL is not set');
-            }
-            const fileData = await docData.getFileData();
-            const response = await fetch(docData.presigned_url, {
-                method: 'PUT',
-                body: fileData
-            });
-            return this.handleUploadResponse(response);
-        };
-        this.handleUploadResponse = (response) => {
-            if (response.error) {
-                this.errorEvent.emit({
-                    errorCode: ComponentErrorCodes.POST_ERROR,
-                    message: response.error.message,
-                    severity: ComponentErrorSeverity.ERROR,
-                    data: response.error,
-                });
-                return false;
-            }
-            else {
-                return true;
-            }
-        };
-    }
-    watchHandler(newValue) {
-        this.formLoading.emit(newValue);
-    }
-    async validateAndSubmit({ onSuccess }) {
-        if (this.existingBankAccount) {
-            // If a bank account already exists, skip bank account posting; proceed directly to document upload
-            this.sendData(onSuccess);
-        }
-        else {
-            // If bank account is new, validate form inputs (bank account fields), then proceed
-            this.formController.validateAndSubmit(() => this.sendData(onSuccess));
-        }
-    }
-    componentWillLoad() {
-        this.getBusiness && this.getData();
-        this.formController = new FormController(this.getSchema());
-    }
-    componentDidLoad() {
-        this.formController.errors.subscribe(errors => {
-            this.errors = Object.assign({}, errors);
-        });
-    }
-    get postPayload() {
-        const values = this.formController.values.getValue();
-        const formValues = new BankAccount(values).payload;
-        return formValues;
-    }
-    get existingBankAccount() {
-        var _a;
-        return !!((_a = this.bankAccount) === null || _a === void 0 ? void 0 : _a.id);
-    }
-    async sendData(onSuccess) {
-        try {
-            //  Post bank account data if the form is not disabled
-            const bankAccountPosted = !this.existingBankAccount ? await this.postBankAccountData() : true;
-            if (!bankAccountPosted) {
-                return;
-            }
-            // Post documents only after bank account was successfully created
-            const documentsUploaded = await this.postBusinessDocuments();
-            if (!documentsUploaded) {
-                return;
-            }
-            onSuccess();
-        }
-        catch (error) {
-            this.errorEvent.emit({
-                message: error,
-                errorCode: ComponentErrorCodes.POST_ERROR,
-                severity: ComponentErrorSeverity.ERROR
-            });
-        }
-    }
-    async postBankAccountData() {
-        let submittedData;
-        this.isLoading = true;
-        return new Promise((resolve) => {
-            let success = false;
-            this.postBankAccount({
-                payload: this.postPayload,
-                onSuccess: (response) => {
-                    submittedData = response;
-                    success = true;
-                },
-                onError: ({ error, code, severity }) => {
-                    success = false;
-                    this.errorEvent.emit({
-                        message: error,
-                        errorCode: code,
-                        severity: severity
-                    });
-                },
-                final: () => {
-                    this.stepCompleteEvent.emit({ response: submittedData, formStep: BusinessFormStep.bankAccount });
-                    this.isLoading = false;
-                    resolve(success);
-                }
-            });
-        });
-    }
-    async postBusinessDocuments() {
-        this.isLoading = true;
-        try {
-            const docArray = Object.values(this.documentData).flat();
-            if (!docArray.length) {
-                return true;
-            }
-            const recordsCreated = await Promise.all(docArray.map((docData) => this.postDocumentRecordData(docData))); // Create document records
-            if (recordsCreated.includes(false)) {
-                return false;
-            } // Exit if document record creation fails
-            const uploadsCompleted = await Promise.all(docArray.map((docData) => this.uploadDocument(docData))); // Upload documents to AWS presigned URLs
-            if (uploadsCompleted.includes(false)) {
-                return false;
-            } // Exit if any upload fails
-            return true;
-        }
-        finally {
-            this.isLoading = false;
-        }
-    }
-    render() {
-        const bankAccountDefaultValue = this.formController.getInitialValues();
-        if (this.isLoading) {
-            return h(PaymentProvisioningLoading, null);
-        }
-        return (h("form", null, h("fieldset", { class: "mb-4" }, h("div", { class: "d-flex align-items-center gap-2" }, h("legend", { class: "mb-0", part: heading2 }, "Bank Account Info"), h("form-control-tooltip", { helpText: "This direct deposit account is the designated bank account where incoming funds will be deposited. The name of this account must match the registered business name exactly. We are not able to accept personal accounts unless your business is a registered sole proprietorship." })), h("hr", { class: "mt-2" }), this.country === CountryCode.CAN ? (h("bank-account-form-inputs-canada", { defaultValue: bankAccountDefaultValue, errors: this.errors, inputHandler: this.inputHandler, formDisabled: this.existingBankAccount })) : (h("bank-account-form-inputs", { defaultValue: bankAccountDefaultValue, errors: this.errors, inputHandler: this.inputHandler, formDisabled: this.existingBankAccount }))), h("fieldset", { class: "mt-4" }, h("div", { class: "d-flex align-items-center gap-2" }, h("legend", { class: "mb-0", part: heading2 }, "Document Uploads"), h("form-control-tooltip", { helpText: "One document (voided check or bank statement) is required for underwriting purposes. It needs to visibly show the name tied to the account and the account number. Various file formats such as PDF, DOC, DOCX, JPEG are accepted. Multiple files can be uploaded for each document category." })), h("hr", { class: "mt-2" }), h("business-documents-on-file", { documents: this.existingDocuments, isLoading: this.isLoading }), h("bank-account-document-form-inputs", { inputHandler: this.inputHandler, errors: this.errors, storeFiles: this.storeFiles }))));
-    }
-    static get is() { return "justifi-business-bank-account-form-step-core"; }
-    static get properties() {
-        return {
-            "businessId": {
-                "type": "string",
-                "mutable": false,
-                "complexType": {
-                    "original": "string",
-                    "resolved": "string",
-                    "references": {}
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "getter": false,
-                "setter": false,
-                "reflect": false,
-                "attribute": "business-id"
-            },
-            "getBusiness": {
-                "type": "unknown",
-                "mutable": false,
-                "complexType": {
-                    "original": "Function",
-                    "resolved": "Function",
-                    "references": {
-                        "Function": {
-                            "location": "global",
-                            "id": "global::Function"
-                        }
-                    }
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "getter": false,
-                "setter": false
-            },
-            "postBankAccount": {
-                "type": "unknown",
-                "mutable": false,
-                "complexType": {
-                    "original": "Function",
-                    "resolved": "Function",
-                    "references": {
-                        "Function": {
-                            "location": "global",
-                            "id": "global::Function"
-                        }
-                    }
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "getter": false,
-                "setter": false
-            },
-            "postDocumentRecord": {
-                "type": "unknown",
-                "mutable": false,
-                "complexType": {
-                    "original": "Function",
-                    "resolved": "Function",
-                    "references": {
-                        "Function": {
-                            "location": "global",
-                            "id": "global::Function"
-                        }
-                    }
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "getter": false,
-                "setter": false
-            },
-            "allowOptionalFields": {
-                "type": "boolean",
-                "mutable": false,
-                "complexType": {
-                    "original": "boolean",
-                    "resolved": "boolean",
-                    "references": {}
-                },
-                "required": false,
-                "optional": true,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "getter": false,
-                "setter": false,
-                "reflect": false,
-                "attribute": "allow-optional-fields"
-            },
-            "country": {
-                "type": "string",
-                "mutable": false,
-                "complexType": {
-                    "original": "CountryCode",
-                    "resolved": "CountryCode.CAN | CountryCode.USA",
-                    "references": {
-                        "CountryCode": {
-                            "location": "import",
-                            "path": "../../../../utils/country-codes",
-                            "id": "src/utils/country-codes.ts::CountryCode"
-                        }
-                    }
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "getter": false,
-                "setter": false,
-                "reflect": false,
-                "attribute": "country"
-            }
-        };
-    }
-    static get states() {
-        return {
-            "formController": {},
-            "errors": {},
-            "bankAccount": {},
-            "existingDocuments": {},
-            "documentData": {},
-            "isLoading": {}
-        };
-    }
-    static get events() {
-        return [{
-                "method": "stepCompleteEvent",
-                "name": "complete-form-step-event",
-                "bubbles": true,
-                "cancelable": true,
-                "composed": true,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "complexType": {
-                    "original": "ComponentFormStepCompleteEvent",
-                    "resolved": "ComponentFormStepCompleteEvent",
-                    "references": {
-                        "ComponentFormStepCompleteEvent": {
-                            "location": "import",
-                            "path": "../../../../api",
-                            "id": "src/api/index.ts::ComponentFormStepCompleteEvent"
-                        }
-                    }
-                }
-            }, {
-                "method": "errorEvent",
-                "name": "error-event",
-                "bubbles": true,
-                "cancelable": true,
-                "composed": true,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "complexType": {
-                    "original": "ComponentErrorEvent",
-                    "resolved": "ComponentErrorEvent",
-                    "references": {
-                        "ComponentErrorEvent": {
-                            "location": "import",
-                            "path": "../../../../api",
-                            "id": "src/api/index.ts::ComponentErrorEvent"
-                        }
-                    }
-                }
-            }, {
-                "method": "formLoading",
-                "name": "formLoading",
-                "bubbles": true,
-                "cancelable": true,
-                "composed": true,
-                "docs": {
-                    "tags": [],
-                    "text": ""
-                },
-                "complexType": {
-                    "original": "boolean",
-                    "resolved": "boolean",
-                    "references": {}
-                }
-            }];
-    }
-    static get methods() {
-        return {
-            "validateAndSubmit": {
-                "complexType": {
-                    "signature": "({ onSuccess }: { onSuccess: any; }) => Promise<void>",
-                    "parameters": [{
-                            "name": "__0",
-                            "type": "{ onSuccess: any; }",
-                            "docs": ""
-                        }],
-                    "references": {
-                        "Promise": {
-                            "location": "global",
-                            "id": "global::Promise"
-                        }
-                    },
-                    "return": "Promise<void>"
-                },
-                "docs": {
-                    "text": "",
-                    "tags": []
-                }
-            }
-        };
-    }
-    static get watchers() {
-        return [{
-                "propName": "isLoading",
-                "methodName": "watchHandler"
-            }];
-    }
-}