@mychoice/mychoice-sdk-store 2.2.9 → 2.2.11

package/dist/cjs/index.js

@@ -6712,6 +6712,723 @@ const useValidationLifeApplicant = () => {
     };
 };
 
+// Province code to name mapping
+const PROVINCE_NAME_MAP = {
+    ON: 'Ontario',
+    AB: 'Alberta',
+    NS: 'Nova Scotia',
+    NF: 'Newfoundland',
+    NB: 'New Brunswick',
+    BC: 'British Columbia',
+    SK: 'Saskatchewan',
+    MB: 'Manitoba',
+};
+/**
+ * Parse URL-encoded JSON from query parameter
+ */
+const parseAutofillParam = (urlEncodedJson) => {
+    const decoded = decodeURIComponent(urlEncodedJson);
+    return JSON.parse(decoded);
+};
+/**
+ * Get province name from code
+ */
+const getProvinceName = (code) => {
+    return PROVINCE_NAME_MAP[code] || code;
+};
+/**
+ * Map autofill data to postal state format
+ */
+const mapToPostalState = (autofillData) => {
+    const firstVehicle = autofillData.vehicles[0];
+    return {
+        city: firstVehicle.city || '',
+        postalCode: firstVehicle.postal_code || '',
+        locationIndex: String(firstVehicle.location_index || ''),
+        provinceCode: autofillData.province_code || '',
+        provinceName: getProvinceName(autofillData.province_code || ''),
+    };
+};
+/**
+ * Map autofill data to vehicle state format
+ */
+const mapToVehicleState = (autofillData) => {
+    const firstVehicle = autofillData.vehicles[0];
+    return {
+        year: String(firstVehicle.year || ''),
+        make: firstVehicle.make || '',
+        model: firstVehicle.model || '',
+        condition: firstVehicle.condition || 'N',
+        leased: firstVehicle.leased || false,
+        purchaseDate: firstVehicle.purchase_date || '',
+        winterTires: firstVehicle.winter_tires || false,
+        parkingLocation: firstVehicle.parking_location || 'driveway',
+        primaryUse: firstVehicle.primary_use || 'Personal',
+        distanceDaily: firstVehicle.distance_daily || 0,
+        distanceBusiness: firstVehicle.distance_business || 0,
+        distanceYearly: firstVehicle.distance_yearly || 0,
+        comprehensive: {
+            coverage: firstVehicle.comprehensive?.coverage ?? true,
+            deductible: firstVehicle.comprehensive?.deductible ?? 1000,
+        },
+        collision: {
+            coverage: firstVehicle.collision?.coverage ?? true,
+            deductible: firstVehicle.collision?.deductible ?? 1000,
+        },
+        liability: {
+            coverage: firstVehicle.liability?.coverage ?? true,
+            limit: firstVehicle.liability?.limit ?? 1000000,
+        },
+        lossofuse: {
+            coverage: firstVehicle.lossofuse?.coverage ?? true,
+            limit: firstVehicle.lossofuse?.limit ?? 2000,
+        },
+        liabilityfordamage: {
+            coverage: firstVehicle.liabilityfordamage?.coverage ?? true,
+            limit: firstVehicle.liabilityfordamage?.limit ?? 50000,
+        },
+        limitedwaiverofdepreciation: {
+            coverage: firstVehicle.limitedwaiverofdepreciation?.coverage ?? true,
+            limit: firstVehicle.limitedwaiverofdepreciation?.limit ?? 1,
+        },
+        postalCode: firstVehicle.postal_code || '',
+        locationIndex: String(firstVehicle.location_index || ''),
+        city: firstVehicle.city || '',
+    };
+};
+/**
+ * Map autofill data to driver state format
+ */
+const mapToDriverState = (autofillData) => {
+    const firstDriver = autofillData.drivers[0];
+    return {
+        firstName: firstDriver.first_name || '',
+        dateOfBirth: firstDriver.date_of_birth || '',
+        maritalStatus: firstDriver.marital_status || '',
+        gender: firstDriver.gender || '',
+        occupation: firstDriver.occupation || 0,
+        listed: firstDriver.listed || false,
+        listedYear: firstDriver.listed_year || '',
+        insured: firstDriver.insured || false,
+        insuredYear: firstDriver.insured_year || '',
+        ticket: firstDriver.ticket || false,
+        accident: firstDriver.accident || false,
+        licenceSuspension: firstDriver.licence_suspension || false,
+        insuranceCancellation: firstDriver.insurance_cancellation || false,
+        licenceInfo: {
+            licenceType: (firstDriver.licence_info?.licence_type || '').toLowerCase(),
+            firstLicenceAge: firstDriver.licence_info?.first_licence_age || 0,
+            gLicenceDate: firstDriver.licence_info?.g_licence_date || '',
+            g1LicenceDate: firstDriver.licence_info?.g1_licence_date || '',
+            g2LicenceDate: firstDriver.licence_info?.g2_licence_date || '',
+        },
+    };
+};
+/**
+ * Map autofill data to config state format
+ */
+const mapToConfigState = (autofillData) => {
+    return {
+        province: autofillData.province_code || '',
+    };
+};
+// Life insurance autofill utilities
+// State number to province code mapping (reverse of stateMapper in LifeQuoteDataHandler)
+const STATE_TO_PROVINCE_CODE_MAP = {
+    '1': 'AB',
+    '2': 'BC',
+    '3': 'MB',
+    '4': 'NB',
+    '5': 'NF',
+    '6': 'NS',
+    '7': 'NT',
+    '9': 'ON',
+    '10': 'PE',
+    '11': 'QC',
+    '12': 'SK',
+    '13': 'YT',
+};
+/**
+ * Parse URL-encoded JSON from query parameter for life insurance
+ */
+const parseLifeAutofillParam = (urlEncodedJson) => {
+    const decoded = decodeURIComponent(urlEncodedJson);
+    return JSON.parse(decoded);
+};
+/**
+ * Get province code from state number
+ */
+const getProvinceCodeFromState = (stateNumber) => {
+    return STATE_TO_PROVINCE_CODE_MAP[stateNumber] || '';
+};
+/**
+ * Map life autofill data to coverage state format
+ */
+const mapToLifeCoverageState = (autofillData) => {
+    const provinceCode = getProvinceCodeFromState(autofillData.State || '');
+    return {
+        province: provinceCode,
+        type: autofillData.NewCategory || '',
+        coverage: String(autofillData.FaceAmount || ''),
+        postalCode: autofillData.PostalCode || '',
+        city: autofillData.City || '',
+    };
+};
+/**
+ * Map life autofill data to applicant state format
+ */
+const mapToLifeApplicantState = (autofillData) => {
+    return {
+        birthYear: autofillData.BirthYear || '',
+        birthMonth: autofillData.BirthMonth || '',
+        birthDay: autofillData.Birthday || '',
+        gender: autofillData.Sex || 'M',
+        smoker: autofillData.Smoker === 'Y',
+        emailTo: {
+            email: autofillData.email_to || '',
+        },
+        quoterInfo: {
+            firstName: autofillData.quoter_info?.first_name || '',
+            lastName: autofillData.quoter_info?.last_name || '',
+            phone: autofillData.quoter_info?.phone ? String(autofillData.quoter_info.phone) : '',
+            utmSource: autofillData.quoter_info?.utm_source || '',
+            utmCampaign: autofillData.quoter_info?.utm_campaign || '',
+        },
+    };
+};
+/**
+ * Map life autofill data to postal state format
+ */
+const mapToLifePostalState = (autofillData) => {
+    const provinceCode = getProvinceCodeFromState(autofillData.State || '');
+    return {
+        postalCode: autofillData.PostalCode || '',
+        provinceCode,
+        provinceName: getProvinceName(provinceCode),
+        city: autofillData.City || '',
+        locationIndex: '',
+    };
+};
+
+/**
+ * Hook to initialize car insurance form with autofill data from query parameter
+ */
+const useAutofillCarForm = (options) => {
+    const { dispatchPostalState } = useStoreFormCarPostal();
+    const { dispatchVehicleState } = useStoreFormCarVehicle();
+    const { configState, dispatchConfigState } = useStoreFormCarConfig();
+    const { dispatchDriverInfoState } = useStoreFormCarDriverInfo();
+    const { dispatchDriverLicenceState } = useStoreFormCarDriverLicence();
+    const { dispatchDriverInsuranceState } = useStoreFormCarDriverInsurance();
+    const { dispatchDriverSuspensionState } = useStoreFormCarDriverSuspension();
+    const { dispatchDriverCancellationState } = useStoreFormCarDriverCancellation();
+    const { dispatchDriverAccidentState } = useStoreFormCarDriverAccident();
+    const { dispatchDriverTicketState } = useStoreFormCarDriverTicket();
+    const { getVehicleMake } = useHandlerCarMake();
+    const { getVehicleModel } = useHandlerCarModel();
+    const { dispatchAppModalState } = useStoreAppModal();
+    const autofillProcessedRef = react.useRef(false);
+    react.useEffect(() => {
+        // Prevent double execution in development strict mode
+        if (autofillProcessedRef.current) {
+            return;
+        }
+        try {
+            const urlParams = new URLSearchParams(window.location.search);
+            const autofillParam = urlParams.get('autofill');
+            if (!autofillParam) {
+                return;
+            }
+            // Parse the autofill data
+            const autofillData = parseAutofillParam(autofillParam);
+            // Dispatch postal state
+            const postalData = mapToPostalState(autofillData);
+            dispatchPostalState({
+                type: exports.StoreFormCarPostalActionTypes.FormCarPostalSet,
+                payload: postalData,
+            });
+            // Close the postal modal since we have postal data from autofill
+            dispatchAppModalState({
+                type: exports.StoreConfigAppModalActionTypes.AppModalClose,
+            });
+            // Dispatch config state
+            const configData = mapToConfigState(autofillData);
+            dispatchConfigState({
+                type: exports.StoreFormCarConfigActionTypes.FormCarConfigSet,
+                payload: configData,
+            });
+            // Dispatch vehicle state with mapped data
+            const vehicleData = mapToVehicleState(autofillData);
+            // Update the first vehicle in the form with autofill data
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarVehicleYearSet,
+                payload: {
+                    year: vehicleData.year,
+                },
+            });
+            // Update make
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarVehicleMakeSet,
+                payload: {
+                    make: vehicleData.make,
+                },
+            });
+            // Update model
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarVehicleModelSet,
+                payload: {
+                    model: vehicleData.model,
+                },
+            });
+            // Update condition
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarVehicleConditionSelect,
+                payload: {
+                    condition: vehicleData.condition,
+                },
+            });
+            // Update leased status
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarVehicleCarStatusSelect,
+                payload: {
+                    leased: vehicleData.leased,
+                },
+            });
+            // Update purchase year
+            if (vehicleData.purchaseDate) {
+                const [year, month, day] = vehicleData.purchaseDate.split('-');
+                dispatchVehicleState({
+                    type: exports.StoreFormCarVehicleActionTypes.FormCarVehiclePurchaseYearSelect,
+                    payload: {
+                        purchaseYear: year,
+                    },
+                });
+                dispatchVehicleState({
+                    type: exports.StoreFormCarVehicleActionTypes.FormCarVehiclePurchaseMonthSelect,
+                    payload: {
+                        purchaseMonth: month,
+                    },
+                });
+                dispatchVehicleState({
+                    type: exports.StoreFormCarVehicleActionTypes.FormCarVehiclePurchaseDaySelect,
+                    payload: {
+                        purchaseDay: day,
+                    },
+                });
+            }
+            // Update winter tires
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarVehicleWinterTiresSelect,
+                payload: {
+                    winterTires: vehicleData.winterTires,
+                },
+            });
+            // Update primary use
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarVehicleUsageSelect,
+                payload: {
+                    primaryUse: vehicleData.primaryUse,
+                },
+            });
+            // Update parking location
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarParkingLocationSelect,
+                payload: {
+                    parkingLocation: vehicleData.parkingLocation,
+                },
+            });
+            // Update distances
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarDailyDistanceSelect,
+                payload: {
+                    distanceDaily: String(vehicleData.distanceDaily),
+                },
+            });
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarBusinessDistanceSelect,
+                payload: {
+                    distanceBusiness: String(vehicleData.distanceBusiness),
+                },
+            });
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarYearlyDistanceSelect,
+                payload: {
+                    distanceYearly: String(vehicleData.distanceYearly),
+                },
+            });
+            // Update coverages and deductibles
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarComprehensiveCoverageSelect,
+                payload: {
+                    coverage: vehicleData.comprehensive.coverage,
+                    deductible: vehicleData.comprehensive.deductible,
+                },
+            });
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarCollisionCoverageSelect,
+                payload: {
+                    coverage: vehicleData.collision.coverage,
+                    deductible: vehicleData.collision.deductible,
+                },
+            });
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarLiabilityCoverageSelect,
+                payload: {
+                    coverage: vehicleData.liability.coverage,
+                    limit: vehicleData.liability.limit,
+                },
+            });
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarLossOfUseCoverageSelect,
+                payload: {
+                    coverage: vehicleData.lossofuse.coverage,
+                    limit: vehicleData.lossofuse.limit,
+                },
+            });
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarLiabilityForDamageCoverageSelect,
+                payload: {
+                    coverage: vehicleData.liabilityfordamage.coverage,
+                    limit: vehicleData.liabilityfordamage.limit,
+                },
+            });
+            dispatchVehicleState({
+                type: exports.StoreFormCarVehicleActionTypes.FormCarLimitedWaiverOfDepreciationCoverageSelect,
+                payload: {
+                    coverage: vehicleData.limitedwaiverofdepreciation.coverage,
+                    limit: vehicleData.limitedwaiverofdepreciation.limit,
+                },
+            });
+            // Dispatch driver state
+            const driverData = mapToDriverState(autofillData);
+            // Update driver basic info
+            dispatchDriverInfoState({
+                type: exports.StoreFormCarDriverInfoActionTypes.FormCarDriverNameSet,
+                payload: {
+                    firstName: driverData.firstName,
+                },
+            });
+            dispatchDriverInfoState({
+                type: exports.StoreFormCarDriverInfoActionTypes.FormCarDriverMaritalStatusSelect,
+                payload: {
+                    maritalStatus: driverData.maritalStatus,
+                },
+            });
+            dispatchDriverInfoState({
+                type: exports.StoreFormCarDriverInfoActionTypes.FormCarDriverGenderSelect,
+                payload: {
+                    gender: driverData.gender,
+                },
+            });
+            dispatchDriverInfoState({
+                type: exports.StoreFormCarDriverInfoActionTypes.FormCarDriverOccupationSelect,
+                payload: {
+                    occupation: driverData.occupation,
+                },
+            });
+            // Update driver birth date
+            if (driverData.dateOfBirth) {
+                const [year, month, day] = driverData.dateOfBirth.split('-');
+                dispatchDriverInfoState({
+                    type: exports.StoreFormCarDriverInfoActionTypes.FormCarDriverBirthYearSelect,
+                    payload: { birthYear: year, config: configState },
+                });
+                dispatchDriverInfoState({
+                    type: exports.StoreFormCarDriverInfoActionTypes.FormCarDriverBirthMonthSelect,
+                    payload: { birthMonth: month, config: configState },
+                });
+                dispatchDriverInfoState({
+                    type: exports.StoreFormCarDriverInfoActionTypes.FormCarDriverBirthDaySelect,
+                    payload: { birthDay: day, config: configState },
+                });
+            }
+            // Update driver licence info
+            dispatchDriverLicenceState({
+                type: exports.StoreFormCarDriverLicenceActionTypes.FormCarDriverLicenceAgeSelect,
+                payload: {
+                    firstLicenceAge: String(driverData.licenceInfo.firstLicenceAge),
+                    config: configState,
+                },
+            });
+            if (driverData.licenceInfo.licenceType) {
+                dispatchDriverLicenceState({
+                    type: exports.StoreFormCarDriverLicenceActionTypes.FormCarDriverLicenceTypeSelect,
+                    payload: {
+                        licenceType: driverData.licenceInfo.licenceType,
+                        config: configState,
+                    },
+                });
+            }
+            // Update driver insurance info
+            dispatchDriverInsuranceState({
+                type: exports.StoreFormCarDriverInsuranceActionTypes.FormCarDriverListedSelect,
+                payload: {
+                    listed: driverData.listed,
+                },
+            });
+            if (driverData.listedYear) {
+                const [year, month] = driverData.listedYear.split('-');
+                if (year) {
+                    dispatchDriverInsuranceState({
+                        type: exports.StoreFormCarDriverInsuranceActionTypes.FormCarDriverListedYearSelect,
+                        payload: { listedYear: year },
+                    });
+                }
+                if (month) {
+                    dispatchDriverInsuranceState({
+                        type: exports.StoreFormCarDriverInsuranceActionTypes.FormCarDriverListedMonthSelect,
+                        payload: { listedMonth: month },
+                    });
+                }
+            }
+            dispatchDriverInsuranceState({
+                type: exports.StoreFormCarDriverInsuranceActionTypes.FormCarDriverInsuredSelect,
+                payload: {
+                    insured: driverData.insured,
+                },
+            });
+            if (driverData.insuredYear) {
+                dispatchDriverInsuranceState({
+                    type: exports.StoreFormCarDriverInsuranceActionTypes.FormCarDriverInsuredDateSelect,
+                    payload: { insuredDate: driverData.insuredYear },
+                });
+            }
+            // Update driver suspension and cancellation status
+            dispatchDriverSuspensionState({
+                type: exports.StoreFormCarDriverSuspensionActionTypes.FormCarDriverLicenceSuspensionSelect,
+                payload: {
+                    licenceSuspension: driverData.licenceSuspension,
+                },
+            });
+            dispatchDriverCancellationState({
+                type: exports.StoreFormCarDriverCancellationActionTypes.FormCarDriverInsuranceCancellationSelect,
+                payload: {
+                    insuranceCancellation: driverData.insuranceCancellation,
+                },
+            });
+            // Update accident and ticket status
+            dispatchDriverAccidentState({
+                type: exports.StoreFormCarDriverAccidentActionTypes.FormCarDriverAccidentSelect,
+                payload: {
+                    accident: driverData.accident,
+                },
+            });
+            dispatchDriverTicketState({
+                type: exports.StoreFormCarDriverTicketActionTypes.FormCarDriverTrafficTicketSelect,
+                payload: {
+                    ticket: driverData.ticket,
+                },
+            });
+            // Pre-fetch vehicle makes for the year
+            if (vehicleData.year) {
+                getVehicleMake(vehicleData.year);
+            }
+            // Pre-fetch vehicle models for year + make
+            if (vehicleData.year && vehicleData.make) {
+                getVehicleModel(vehicleData.year, vehicleData.make);
+            }
+            autofillProcessedRef.current = true;
+            if (options?.onComplete) {
+                options.onComplete();
+            }
+        }
+        catch (error) {
+            // Silently fail - let the app continue with normal flow
+            console.error('Autofill initialization error:', error);
+        }
+    }, [
+        configState,
+        dispatchPostalState,
+        dispatchVehicleState,
+        dispatchConfigState,
+        dispatchDriverInfoState,
+        dispatchDriverLicenceState,
+        dispatchDriverInsuranceState,
+        dispatchDriverSuspensionState,
+        dispatchDriverCancellationState,
+        dispatchDriverAccidentState,
+        dispatchDriverTicketState,
+        dispatchAppModalState,
+        getVehicleMake,
+        getVehicleModel,
+    ]);
+};
+
+/**
+ * Hook to initialize life insurance form with autofill data from query parameter
+ */
+const useAutofillLifeForm = (options) => {
+    const { dispatchPostalState } = useStoreFormLifePostal();
+    const { dispatchCoverageState } = useStoreFormLifeCoverage();
+    const { dispatchApplicantState } = useStoreFormLifeApplicant();
+    const { dispatchAppModalState } = useStoreAppModal();
+    const autofillProcessedRef = react.useRef(false);
+    react.useEffect(() => {
+        // Prevent double execution in development strict mode
+        if (autofillProcessedRef.current) {
+            return;
+        }
+        try {
+            const urlParams = new URLSearchParams(window.location.search);
+            const autofillParam = urlParams.get('autofill');
+            if (!autofillParam) {
+                return;
+            }
+            // Parse the autofill data
+            const autofillData = parseLifeAutofillParam(autofillParam);
+            // Map and dispatch postal state
+            const postalData = mapToLifePostalState(autofillData);
+            dispatchPostalState({
+                type: exports.StoreFormLifePostalActionTypes.FormLifePostalSet,
+                payload: postalData,
+            });
+            // Close the postal modal since we have postal data from autofill
+            dispatchAppModalState({
+                type: exports.StoreConfigAppModalActionTypes.AppModalClose,
+            });
+            // Map and dispatch coverage state
+            const coverageData = mapToLifeCoverageState(autofillData);
+            // Dispatch province
+            dispatchCoverageState({
+                type: exports.StoreFormLifeCoverageActionTypes.FormLifeProvinceSelect,
+                payload: {
+                    province: coverageData.province,
+                },
+            });
+            // Dispatch coverage type
+            dispatchCoverageState({
+                type: exports.StoreFormLifeCoverageActionTypes.FormLifeCoverageTypeSelect,
+                payload: {
+                    type: coverageData.type,
+                },
+            });
+            // Dispatch coverage amount
+            dispatchCoverageState({
+                type: exports.StoreFormLifeCoverageActionTypes.FormLifeCoverageSelect,
+                payload: {
+                    coverage: coverageData.coverage,
+                },
+            });
+            // Dispatch postal code
+            dispatchCoverageState({
+                type: exports.StoreFormLifeCoverageActionTypes.FormLifePostalCodeSelect,
+                payload: {
+                    postalCode: coverageData.postalCode,
+                },
+            });
+            // Dispatch city
+            if (coverageData.city) {
+                dispatchCoverageState({
+                    type: exports.StoreFormLifeCoverageActionTypes.FormLifeCitySelect,
+                    payload: {
+                        city: coverageData.city,
+                    },
+                });
+            }
+            // Map and dispatch applicant state
+            const applicantData = mapToLifeApplicantState(autofillData);
+            // Dispatch birth year
+            dispatchApplicantState({
+                type: exports.StoreFormLifeApplicantActionTypes.FormLifeApplicantBirthYearSelect,
+                payload: {
+                    birthYear: applicantData.birthYear,
+                },
+            });
+            // Dispatch birth month
+            dispatchApplicantState({
+                type: exports.StoreFormLifeApplicantActionTypes.FormLifeApplicantBirthMonthSelect,
+                payload: {
+                    birthMonth: applicantData.birthMonth,
+                },
+            });
+            // Dispatch birth day
+            dispatchApplicantState({
+                type: exports.StoreFormLifeApplicantActionTypes.FormLifeApplicantBirthDaySelect,
+                payload: {
+                    birthDay: applicantData.birthDay,
+                },
+            });
+            // Dispatch gender
+            dispatchApplicantState({
+                type: exports.StoreFormLifeApplicantActionTypes.FormLifeApplicantGenderSelect,
+                payload: {
+                    gender: applicantData.gender,
+                },
+            });
+            // Dispatch smoker status
+            dispatchApplicantState({
+                type: exports.StoreFormLifeApplicantActionTypes.FormLifeApplicantSmokerSelect,
+                payload: {
+                    smoker: applicantData.smoker,
+                },
+            });
+            // Dispatch email
+            if (applicantData.emailTo.email) {
+                dispatchApplicantState({
+                    type: exports.StoreFormLifeApplicantActionTypes.FormLifeApplicantEmailSet,
+                    payload: {
+                        email: applicantData.emailTo.email,
+                        emailStatus: mychoiceSdkComponents.ValidationStatusTypes.Approved,
+                    },
+                });
+            }
+            // Dispatch quoter info - first name
+            if (applicantData.quoterInfo.firstName) {
+                dispatchApplicantState({
+                    type: exports.StoreFormLifeApplicantActionTypes.FormLifeQuoterFirstNameSet,
+                    payload: {
+                        firstName: applicantData.quoterInfo.firstName,
+                    },
+                });
+            }
+            // Dispatch quoter info - last name
+            if (applicantData.quoterInfo.lastName) {
+                dispatchApplicantState({
+                    type: exports.StoreFormLifeApplicantActionTypes.FormLifeQuoterLastNameSet,
+                    payload: {
+                        lastName: applicantData.quoterInfo.lastName,
+                    },
+                });
+            }
+            // Dispatch quoter info - phone
+            if (applicantData.quoterInfo.phone) {
+                dispatchApplicantState({
+                    type: exports.StoreFormLifeApplicantActionTypes.FormLifeQuoterPhoneSet,
+                    payload: {
+                        phone: applicantData.quoterInfo.phone,
+                    },
+                });
+            }
+            // Dispatch quoter info - utm source
+            if (applicantData.quoterInfo.utmSource) {
+                dispatchApplicantState({
+                    type: exports.StoreFormLifeApplicantActionTypes.FormLifeUtmSourceSet,
+                    payload: {
+                        utmSource: applicantData.quoterInfo.utmSource,
+                    },
+                });
+            }
+            // Dispatch quoter info - utm campaign
+            if (applicantData.quoterInfo.utmCampaign) {
+                dispatchApplicantState({
+                    type: exports.StoreFormLifeApplicantActionTypes.FormLifeUtmCampaignSet,
+                    payload: {
+                        utmCampaign: applicantData.quoterInfo.utmCampaign,
+                    },
+                });
+            }
+            autofillProcessedRef.current = true;
+            if (options?.onComplete) {
+                options.onComplete();
+            }
+        }
+        catch (error) {
+            // Silently fail - let the app continue with normal flow
+            console.error('Life autofill initialization error:', error);
+        }
+    }, [dispatchPostalState, dispatchCoverageState, dispatchApplicantState, dispatchAppModalState]);
+};
+
 exports.CarQuoteDataHandler = CarQuoteDataHandler;
 exports.ClearFormDataHandler = ClearFormDataHandler;
 exports.HomeQuoteDataHandler = HomeQuoteDataHandler;
@@ -6727,10 +7444,23 @@ exports.formHomeReducer = formHomeReducer;
 exports.formLifeReducer = formLifeReducer;
 exports.formTenantDwellingInitialState = formTenantDwellingInitialState;
 exports.getDwellingInitialState = getDwellingInitialState;
+exports.getProvinceCodeFromState = getProvinceCodeFromState;
+exports.getProvinceName = getProvinceName;
 exports.globalStateReducer = globalStateReducer;
 exports.initHttpResponse = initHttpResponse;
+exports.mapToConfigState = mapToConfigState;
+exports.mapToDriverState = mapToDriverState;
+exports.mapToLifeApplicantState = mapToLifeApplicantState;
+exports.mapToLifeCoverageState = mapToLifeCoverageState;
+exports.mapToLifePostalState = mapToLifePostalState;
+exports.mapToPostalState = mapToPostalState;
+exports.mapToVehicleState = mapToVehicleState;
+exports.parseAutofillParam = parseAutofillParam;
+exports.parseLifeAutofillParam = parseLifeAutofillParam;
 exports.reducers = reducers;
 exports.token = default_1;
+exports.useAutofillCarForm = useAutofillCarForm;
+exports.useAutofillLifeForm = useAutofillLifeForm;
 exports.useHandlerAuth = useHandlerAuth;
 exports.useHandlerCarMake = useHandlerCarMake;
 exports.useHandlerCarModel = useHandlerCarModel;