@justifi/webcomponents 6.1.0-rc.2 → 6.1.0-rc.3

package/dist/collection/components/business-forms/payment-provisioning/payment-provisioning-form-steps.js

@@ -1,14 +1,16 @@
 import { h } from "@stencil/core";
+import { CountryCode } from "../../../utils/country-codes";
 export class PaymentProvisioningFormSteps {
     constructor() {
         this.allowOptionalFields = false;
+        this.country = CountryCode.USA;
         this.componentStepMapping = {
-            0: () => h("justifi-business-core-info-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[0] = el, allowOptionalFields: this.allowOptionalFields }),
-            1: () => h("justifi-legal-address-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[1] = el, allowOptionalFields: this.allowOptionalFields }),
+            0: () => h("justifi-business-core-info-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[0] = el, allowOptionalFields: this.allowOptionalFields, country: this.country }),
+            1: () => h("justifi-legal-address-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[1] = el, allowOptionalFields: this.allowOptionalFields, country: this.country }),
             2: () => h("justifi-additional-questions-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[2] = el, allowOptionalFields: this.allowOptionalFields }),
-            3: () => h("justifi-business-representative-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[3] = el, allowOptionalFields: this.allowOptionalFields }),
-            4: () => h("justifi-business-owners-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[4] = el, allowOptionalFields: this.allowOptionalFields }),
-            5: () => h("justifi-business-bank-account-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[5] = el, allowOptionalFields: this.allowOptionalFields }),
+            3: () => h("justifi-business-representative-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[3] = el, allowOptionalFields: this.allowOptionalFields, country: this.country }),
+            4: () => h("justifi-business-owners-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[4] = el, allowOptionalFields: this.allowOptionalFields, country: this.country }),
+            5: () => h("justifi-business-bank-account-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[5] = el, allowOptionalFields: this.allowOptionalFields, country: this.country }),
             6: () => h("justifi-business-terms-conditions-form-step", { businessId: this.businessId, authToken: this.authToken, ref: (el) => this.refs[6] = el, onFormLoading: this.handleFormLoading, allowOptionalFields: this.allowOptionalFields }),
         };
     }
@@ -16,14 +18,13 @@ export class PaymentProvisioningFormSteps {
         return this.componentStepMapping[this.currentStep]();
     }
     render() {
-        return (h("div", { key: 'bc4e1cd4a04dc6f0d9338fa737b91fe1628ed2b3', class: 'col-12 mb-4' }, this.currentStepComponent));
+        return (h("div", { key: '2e1d2983f259fd9fe4e1dda9c1f442b248f4c5ba', class: 'col-12 mb-4' }, this.currentStepComponent));
     }
     static get is() { return "justifi-payment-provisioning-form-steps"; }
     static get properties() {
         return {
             "businessId": {
                 "type": "string",
-                "attribute": "business-id",
                 "mutable": false,
                 "complexType": {
                     "original": "string",
@@ -38,11 +39,11 @@ export class PaymentProvisioningFormSteps {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false
+                "reflect": false,
+                "attribute": "business-id"
             },
             "authToken": {
                 "type": "string",
-                "attribute": "auth-token",
                 "mutable": false,
                 "complexType": {
                     "original": "string",
@@ -57,11 +58,11 @@ export class PaymentProvisioningFormSteps {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false
+                "reflect": false,
+                "attribute": "auth-token"
             },
             "refs": {
                 "type": "unknown",
-                "attribute": "refs",
                 "mutable": false,
                 "complexType": {
                     "original": "any[]",
@@ -79,7 +80,6 @@ export class PaymentProvisioningFormSteps {
             },
             "currentStep": {
                 "type": "number",
-                "attribute": "current-step",
                 "mutable": false,
                 "complexType": {
                     "original": "number",
@@ -94,11 +94,11 @@ export class PaymentProvisioningFormSteps {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false
+                "reflect": false,
+                "attribute": "current-step"
             },
             "allowOptionalFields": {
                 "type": "boolean",
-                "attribute": "allow-optional-fields",
                 "mutable": false,
                 "complexType": {
                     "original": "boolean",
@@ -114,11 +114,37 @@ export class PaymentProvisioningFormSteps {
                 "getter": false,
                 "setter": false,
                 "reflect": false,
+                "attribute": "allow-optional-fields",
                 "defaultValue": "false"
             },
+            "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": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "country",
+                "defaultValue": "CountryCode.USA"
+            },
             "handleFormLoading": {
                 "type": "unknown",
-                "attribute": "handle-form-loading",
                 "mutable": false,
                 "complexType": {
                     "original": "(e: CustomEvent) => void",

package/dist/collection/components/business-forms/payment-provisioning/payment-provisioning.js

@@ -46,7 +46,7 @@ export class PaymentProvisioning {
         }
     }
     render() {
-        return (h("justifi-payment-provisioning-core", { key: '4d0da0feba2d6786e696f6cc9e286d77e6aca8f1', businessId: this.businessId, authToken: this.authToken, allowOptionalFields: this.allowOptionalFields, formTitle: this.formTitle, getBusiness: this.getBusiness, postProvisioning: this.postProvisioning }));
+        return (h("justifi-payment-provisioning-core", { key: '41e96a931c082212f43bdd84dd5c948fac1eddfc', businessId: this.businessId, authToken: this.authToken, allowOptionalFields: this.allowOptionalFields, formTitle: this.formTitle, getBusiness: this.getBusiness, postProvisioning: this.postProvisioning }));
     }
     static get is() { return "justifi-payment-provisioning"; }
     static get encapsulation() { return "shadow"; }
@@ -54,7 +54,6 @@ export class PaymentProvisioning {
         return {
             "businessId": {
                 "type": "string",
-                "attribute": "business-id",
                 "mutable": false,
                 "complexType": {
                     "original": "string",
@@ -69,11 +68,11 @@ export class PaymentProvisioning {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false
+                "reflect": false,
+                "attribute": "business-id"
             },
             "authToken": {
                 "type": "string",
-                "attribute": "auth-token",
                 "mutable": false,
                 "complexType": {
                     "original": "string",
@@ -88,11 +87,11 @@ export class PaymentProvisioning {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false
+                "reflect": false,
+                "attribute": "auth-token"
             },
             "allowOptionalFields": {
                 "type": "boolean",
-                "attribute": "allow-optional-fields",
                 "mutable": false,
                 "complexType": {
                     "original": "boolean",
@@ -108,11 +107,11 @@ export class PaymentProvisioning {
                 "getter": false,
                 "setter": false,
                 "reflect": false,
+                "attribute": "allow-optional-fields",
                 "defaultValue": "false"
             },
             "formTitle": {
                 "type": "string",
-                "attribute": "form-title",
                 "mutable": false,
                 "complexType": {
                     "original": "string",
@@ -128,6 +127,7 @@ export class PaymentProvisioning {
                 "getter": false,
                 "setter": false,
                 "reflect": false,
+                "attribute": "form-title",
                 "defaultValue": "'Business Information'"
             }
         };

package/dist/collection/components/business-forms/payment-provisioning/terms-and-conditions/business-terms-conditions-form-step.js

@@ -108,14 +108,13 @@ export class BusinessTermsConditionsFormStep {
         return (h("a", { href: "https://justifi.tech/merchant-agreement/", target: "_blank", rel: "noopener noreferrer" }, "merchant agreement"));
     }
     render() {
-        return (h("form", { key: 'ed3e493e5c53e303c98e97a15149cffd2865de47' }, h("fieldset", { key: 'a4be899152d7930c2e5ac8b384f866ba313a434f' }, h("legend", { key: '6b473d236380c13ec4186cb5088f976349f18e7c', part: heading2 }, "Terms and Conditions"), h("hr", { key: '4ef52973bed72265e0ef29f0ac6e7a0ac1142f8a' }), h("div", { key: '621d89594d6335d10a746af628ce85df0bf4a71f' }, h("p", { key: '2f13e9851fdfa4b8f678de19261e7df7a7968cc0' }, "Please read and accept the ", this.merchantAgreementLink, " to submit your provisioning request.")), h("br", { key: '7951565f2ad57491cbba0d05d650eb0aea1aea54' }), h("div", { key: 'e7d727efbd5d732b31746d3cc61eeaf9eb4b1ff6', class: "row-gy-3" }, h("div", { key: 'b6d8d501530fbe4de7c11eb46218c618a7aec26f', class: "col-12" }, h("form-control-checkbox", { key: '79030af1a43bc5d1742726b8ea66d6dda3306473', name: "accepted", label: "I agree to the terms and conditions", inputHandler: this.inputHandler, errorText: this.errors.accepted, disabled: this.acceptedTermsBefore, helpText: this.formHelperText, checked: this.acceptedTerms }))))));
+        return (h("form", { key: '6fbccc271d16cbb87d8845b06b58fd461e18f770' }, h("fieldset", { key: 'ce5240753aefdb4aa92aa3ba5af4741466702ae6' }, h("legend", { key: '01a3a99f6d9dfe45ae12eb2a603ebc70a25747be', part: heading2 }, "Terms and Conditions"), h("hr", { key: 'b0209b2df034353f663cf4dde25fee51e2906dc4' }), h("div", { key: '1ed270526bc1f6d24d81c485ea6e9459607bac3e' }, h("p", { key: '8c98f939d4db12cad7169debc71fd0ad652cc724' }, "Please read and accept the ", this.merchantAgreementLink, " to submit your provisioning request.")), h("br", { key: '021ffcc28e65e59d8fb81a8a2507cac1ce0d448f' }), h("div", { key: 'e6181b2a5ad6b01be123962bf17282cb1f97fd30', class: "row-gy-3" }, h("div", { key: '82acd8dcfed625e051b93bb8845fb9d11b5e26ce', class: "col-12" }, h("form-control-checkbox", { key: 'c246a348366354dce60ec4dc00e3a4791281a584', name: "accepted", label: "I agree to the terms and conditions", inputHandler: this.inputHandler, errorText: this.errors.accepted, disabled: this.acceptedTermsBefore, helpText: this.formHelperText, checked: this.acceptedTerms }))))));
     }
     static get is() { return "justifi-business-terms-conditions-form-step"; }
     static get properties() {
         return {
             "authToken": {
                 "type": "string",
-                "attribute": "auth-token",
                 "mutable": false,
                 "complexType": {
                     "original": "string",
@@ -130,11 +129,11 @@ export class BusinessTermsConditionsFormStep {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false
+                "reflect": false,
+                "attribute": "auth-token"
             },
             "businessId": {
                 "type": "string",
-                "attribute": "business-id",
                 "mutable": false,
                 "complexType": {
                     "original": "string",
@@ -149,11 +148,11 @@ export class BusinessTermsConditionsFormStep {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false
+                "reflect": false,
+                "attribute": "business-id"
             },
             "allowOptionalFields": {
                 "type": "boolean",
-                "attribute": "allow-optional-fields",
                 "mutable": false,
                 "complexType": {
                     "original": "boolean",
@@ -168,7 +167,8 @@ export class BusinessTermsConditionsFormStep {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false
+                "reflect": false,
+                "attribute": "allow-optional-fields"
             }
         };
     }

package/dist/collection/components/business-forms/payment-provisioning/test/mockBusiness.js

@@ -0,0 +1,52 @@
+import { Business } from "../../../../api/Business";
+/**
+ * Creates mock business data with 2-character country codes (as they come from API)
+ * This allows us to test the normalization that happens in the Business constructor
+ */
+export const createMockBusinessData = (countryCode) => ({
+    additional_questions: {},
+    associated_accounts: [],
+    classification: 'corporation',
+    bank_accounts: [],
+    created_at: '2023-01-01',
+    documents: [],
+    doing_business_as: 'Test Business',
+    email: 'test@example.com',
+    id: 'biz_123',
+    industry: 'technology',
+    legal_address: {
+        line1: '123 Main St',
+        city: 'Test City',
+        state: 'CA',
+        postal_code: '12345',
+        country: countryCode, // This will be normalized by Business constructor
+    },
+    legal_name: 'Test Business LLC',
+    metadata: {},
+    owners: [],
+    phone: '555-555-5555',
+    platform_account_id: 'pa_123',
+    product_categories: {
+        credit: false,
+        insurance: false,
+        lending: false,
+        payment: true,
+    },
+    representative: null,
+    tax_id: null,
+    tax_id_last4: '1234',
+    terms_conditions_accepted: false,
+    updated_at: '2023-01-01',
+    website_url: 'https://example.com',
+    date_of_incorporation: '2020-01-01',
+    country_of_establishment: countryCode, // This will be normalized
+});
+/**
+ * Helper to get normalized country codes as they would appear in real usage
+ * This simulates what happens when the Business constructor processes API data
+ */
+export const getNormalizedCountry = (inputCountryCode) => {
+    const mockBusiness = createMockBusinessData(inputCountryCode);
+    const business = new Business(mockBusiness);
+    return business.country_of_establishment;
+};

package/dist/collection/components/business-forms/schemas/business-address-schema.js

@@ -1,21 +1,43 @@
 import { object, string } from "yup";
-import { cityValidation, lineOneValidation, lineTwoValidation, postalValidation, stateValidation } from "./schema-validations";
-export const addressSchema = (allowOptionalFields) => {
-    const schema = object({
-        line1: lineOneValidation.required('Enter street address'),
-        line2: lineTwoValidation.nullable(),
-        city: cityValidation.required('Enter city'),
-        state: stateValidation.required('Select state'),
-        postal_code: postalValidation.required('Enter postal code'),
-        country: string().required('Select country')
-    });
-    const easySchema = object({
-        line1: lineOneValidation.nullable(),
-        line2: lineTwoValidation.nullable(),
-        city: cityValidation.nullable(),
-        state: stateValidation.nullable(),
-        postal_code: postalValidation.nullable(),
-        country: string().required('Select country')
-    });
-    return allowOptionalFields ? easySchema : schema;
+import { cityValidation, lineOneValidation, lineTwoValidation, postalValidation, makePostalValidation, } from "./schema-validations";
+import { CountryCode } from "../../../utils/country-codes";
+// Internal USA schemas
+const schemaUSA = () => object({
+    line1: lineOneValidation.nullable(),
+    line2: lineTwoValidation.nullable(),
+    city: cityValidation.nullable(),
+    state: string().nullable(),
+    postal_code: string().nullable(),
+});
+const strictSchemaUSA = () => object({
+    line1: lineOneValidation.required('Enter street address'),
+    line2: lineTwoValidation.nullable(),
+    city: cityValidation.required('Enter city'),
+    state: string().required('Select state'),
+    postal_code: postalValidation.required('Enter postal code'),
+});
+// Internal CAN schemas
+const schemaCAN = () => object({
+    line1: lineOneValidation.nullable(),
+    line2: lineTwoValidation.nullable(),
+    city: cityValidation.nullable(),
+    state: string().nullable(),
+    postal_code: string().nullable(),
+});
+const strictSchemaCAN = () => object({
+    line1: lineOneValidation.required('Enter street address'),
+    line2: lineTwoValidation.nullable(),
+    city: cityValidation.required('Enter city'),
+    state: string().required('Select province'),
+    postal_code: makePostalValidation(CountryCode.CAN).required('Enter postal code'),
+});
+// Public API
+export const addressSchemaUSA = (allowOptionalFields) => allowOptionalFields ? schemaUSA() : strictSchemaUSA();
+export const addressSchemaCAN = (allowOptionalFields) => allowOptionalFields ? schemaCAN() : strictSchemaCAN();
+// For Backward compatibility
+export const addressSchema = (allowOptionalFields) => addressSchemaUSA(allowOptionalFields);
+// Country-keyed mapping
+export const addressSchemaByCountry = {
+    [CountryCode.USA]: addressSchemaUSA,
+    [CountryCode.CAN]: addressSchemaCAN,
 };

package/dist/collection/components/business-forms/schemas/business-bank-account-schema.js

@@ -1,53 +1,88 @@
-import { object, mixed } from "yup";
+import { object, mixed, string } from "yup";
+import { CountryCode } from "../../../utils/country-codes";
 import { EntityDocumentType } from "../../../api/Document";
-import { accountNumberValidation, accountTypeValidation, bankNameValidation, identityNameValidation, nicknameValidation, routingNumberValidation } from "./schema-validations";
+import { accountNumberValidation, accountTypeValidation, bankNameValidation, identityNameValidation, nicknameValidation, routingNumberValidation, } from "./schema-validations";
+import { numbersOnlyRegex } from "./schema-helpers";
 const checkExistingDocs = (documents, documentType) => {
     return documents.some((doc) => doc.document_type === documentType);
 };
-const documentErrorText = 'Please upload either a voided check or a bank statement. Only one is required.';
-export const businessBankAccountSchema = (documents, allowOptionalFields) => {
-    const existingVoidedCheck = checkExistingDocs(documents, EntityDocumentType.voidedCheck);
-    const existingBankStatement = checkExistingDocs(documents, EntityDocumentType.bankStatement);
-    const existingDocument = existingVoidedCheck || existingBankStatement;
-    const schema = object().shape({
+const buildCommonFieldRules = (allowOptionalFields) => {
+    if (allowOptionalFields) {
+        return {
+            bank_name: bankNameValidation.nullable(),
+            nickname: nicknameValidation.nullable(),
+            account_owner_name: identityNameValidation.nullable(),
+            account_type: accountTypeValidation.nullable(),
+            account_number: accountNumberValidation.nullable(),
+        };
+    }
+    return {
         bank_name: bankNameValidation.required('Enter bank name'),
         nickname: nicknameValidation.required('Enter nickname'),
         account_owner_name: identityNameValidation.required('Enter account owner name'),
         account_type: accountTypeValidation.required('Select account type'),
         account_number: accountNumberValidation.required('Enter account number'),
-        routing_number: routingNumberValidation.required('Enter routing number'),
+    };
+};
+const buildDocumentRules = (documents, allowOptionalFields) => {
+    if (allowOptionalFields) {
+        return {
+            voided_check: mixed().nullable(),
+            bank_statement: mixed().nullable(),
+        };
+    }
+    const existingVoidedCheck = checkExistingDocs(documents, EntityDocumentType.voidedCheck);
+    const existingBankStatement = checkExistingDocs(documents, EntityDocumentType.bankStatement);
+    const existingDocument = existingVoidedCheck || existingBankStatement;
+    const documentErrorText = 'Please upload either a voided check or a bank statement. Only one is required.';
+    return {
         voided_check: mixed().when('bank_statement', {
-            is: (val) => {
-                return !val && !existingDocument;
-            },
-            then: (schema) => {
-                return schema.required(documentErrorText);
-            },
-            otherwise: (schema) => {
-                return schema.notRequired();
-            }
+            is: (val) => !val && !existingDocument,
+            then: (schema) => schema.required(documentErrorText),
+            otherwise: (schema) => schema.notRequired(),
         }),
         bank_statement: mixed().when('voided_check', {
-            is: (val) => {
-                return !val && !existingDocument;
-            },
-            then: (schema) => {
-                return schema.required(documentErrorText);
-            },
-            otherwise: (schema) => {
-                return schema.notRequired();
-            }
+            is: (val) => !val && !existingDocument,
+            then: (schema) => schema.required(documentErrorText),
+            otherwise: (schema) => schema.notRequired(),
         }),
-    }, [['voided_check', 'bank_statement']]);
-    const easySchema = object({
-        bank_name: bankNameValidation.nullable(),
-        nickname: nicknameValidation.nullable(),
-        account_owner_name: identityNameValidation.nullable(),
-        account_type: accountTypeValidation.nullable(),
-        account_number: accountNumberValidation.nullable(),
-        routing_number: routingNumberValidation.nullable(),
-        voided_check: mixed().nullable(),
-        bank_statement: mixed().nullable(),
-    });
-    return allowOptionalFields ? easySchema : schema;
+    };
+};
+const buildUSARules = (allowOptionalFields) => {
+    if (allowOptionalFields) {
+        return { routing_number: routingNumberValidation.nullable() };
+    }
+    return { routing_number: routingNumberValidation.required('Enter routing number') };
+};
+const buildCANRules = (allowOptionalFields) => {
+    const institutionNumberValidation = string()
+        .length(3, 'Institution number must be 3 digits')
+        .matches(numbersOnlyRegex, 'Enter valid institution number');
+    const transitNumberValidation = string()
+        .length(5, 'Transit number must be 5 digits')
+        .matches(numbersOnlyRegex, 'Enter valid transit number');
+    if (allowOptionalFields) {
+        return {
+            institution_number: institutionNumberValidation.nullable(),
+            transit_number: transitNumberValidation.nullable(),
+        };
+    }
+    return {
+        institution_number: institutionNumberValidation.required('Enter institution number'),
+        transit_number: transitNumberValidation.required('Enter transit number'),
+    };
+};
+export const businessBankAccountSchemaUSA = (documents, allowOptionalFields) => {
+    const shape = Object.assign(Object.assign(Object.assign({}, buildCommonFieldRules(allowOptionalFields)), buildUSARules(allowOptionalFields)), buildDocumentRules(documents, allowOptionalFields));
+    return object().shape(shape, [['voided_check', 'bank_statement']]);
+};
+export const businessBankAccountSchemaCAN = (documents, allowOptionalFields) => {
+    const shape = Object.assign(Object.assign(Object.assign({}, buildCommonFieldRules(allowOptionalFields)), buildCANRules(allowOptionalFields)), buildDocumentRules(documents, allowOptionalFields));
+    return object().shape(shape, [['voided_check', 'bank_statement']]);
+};
+// For backward compatibility, default to USA
+export const businessBankAccountSchema = (documents, allowOptionalFields) => businessBankAccountSchemaUSA(documents, allowOptionalFields);
+export const bankAccountSchemaByCountry = {
+    [CountryCode.USA]: (allowOptionalFields, documents = []) => businessBankAccountSchemaUSA(documents, allowOptionalFields),
+    [CountryCode.CAN]: (allowOptionalFields, documents = []) => businessBankAccountSchemaCAN(documents, allowOptionalFields),
 };

package/dist/collection/components/business-forms/schemas/business-core-info-schema.js

@@ -1,6 +1,9 @@
-import { object } from "yup";
-import { doingBusinessAsValidation, emailValidation, industryValidation, businessNameValidation, phoneValidation, taxIdValidation, websiteUrlValidation, dateOfIncorporationValidation, businessClassificationValidation } from "./schema-validations";
-export const businessCoreInfoSchema = (allowOptionalFields) => {
+import { object, string } from "yup";
+import { doingBusinessAsValidation, emailValidation, industryValidation, businessNameValidation, phoneValidation, taxIdValidation, websiteUrlValidation, dateOfIncorporationValidation, businessClassificationValidation, makeTaxIdValidation } from "./schema-validations";
+import { CountryCode } from "../../../utils/country-codes";
+import { countryLabels } from "../utils/country-config";
+// Base schema (no country-specific rules for classification/tax id)
+export const baseBusinessCoreInfoSchema = (allowOptionalFields) => {
     const schema = object({
         legal_name: businessNameValidation.required('Enter legal name'),
         website_url: websiteUrlValidation.required('Enter business website url'),
@@ -9,7 +12,6 @@ export const businessCoreInfoSchema = (allowOptionalFields) => {
         doing_business_as: doingBusinessAsValidation.nullable(),
         classification: businessClassificationValidation.required('Select business classification'),
         industry: industryValidation.required('Enter a business industry'),
-        tax_id: taxIdValidation.required('Enter valid tax ID (SSN or EIN) without dashes'),
         date_of_incorporation: dateOfIncorporationValidation.required('Enter date of incorporation'),
     });
     const easySchema = object({
@@ -25,3 +27,24 @@ export const businessCoreInfoSchema = (allowOptionalFields) => {
     });
     return allowOptionalFields ? easySchema : schema;
 };
+// Country-specific schema convenience wrappers
+export const businessCoreInfoSchemaUSA = (allowOptionalFields) => baseBusinessCoreInfoSchema(allowOptionalFields).concat(object({
+    classification: string().required('Select business classification'),
+    tax_id: makeTaxIdValidation(CountryCode.USA)
+        .when('tax_id_last4', {
+        is: (val) => !val,
+        then: (schema) => schema.required(`Enter valid ${countryLabels.USA.taxIdLabel} without dashes`),
+        otherwise: (schema) => schema.nullable(),
+    }),
+}));
+export const businessCoreInfoSchemaCAN = (allowOptionalFields) => baseBusinessCoreInfoSchema(allowOptionalFields).concat(object({
+    classification: string().required('Select business classification'),
+    tax_id: makeTaxIdValidation(CountryCode.CAN)
+        .when('tax_id_last4', {
+        is: (val) => !val,
+        then: (schema) => schema.required(`Enter valid ${countryLabels.CAN.taxIdLabel} without dashes`),
+        otherwise: (schema) => schema.nullable(),
+    }),
+}));
+// For backward compatibility, default to USA
+export const businessCoreInfoSchema = (allowOptionalFields) => businessCoreInfoSchemaUSA(allowOptionalFields);

package/dist/collection/components/business-forms/schemas/business-form-schema.js

@@ -1,6 +1,9 @@
 import { object } from "yup";
-import { businessCoreInfoSchema } from "./business-core-info-schema";
+import { businessCoreInfoSchemaUSA, businessCoreInfoSchemaCAN } from "./business-core-info-schema";
 import { additionalQuestionsSchema } from "./business-additional-questions-schema";
-import { identitySchema } from "./business-identity-schema";
-import { addressSchema } from "./business-address-schema";
-export const businessFormSchema = object(Object.assign(Object.assign({}, businessCoreInfoSchema().fields), { legal_address: addressSchema(), additional_questions: additionalQuestionsSchema(), representative: identitySchema('representative') }));
+import { identitySchemaUSA, identitySchemaCAN } from "./business-identity-schema";
+import { addressSchemaUSA, addressSchemaCAN } from "./business-address-schema";
+export const businessFormSchemaUSA = object(Object.assign(Object.assign({}, businessCoreInfoSchemaUSA().fields), { legal_address: addressSchemaUSA(), additional_questions: additionalQuestionsSchema(), representative: identitySchemaUSA('representative') }));
+export const businessFormSchemaCAN = object(Object.assign(Object.assign({}, businessCoreInfoSchemaCAN().fields), { legal_address: addressSchemaCAN(), additional_questions: additionalQuestionsSchema(), representative: identitySchemaCAN('representative') }));
+// For backward compatibility, default to USA
+export const businessFormSchema = businessFormSchemaUSA;

package/dist/collection/components/business-forms/schemas/business-identity-schema.js

@@ -1,26 +1,55 @@
 import { object, string } from "yup";
-import { addressSchema } from "./business-address-schema";
-import { dobValidation, emailValidation, identityNameValidation, identityTitleValidation, phoneValidation, ssnValidation } from "./schema-validations";
-export const identitySchema = (role, allowOptionalFields) => {
-    const schema = object({
-        name: identityNameValidation.required(`Enter ${role} name`),
-        title: identityTitleValidation.required(`Enter ${role} title`),
-        email: emailValidation.required(`Enter ${role} email`),
-        phone: phoneValidation.required('Enter phone number'),
-        dob_full: dobValidation(role).required('Enter date of birth'),
-        ssn_last4: string().nullable(),
-        identification_number: ssnValidation,
-        address: addressSchema(allowOptionalFields),
-    });
-    const easySchema = object({
-        name: identityNameValidation.required(`Enter ${role} name`),
-        title: identityTitleValidation.nullable(),
-        email: emailValidation.nullable(),
-        phone: phoneValidation.nullable(),
-        dob_full: dobValidation(role).nullable(),
-        ssn_last4: string().nullable(),
-        identification_number: ssnValidation.nullable(),
-        address: addressSchema(allowOptionalFields),
-    });
-    return allowOptionalFields ? easySchema : schema;
+import { addressSchemaUSA, addressSchemaCAN } from "./business-address-schema";
+import { dobValidation, emailValidation, identityNameValidation, identityTitleValidation, phoneValidation, ssnValidation, makeIdentityNumberValidation, } from "./schema-validations";
+import { CountryCode } from "../../../utils/country-codes";
+// Internal USA schemas
+const schemaUSA = (role) => object({
+    name: identityNameValidation.required(`Enter ${role} name`),
+    title: identityTitleValidation.nullable(),
+    email: emailValidation.nullable(),
+    phone: phoneValidation.nullable(),
+    dob_full: dobValidation(role).nullable(),
+    ssn_last4: string().nullable(),
+    identification_number: ssnValidation.nullable(),
+    address: addressSchemaUSA(true),
+});
+const strictSchemaUSA = (role) => object({
+    name: identityNameValidation.required(`Enter ${role} name`),
+    title: identityTitleValidation.required(`Enter ${role} title`),
+    email: emailValidation.required(`Enter ${role} email`),
+    phone: phoneValidation.required('Enter phone number'),
+    dob_full: dobValidation(role).required('Enter date of birth'),
+    ssn_last4: string().nullable(),
+    // ssn required unless last4 provided (handled inside ssnValidation)
+    identification_number: ssnValidation,
+    address: addressSchemaUSA(false),
+});
+// Internal CAN schemas
+const schemaCAN = (role) => object({
+    name: identityNameValidation.required(`Enter ${role} name`),
+    title: identityTitleValidation.nullable(),
+    email: emailValidation.nullable(),
+    phone: phoneValidation.nullable(),
+    dob_full: dobValidation(role).nullable(),
+    identification_number: makeIdentityNumberValidation(CountryCode.CAN).nullable(),
+    address: addressSchemaCAN(true),
+});
+const strictSchemaCAN = (role) => object({
+    name: identityNameValidation.required(`Enter ${role} name`),
+    title: identityTitleValidation.required(`Enter ${role} title`),
+    email: emailValidation.required(`Enter ${role} email`),
+    phone: phoneValidation.required('Enter phone number'),
+    dob_full: dobValidation(role).required('Enter date of birth'),
+    identification_number: makeIdentityNumberValidation(CountryCode.CAN)
+        .required('Enter identification number'),
+    address: addressSchemaCAN(false),
+});
+export const identitySchemaUSA = (role, allowOptionalFields) => allowOptionalFields ? schemaUSA(role) : strictSchemaUSA(role);
+export const identitySchemaCAN = (role, allowOptionalFields) => allowOptionalFields ? schemaCAN(role) : strictSchemaCAN(role);
+// For backward compatibility, default to USA
+export const identitySchema = (role, allowOptionalFields) => identitySchemaUSA(role, allowOptionalFields);
+// Country-keyed mapping
+export const identitySchemaByCountry = {
+    [CountryCode.USA]: identitySchemaUSA,
+    [CountryCode.CAN]: identitySchemaCAN,
 };