@mychoice/mychoice-sdk-store 2.2.8 → 2.2.10

package/dist/cjs/handlers/autofill/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './utils';
+export * from './useAutofillCarForm';

package/dist/cjs/handlers/autofill/types.d.ts

@@ -0,0 +1,76 @@
+export interface AutofillDriver {
+    gender: string;
+    listed: boolean;
+    ticket: boolean;
+    insured: boolean;
+    accident: boolean;
+    first_name: string;
+    occupation: number;
+    listed_year?: string;
+    insured_year?: string;
+    licence_info: {
+        licence_type: string;
+        g_licence_date?: string;
+        g1_licence_date?: string;
+        g2_licence_date?: string;
+        first_licence_age: number;
+    };
+    date_of_birth: string;
+    marital_status: string;
+    licence_suspension: boolean;
+    insurance_cancellation: boolean;
+}
+export interface AutofillVehicleCoverage {
+    coverage: boolean;
+    deductible?: number;
+    limit?: number;
+}
+export interface AutofillVehicle {
+    city: string;
+    make: string;
+    year: number;
+    model: string;
+    leased: boolean;
+    condition: string;
+    liability: AutofillVehicleCoverage;
+    collision: AutofillVehicleCoverage;
+    lossofuse: AutofillVehicleCoverage;
+    comprehensive: AutofillVehicleCoverage;
+    liabilityfordamage: AutofillVehicleCoverage;
+    limitedwaiverofdepreciation: AutofillVehicleCoverage;
+    postal_code: string;
+    primary_use: string;
+    winter_tires: boolean;
+    purchase_date: string;
+    distance_daily: number;
+    distance_yearly: number;
+    parking_location: string;
+    distance_business: number;
+    location_index: number;
+    bodytype: string;
+    ext_vicc: string;
+    vicc_code: string;
+}
+export interface AutofillVehLink {
+    priority: string;
+    driver_index: number;
+    vehicle_index: number;
+}
+export interface AutofillData {
+    uuid: string;
+    drivers: AutofillDriver[];
+    vehicles: AutofillVehicle[];
+    vehlinks: AutofillVehLink[];
+    email_to: string;
+    policy_start: string;
+    province_code: string;
+    caa_member_discount: boolean;
+    app_install_discount: boolean;
+    multiple_policies_discount: boolean;
+}
+export interface MappedAutofillData {
+    drivers: any[];
+    vehicles: any[];
+    postalData: any;
+    configData: any;
+}

package/dist/cjs/handlers/autofill/useAutofillCarForm.d.ts

@@ -0,0 +1,8 @@
+interface AutofillOptions {
+    onComplete?: () => void;
+}
+/**
+ * Hook to initialize car insurance form with autofill data from query parameter
+ */
+export declare const useAutofillCarForm: (options?: AutofillOptions) => void;
+export {};

package/dist/cjs/handlers/autofill/utils.d.ts

@@ -0,0 +1,94 @@
+import { AutofillData } from './types';
+/**
+ * Parse URL-encoded JSON from query parameter
+ */
+export declare const parseAutofillParam: (urlEncodedJson: string) => AutofillData;
+/**
+ * Get province name from code
+ */
+export declare const getProvinceName: (code: string) => string;
+/**
+ * Map autofill data to postal state format
+ */
+export declare const mapToPostalState: (autofillData: AutofillData) => {
+    city: string;
+    postalCode: string;
+    locationIndex: string;
+    provinceCode: string;
+    provinceName: string;
+};
+/**
+ * Map autofill data to vehicle state format
+ */
+export declare const mapToVehicleState: (autofillData: AutofillData) => {
+    year: string;
+    make: string;
+    model: string;
+    condition: string;
+    leased: boolean;
+    purchaseDate: string;
+    winterTires: boolean;
+    parkingLocation: string;
+    primaryUse: string;
+    distanceDaily: number;
+    distanceBusiness: number;
+    distanceYearly: number;
+    comprehensive: {
+        coverage: boolean;
+        deductible: number;
+    };
+    collision: {
+        coverage: boolean;
+        deductible: number;
+    };
+    liability: {
+        coverage: boolean;
+        limit: number;
+    };
+    lossofuse: {
+        coverage: boolean;
+        limit: number;
+    };
+    liabilityfordamage: {
+        coverage: boolean;
+        limit: number;
+    };
+    limitedwaiverofdepreciation: {
+        coverage: boolean;
+        limit: number;
+    };
+    postalCode: string;
+    locationIndex: string;
+    city: string;
+};
+/**
+ * Map autofill data to driver state format
+ */
+export declare const mapToDriverState: (autofillData: AutofillData) => {
+    firstName: string;
+    dateOfBirth: string;
+    maritalStatus: string;
+    gender: string;
+    occupation: number;
+    listed: boolean;
+    listedYear: string;
+    insured: boolean;
+    insuredYear: string;
+    ticket: boolean;
+    accident: boolean;
+    licenceSuspension: boolean;
+    insuranceCancellation: boolean;
+    licenceInfo: {
+        licenceType: string;
+        firstLicenceAge: number;
+        gLicenceDate: string;
+        g1LicenceDate: string;
+        g2LicenceDate: string;
+    };
+};
+/**
+ * Map autofill data to config state format
+ */
+export declare const mapToConfigState: (autofillData: AutofillData) => {
+    province: string;
+};

package/dist/cjs/handlers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './dataHandlers';
 export * from './validationHandlers';
 export * from './helper';
+export * from './autofill';

package/dist/cjs/index.js

@@ -6712,6 +6712,471 @@ 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 || '',
+    };
+};
+
+/**
+ * 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,
+    ]);
+};
+
 exports.CarQuoteDataHandler = CarQuoteDataHandler;
 exports.ClearFormDataHandler = ClearFormDataHandler;
 exports.HomeQuoteDataHandler = HomeQuoteDataHandler;
@@ -6727,10 +7192,17 @@ exports.formHomeReducer = formHomeReducer;
 exports.formLifeReducer = formLifeReducer;
 exports.formTenantDwellingInitialState = formTenantDwellingInitialState;
 exports.getDwellingInitialState = getDwellingInitialState;
+exports.getProvinceName = getProvinceName;
 exports.globalStateReducer = globalStateReducer;
 exports.initHttpResponse = initHttpResponse;
+exports.mapToConfigState = mapToConfigState;
+exports.mapToDriverState = mapToDriverState;
+exports.mapToPostalState = mapToPostalState;
+exports.mapToVehicleState = mapToVehicleState;
+exports.parseAutofillParam = parseAutofillParam;
 exports.reducers = reducers;
 exports.token = default_1;
+exports.useAutofillCarForm = useAutofillCarForm;
 exports.useHandlerAuth = useHandlerAuth;
 exports.useHandlerCarMake = useHandlerCarMake;
 exports.useHandlerCarModel = useHandlerCarModel;