ouisys-engine 4.6.2 → 4.7.0-alpha.1

package/dist/strategySlice-bF74rxDK.js

@@ -0,0 +1,842 @@
+import { __awaiter, __generator, __assign } from 'tslib';
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { N as NothingYet, S as Success, L as Loading, F as Failure } from './RemoteDataState-CwHLI23e.js';
+import { searchToObject } from './searchToObject.js';
+import { getConfig } from './getConfig.js';
+import 'awesome-phonenumber';
+import { t as tryGetIPRangeName } from './tryGetIPRangeName-C69HEG5W.js';
+import { t as tracker } from './tracker-B_zsMRN2.js';
+
+var PossibleTypes;
+(function (PossibleTypes) {
+    PossibleTypes["IDENTIFY_STRATEGY"] = "IDENTIFY_STRATEGY";
+    PossibleTypes["IDENTIFY_FLOW_BY_MSISDN"] = "IDENTIFY_FLOW_BY_MSISDN";
+    PossibleTypes["IDENTIFY_FLOW_BY_OPERATOR_SELECT"] = "IDENTIFY_FLOW_BY_OPERATOR_SELECT";
+    PossibleTypes["PIN"] = "PIN";
+    PossibleTypes["MO"] = "MO";
+    PossibleTypes["MO_REDIR"] = "MO_REDIR";
+    PossibleTypes["ONE_CLICK"] = "ONE_CLICK";
+    PossibleTypes["CLICK2SMS"] = "CLICK2SMS";
+    PossibleTypes["USSD"] = "USSD";
+    PossibleTypes["TPAY_HE"] = "TPAY_HE";
+    PossibleTypes["CREDIT_CARD"] = "CREDIT_CARD";
+})(PossibleTypes || (PossibleTypes = {}));
+
+var identify = function (_a) {
+    var window = _a.window, slug = _a.slug, country = _a.country, msisdn = _a.msisdn, device = _a.device, offer = _a.offer, rockmanId = _a.rockmanId;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var languageCode, locationHref, host, params, urlParams, url, response;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    languageCode = window.languageCode ? "&language_code=".concat(window.languageCode) : '';
+                    locationHref = encodeURIComponent(window.location.href);
+                    host = window.DEV_BASE_URL || '';
+                    params = {
+                        action: 'identify',
+                        slug: slug,
+                        country: country,
+                        msisdn: msisdn,
+                        device: device,
+                        offerId: offer,
+                        rockman_id: rockmanId,
+                        page: locationHref,
+                        language_code: languageCode
+                    };
+                    urlParams = new URLSearchParams(params).toString();
+                    url = "".concat(host, "/tallyman/v1/?").concat(urlParams);
+                    return [4 /*yield*/, fetch(url)];
+                case 1:
+                    response = _b.sent();
+                    return [2 /*return*/, response.json()];
+            }
+        });
+    });
+};
+
+function determineFlowByMsidn(_a) {
+    var _b, _c, _d, _e;
+    var window = _a.window, internationalMSISDN = _a.internationalMSISDN, configs = _a.configs;
+    return __awaiter(this, void 0, void 0, function () {
+        var submissionError, msisdn, defaultFlowConfig, config, operatorsConfig, indentifyFlow, theResult, flow, cannotDetect, hlrError, submissionError, flowObj, flowObj, submissionError;
+        var _this = this;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    if (!internationalMSISDN) {
+                        submissionError = new Error("Error in submitMSISDN() identify action");
+                        submissionError.type = 'SEInvalidMSISDN';
+                        throw submissionError;
+                    }
+                    msisdn = ((_b = internationalMSISDN.match(/\d+/gi)) === null || _b === void 0 ? void 0 : _b.join('')) || '';
+                    defaultFlowConfig = (_c = configs === null || configs === void 0 ? void 0 : configs.strategyConfigs) === null || _c === void 0 ? void 0 : _c.default;
+                    config = defaultFlowConfig.flowConfig;
+                    operatorsConfig = (_d = configs === null || configs === void 0 ? void 0 : configs.strategyConfigs) === null || _d === void 0 ? void 0 : _d.operators;
+                    indentifyFlow = function () { return __awaiter(_this, void 0, void 0, function () {
+                        var slug, country, device, rockmanId, offer, flowOperatorResult;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    slug = config.slug, country = config.country, device = config.device;
+                                    rockmanId = window.pac_analytics.visitor.rockmanId;
+                                    offer = window.pac_analytics.visitor.offer;
+                                    return [4 /*yield*/, identify({
+                                            window: window,
+                                            slug: slug,
+                                            country: country,
+                                            msisdn: msisdn,
+                                            device: device,
+                                            offer: offer,
+                                            rockmanId: rockmanId
+                                        })];
+                                case 1:
+                                    flowOperatorResult = _a.sent();
+                                    return [2 /*return*/, flowOperatorResult];
+                            }
+                        });
+                    }); };
+                    return [4 /*yield*/, indentifyFlow()];
+                case 1:
+                    theResult = _f.sent();
+                    flow = operatorsConfig[theResult.operator] ? operatorsConfig[theResult.operator] : null;
+                    cannotDetect = theResult.success === false && theResult.message === 'Operator could not be found for the given MSISDN';
+                    hlrError = theResult.success === false && ((_e = theResult.message) === null || _e === void 0 ? void 0 : _e.indexOf('HLR did not find the operator for given MSISDN')) !== -1;
+                    if (cannotDetect || hlrError) {
+                        submissionError = new Error("Error in submitMSISDN() identify action");
+                        submissionError.type = 'FlowDetectFailed';
+                        submissionError.msisdn = msisdn;
+                        throw submissionError;
+                    }
+                    else if (flow !== null) {
+                        flowObj = __assign({ operator: theResult.operator, default: defaultFlowConfig }, flow);
+                        // @ts-ignore
+                        return [2 /*return*/, flowObj];
+                    }
+                    else if (flow === null) {
+                        flowObj = __assign({ operator: theResult.operator }, defaultFlowConfig);
+                        // @ts-ignore
+                        return [2 /*return*/, flowObj];
+                    }
+                    else {
+                        submissionError = new Error("Error in submitMSISDN() identify action");
+                        submissionError.type = 'SEInvalidMSISDN';
+                        throw submissionError;
+                    }
+            }
+        });
+    });
+}
+function determineFlowByOperator(_a) {
+    var _b, _c;
+    var configs = _a.configs, operator = _a.operator;
+    var defaultFlowConfig = (_b = configs === null || configs === void 0 ? void 0 : configs.strategyConfigs) === null || _b === void 0 ? void 0 : _b.default;
+    var operatorsConfig = (_c = configs === null || configs === void 0 ? void 0 : configs.strategyConfigs) === null || _c === void 0 ? void 0 : _c.operators;
+    var flowObj = __assign({ operator: operator === null || operator === void 0 ? void 0 : operator.toUpperCase(), default: defaultFlowConfig }, operatorsConfig[operator === null || operator === void 0 ? void 0 : operator.toUpperCase()]);
+    // @ts-ignore
+    return flowObj;
+}
+function determineFlowByOperatorFromIp(_a) {
+    var window = _a.window, configs = _a.configs;
+    return __awaiter(this, void 0, void 0, function () {
+        var operator, flowObj;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, tryGetIPRangeName(window.pac_analytics.visitor)];
+                case 1:
+                    operator = _b.sent();
+                    flowObj = determineFlowByOperator({
+                        configs: configs,
+                        operator: operator ? operator.toUpperCase() : ''
+                    });
+                    return [2 /*return*/, flowObj];
+            }
+        });
+    });
+}
+function getOperators(_a) {
+    var _b;
+    var configs = _a.configs;
+    var operatorsConfig = (_b = configs === null || configs === void 0 ? void 0 : configs.strategyConfigs) === null || _b === void 0 ? void 0 : _b.operators;
+    var operators = Object.keys(operatorsConfig);
+    return operators;
+}
+// export const mockedPinFlow: StrategyState = {
+//   currentState: {
+//     type: PossibleTypes.PIN,
+//     result: RDS.NothingYet(),
+//     data: {
+//       config: mockConfig('pin')
+//     }
+//   }
+// };
+// export const mockedMoFlow: StrategyState = {
+//   currentState: {
+//     type: PossibleTypes.MO,
+//     result: RDS.NothingYet(),
+//     data: {
+//       config: mockConfig('mo')
+//     }
+//   }
+// };
+// export const mockedUssdFlow: StrategyState = {
+//   currentState: {
+//     type: PossibleTypes.USSD,
+//     result: RDS.NothingYet(),
+//     data: {
+//       config: mockConfig('ussd')
+//     }
+//   }
+// };
+// export const mockedMoRdirFlow: StrategyState = {
+//   currentState: {
+//     type: PossibleTypes.MO_REDIR,
+//     result: RDS.NothingYet(),
+//     data: {
+//       config: mockConfig('moRedir')
+//     }
+//   }
+// };
+// export const mockedClick2smsFlow: StrategyState = {
+//   currentState: {
+//     type: PossibleTypes.CLICK2SMS,
+//     result: RDS.NothingYet(),
+//     data: {
+//       config: mockConfig('click2sms')
+//     }
+//   }
+// };
+// export const mockedOneClickFlow: StrategyState = {
+//   currentState: {
+//     type: PossibleTypes.ONE_CLICK,
+//     result: RDS.NothingYet(),
+//     data: {
+//       config: mockConfig('oneClick')
+//     }
+//   }
+// };
+// export const mockedCreditCardFlow: StrategyState = {
+//   currentState: {
+//     type: PossibleTypes.CREDIT_CARD,
+//     result: RDS.NothingYet(),
+//     data: {
+//       config: mockConfig('creditCard')
+//     }
+//   }
+// };
+// export const mockedMOFlow : State = { type: "MO", result:moFlow(mockTracker, mockConfig("mo"))}
+// export const mockedOneClickFlow : State = { type: "ONECLICK", result:oneClickFlow(mockTracker, mockConfig("oneClick"), {"testextraparams":"1"})}
+// export const mockedClick2smsFlow : State = { type: "CLICK2SMS", result:click2smsFlow(mockTracker, mockConfig("click2sms"))}
+// export const mockedMORedirFlow : State = { type: "MOREDIR", result:moRedirFlow(mockTracker, mockConfig("moRedir"))}
+
+var askMobileNumber = function () { return ({
+    type: PossibleTypes.IDENTIFY_FLOW_BY_MSISDN,
+    result: NothingYet()
+}); };
+var submitMSISDNAction = createAsyncThunk('strategy/submitMSISDNAction', function (_a, _b) {
+    var window = _a.window, msisdn = _a.msisdn;
+    var rejectWithValue = _b.rejectWithValue;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var configs, strategy, flowObj, ex_1, errorType;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    configs = getConfig();
+                    strategy = configs.strategy;
+                    return [4 /*yield*/, determineFlowByMsidn({ window: window, internationalMSISDN: msisdn, configs: configs })];
+                case 1:
+                    flowObj = _c.sent();
+                    switch (strategy) {
+                        case 'pin-mo-redir-ask-mobile-number':
+                            return [2 /*return*/, pinMoRedirAskMobileNumber(flowObj, msisdn)];
+                        case 'pin-mo-ask-mobile-number':
+                            return [2 /*return*/, pinMoAskMobileNumber(flowObj, msisdn)];
+                        case 'pin-combo-ask-mobile-number':
+                            return [2 /*return*/, pinComboAskMobileNumber(flowObj, msisdn)];
+                        case 'mo-redir-mo-click2sms-one-click-detect-operator-by-ip-or-msisdn':
+                            return [2 /*return*/, moRedirMoClick2smsOneClickDetectOperatorByIpOrMsisdn(flowObj, msisdn)];
+                        case 'pin-mo-mo-redir-ask-mobile-number':
+                            return [2 /*return*/, pinMoMoRedirAskMobileNumber(flowObj, msisdn)];
+                        case 'pin-click2sms-ask-mobile-number':
+                            return [2 /*return*/, pinClick2smsAskMobileNumber(flowObj, msisdn)];
+                        default:
+                            return [2 /*return*/, rejectWithValue('Unknown strategy')];
+                    }
+                case 2:
+                    ex_1 = _c.sent();
+                    errorType = void 0;
+                    switch (ex_1.type) {
+                        case 'SEAlreadySubscribed':
+                            errorType = 'AlreadySubscribed';
+                            break;
+                        case 'SEInvalidMSISDN':
+                            errorType = 'InvalidMSISDN';
+                            break;
+                        default:
+                            errorType = 'UnknownError';
+                    }
+                    return [2 /*return*/, rejectWithValue({
+                            errorType: errorType,
+                            error: ex_1,
+                            productUrl: ex_1.productUrl
+                        })];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+});
+var pinMoAskMobileNumber = function (flowObj, msisdn) {
+    switch (flowObj.flow) {
+        case 'pin':
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: __assign({ config: flowObj.flowConfig, msisdn: msisdn }, (flowObj.operator && { operator: flowObj.operator }))
+            };
+        case 'mo':
+            tracker.sendOptInFlowEvent('Msisdn to sms');
+            return {
+                type: PossibleTypes.MO,
+                result: NothingYet(),
+                data: __assign({ config: flowObj.flowConfig, msisdn: msisdn }, (flowObj.operator && { operator: flowObj.operator }))
+            };
+        default:
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: __assign({ config: flowObj.flowConfig }, (flowObj.operator && { operator: flowObj.operator }))
+            };
+    }
+};
+var pinComboAskMobileNumber = function (flowObj, msisdn) {
+    switch (flowObj.flow) {
+        case 'pin':
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: __assign({ config: flowObj.flowConfig, msisdn: msisdn }, (flowObj.operator && { operator: flowObj.operator }))
+            };
+        default:
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: __assign({ config: flowObj.flowConfig }, (flowObj.operator && { operator: flowObj.operator }))
+            };
+    }
+};
+var pinMoRedirAskMobileNumber = function (flowObj, msisdn) {
+    switch (flowObj.flow) {
+        case 'pin':
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    msisdn: msisdn
+                }
+            };
+        case 'moRedir':
+            tracker.sendOptInFlowEvent('Redirect');
+            return {
+                type: PossibleTypes.MO_REDIR,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig
+                }
+            };
+        default:
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig
+                }
+            };
+    }
+};
+var pinMoMoRedirAskMobileNumber = function (flowObj, msisdn) {
+    switch (flowObj.flow) {
+        case 'pin':
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    msisdn: msisdn
+                }
+            };
+        case 'moRedir':
+            tracker.sendOptInFlowEvent('Redirect');
+            return {
+                type: PossibleTypes.MO_REDIR,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    msisdn: msisdn
+                }
+            };
+        case 'mo':
+            tracker.sendOptInFlowEvent('Msisdn to sms');
+            return {
+                type: PossibleTypes.MO,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    msisdn: msisdn
+                }
+            };
+        default:
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig
+                }
+            };
+    }
+};
+var moRedirMoClick2smsOneClickDetectOperatorByIpOrMsisdn = function (flowObj, msisdn) {
+    switch (flowObj.flowOnWifi) {
+        case 'moRedir':
+            tracker.sendOptInFlowEvent('Redirect');
+            return {
+                type: PossibleTypes.MO_REDIR,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    msisdn: msisdn
+                }
+            };
+        case 'mo':
+            tracker.sendOptInFlowEvent('Msisdn to sms');
+            return {
+                type: PossibleTypes.MO,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    msisdn: msisdn
+                }
+            };
+        default:
+            tracker.sendOptInFlowEvent('Redirect');
+            return {
+                type: PossibleTypes.MO_REDIR,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    rockman_id: flowObj.rockman_id
+                }
+            };
+    }
+};
+var pinClick2smsAskMobileNumber = function (flowObj, msisdn) {
+    switch (flowObj.flow) {
+        case 'pin':
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.PIN,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    msisdn: msisdn
+                }
+            };
+        case 'click2sms':
+            tracker.sendOptInFlowEvent('Click to sms');
+            return {
+                type: PossibleTypes.CLICK2SMS,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig,
+                    msisdn: msisdn
+                }
+            };
+        default:
+            tracker.sendOptInFlowEvent('Pin');
+            return {
+                type: PossibleTypes.CLICK2SMS,
+                result: NothingYet(),
+                data: {
+                    config: flowObj.flowConfig
+                }
+            };
+    }
+};
+
+var askOperator = function () {
+    var configs = getConfig();
+    var operators = getOperators({ configs: configs });
+    return {
+        type: PossibleTypes.IDENTIFY_FLOW_BY_OPERATOR_SELECT,
+        result: NothingYet(),
+        data: {
+            operators: operators
+        }
+    };
+};
+var selectOperatorAction = createAsyncThunk('strategy/selectOperatorAction', function (_a, _b) {
+    var operator = _a.operator;
+    var rejectWithValue = _b.rejectWithValue;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var configs, flowObj, errorType;
+        return __generator(this, function (_c) {
+            try {
+                configs = getConfig();
+                flowObj = determineFlowByOperator({
+                    configs: configs,
+                    operator: operator
+                });
+                switch (flowObj.flow) {
+                    case 'pin':
+                        tracker.sendOptInFlowEvent('Pin');
+                        return [2 /*return*/, {
+                                type: PossibleTypes.PIN,
+                                result: {
+                                    config: flowObj.flowConfig,
+                                    operator: operator
+                                }
+                            }];
+                    case 'mo':
+                        tracker.sendOptInFlowEvent('Msisdn to sms');
+                        return [2 /*return*/, {
+                                type: PossibleTypes.MO,
+                                result: {
+                                    config: flowObj.flowConfig,
+                                    operator: operator
+                                }
+                            }];
+                    case 'click2sms':
+                        tracker.sendOptInFlowEvent('Click to sms');
+                        return [2 /*return*/, {
+                                type: PossibleTypes.CLICK2SMS,
+                                result: {
+                                    config: __assign({ operators: [operator] }, flowObj.flowConfig),
+                                    operator: operator
+                                }
+                            }];
+                    case 'oneClick':
+                        tracker.sendOptInFlowEvent('3G click');
+                        return [2 /*return*/, {
+                                type: PossibleTypes.ONE_CLICK,
+                                result: {
+                                    config: flowObj.flowConfig,
+                                    operator: operator,
+                                    autoRedirect: true
+                                }
+                            }];
+                    default:
+                        tracker.sendOptInFlowEvent('Pin');
+                        return [2 /*return*/, {
+                                type: PossibleTypes.PIN,
+                                result: NothingYet()
+                            }];
+                }
+            }
+            catch (ex) {
+                errorType = 'UnkownError';
+                return [2 /*return*/, rejectWithValue({
+                        errorType: errorType,
+                        error: ex.toString()
+                    })];
+            }
+            return [2 /*return*/];
+        });
+    });
+});
+
+// @ts-ignore
+var trackerEventMapping = {
+    mo: 'Msisdn to sms',
+    pin: 'Pin',
+    oneClick: '3G click',
+    moRedir: 'Redirect',
+    click2sms: 'Click to sms',
+    ussd: 'Msisdn to sms'
+};
+var flowMapping = {
+    mo: PossibleTypes.MO,
+    pin: PossibleTypes.PIN,
+    oneClick: PossibleTypes.ONE_CLICK,
+    moRedir: PossibleTypes.MO_REDIR,
+    click2sms: PossibleTypes.CLICK2SMS,
+    ussd: PossibleTypes.USSD,
+    creditCard: PossibleTypes.CREDIT_CARD
+};
+var detectOperatorByIp = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var configs, flowObj, getTrackerEventName, flowType, event_1, ex_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                configs = getConfig();
+                return [4 /*yield*/, determineFlowByOperatorFromIp({
+                        window: window,
+                        configs: configs
+                    })];
+            case 1:
+                flowObj = _a.sent();
+                getTrackerEventName = function (flowType) { return trackerEventMapping[flowType]; };
+                flowType = flowObj.flow;
+                event_1 = getTrackerEventName(flowType);
+                tracker.sendOptInFlowEvent(event_1);
+                return [2 /*return*/, {
+                        type: flowMapping[flowType],
+                        result: NothingYet(),
+                        data: {
+                            config: flowObj.flowConfig,
+                            operator: flowObj.operator
+                        }
+                    }];
+            case 2:
+                ex_1 = _a.sent();
+                console.error('SSSSS', ex_1);
+                return [3 /*break*/, 3];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+
+var initialState = {
+    currentState: {
+        type: PossibleTypes.IDENTIFY_STRATEGY,
+        result: NothingYet(),
+        data: undefined
+    }
+};
+var mockStrategyStateByUrlParam = function () {
+    var search = searchToObject(window);
+    if (search['mock-flow'] !== undefined) {
+        if (search.operator !== undefined) {
+            window.operator = search.operator;
+        }
+        switch (search['mock-flow']) {
+            case 'pin':
+                return {
+                    type: PossibleTypes.PIN,
+                    result: Success({})
+                };
+            case 'mo':
+                return {
+                    type: PossibleTypes.MO,
+                    result: Success({})
+                };
+            case 'moredir':
+                return {
+                    type: PossibleTypes.MO_REDIR,
+                    result: Success({})
+                };
+            case 'oneclick':
+                return {
+                    type: PossibleTypes.ONE_CLICK,
+                    result: Success({})
+                };
+            case 'click2sms':
+                return {
+                    type: PossibleTypes.CLICK2SMS,
+                    result: Success({})
+                };
+            case 'ussd':
+                return {
+                    type: PossibleTypes.USSD,
+                    result: Success({})
+                };
+            case 'creditcard':
+                return {
+                    type: PossibleTypes.CREDIT_CARD,
+                    result: Success({})
+                };
+            default:
+                throw new Error('(mockStrategyStateByUrlParam) Strategy Mock Flow not supported');
+        }
+    }
+};
+/**
+ * Identify Strategy
+ * @returns {type: 'strategy/identifyStrategy', payload: {type: PossibleTypes.MO, result: IdentifyFlowOptionsResult}}
+ * - Add type
+ * - Makes a decision on which strategy to use in order to identify the flow
+ * - Strategy could be asking user's phone number, selecting an operator etc
+ * - all with the intension of getting the flow and its configuration
+ * - Flows are usually tied to an operator in the pages config.json
+ * - But they could also be single flows
+ *
+ */
+var identifyStrategy = createAsyncThunk('strategy/identifyStrategy', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var configs, strategy, strategyConfigs, search, flowObj, strategyResult;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return __generator(this, function (_j) {
+        configs = getConfig();
+        strategy = configs.strategy, strategyConfigs = configs.strategyConfigs;
+        search = searchToObject(window);
+        if (search['mock-flow'] !== undefined) {
+            return [2 /*return*/, mockStrategyStateByUrlParam()];
+        }
+        if ((search['show-pin-entry'] && search['show-pin-entry'] === '1') ||
+            (search['show-thank-you'] && search['show-thank-you'] === '1')) {
+            flowObj = determineFlowByOperator({
+                configs: configs,
+                operator: search.operator
+            });
+            strategyResult = {
+                type: PossibleTypes.PIN,
+                result: Success({}),
+                data: {
+                    config: (flowObj === null || flowObj === void 0 ? void 0 : flowObj.flowConfig) || ((_a = strategyConfigs === null || strategyConfigs === void 0 ? void 0 : strategyConfigs.default) === null || _a === void 0 ? void 0 : _a.flowConfig)
+                }
+            };
+            return [2 /*return*/, strategyResult];
+        }
+        if (strategy.includes('ask-operator')) {
+            return [2 /*return*/, askOperator()];
+        }
+        if (strategy.includes('detect-operator-by-ip')) {
+            return [2 /*return*/, detectOperatorByIp()];
+        }
+        if (strategy === null || strategy === void 0 ? void 0 : strategy.includes('ask-mobile-number')) {
+            return [2 /*return*/, askMobileNumber()];
+        }
+        switch (strategy) {
+            case 'pin': {
+                return [2 /*return*/, {
+                        type: PossibleTypes.PIN,
+                        result: Success({}),
+                        data: {
+                            config: (_b = strategyConfigs === null || strategyConfigs === void 0 ? void 0 : strategyConfigs.default) === null || _b === void 0 ? void 0 : _b.flowConfig
+                        }
+                    }];
+            }
+            case 'mo':
+                return [2 /*return*/, {
+                        type: PossibleTypes.MO,
+                        result: Success({}),
+                        data: {
+                            config: (_c = strategyConfigs === null || strategyConfigs === void 0 ? void 0 : strategyConfigs.default) === null || _c === void 0 ? void 0 : _c.flowConfig
+                        }
+                    }];
+            case 'mo-redir':
+                return [2 /*return*/, {
+                        type: PossibleTypes.MO_REDIR,
+                        result: Success({}),
+                        data: {
+                            config: (_d = strategyConfigs === null || strategyConfigs === void 0 ? void 0 : strategyConfigs.default) === null || _d === void 0 ? void 0 : _d.flowConfig
+                        }
+                    }];
+            case 'one-click':
+                return [2 /*return*/, {
+                        type: PossibleTypes.ONE_CLICK,
+                        result: Success({}),
+                        data: {
+                            config: (_e = strategyConfigs === null || strategyConfigs === void 0 ? void 0 : strategyConfigs.default) === null || _e === void 0 ? void 0 : _e.flowConfig
+                        }
+                    }];
+            case 'click2sms':
+                return [2 /*return*/, {
+                        type: PossibleTypes.CLICK2SMS,
+                        result: Success({}),
+                        data: {
+                            config: (_f = strategyConfigs === null || strategyConfigs === void 0 ? void 0 : strategyConfigs.default) === null || _f === void 0 ? void 0 : _f.flowConfig
+                        }
+                    }];
+            case 'ussd':
+                return [2 /*return*/, {
+                        type: PossibleTypes.USSD,
+                        result: Success({}),
+                        data: {
+                            config: (_g = strategyConfigs === null || strategyConfigs === void 0 ? void 0 : strategyConfigs.default) === null || _g === void 0 ? void 0 : _g.flowConfig
+                        }
+                    }];
+            case 'credit-card':
+                return [2 /*return*/, {
+                        type: PossibleTypes.CREDIT_CARD,
+                        result: Success({}),
+                        data: {
+                            config: (_h = strategyConfigs === null || strategyConfigs === void 0 ? void 0 : strategyConfigs.default) === null || _h === void 0 ? void 0 : _h.flowConfig
+                        }
+                    }];
+            default:
+                throw new Error('Strategy not supported');
+        }
+    });
+}); });
+var setStrategyExtraData = createAsyncThunk('strategy/setStrategyExtraData', function (_a) {
+    var type = _a.type, data = _a.data;
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_b) {
+            return [2 /*return*/, ({
+                    type: type,
+                    result: NothingYet(),
+                    data: data
+                })];
+        });
+    });
+});
+var strategySlice = createSlice({
+    name: 'strategy',
+    initialState: initialState,
+    reducers: {
+    // Define synchronous reducers as needed
+    },
+    extraReducers: function (builder) {
+        builder
+            .addCase(identifyStrategy.pending, function (state) {
+            state.currentState = {
+                type: PossibleTypes.IDENTIFY_STRATEGY,
+                result: Loading()
+            };
+        })
+            .addCase(identifyStrategy.fulfilled, function (state, action) {
+            state.currentState = action.payload;
+        })
+            .addCase(identifyStrategy.rejected, function (state, action) {
+            state.currentState = {
+                type: PossibleTypes.IDENTIFY_STRATEGY,
+                result: Failure(action.error.message)
+            };
+        })
+            .addCase(submitMSISDNAction.pending, function (state) {
+            state.currentState = {
+                type: PossibleTypes.IDENTIFY_FLOW_BY_MSISDN,
+                result: Loading()
+            };
+        })
+            .addCase(submitMSISDNAction.fulfilled, function (state, action) {
+            state.currentState = action.payload;
+        })
+            .addCase(submitMSISDNAction.rejected, function (state, action) {
+            state.currentState = {
+                type: PossibleTypes.IDENTIFY_FLOW_BY_MSISDN,
+                result: Failure(action.payload)
+            };
+        })
+            .addCase(setStrategyExtraData.fulfilled, function (state, action) {
+            state.currentState = action.payload;
+        })
+            .addCase(selectOperatorAction.pending, function (state) {
+            state.currentState = {
+                type: PossibleTypes.IDENTIFY_FLOW_BY_OPERATOR_SELECT,
+                result: Loading()
+            };
+        })
+            .addCase(selectOperatorAction.fulfilled, function (state, action) {
+            state.currentState = action.payload;
+        })
+            .addCase(selectOperatorAction.rejected, function (state, action) {
+            state.currentState = {
+                type: PossibleTypes.IDENTIFY_FLOW_BY_OPERATOR_SELECT,
+                result: Failure(action.payload)
+            };
+        });
+    }
+});
+var strategyReducer = strategySlice.reducer;
+
+export { PossibleTypes as P, selectOperatorAction as a, strategyReducer as b, setStrategyExtraData as c, identifyStrategy as i, submitMSISDNAction as s };
+//# sourceMappingURL=strategySlice-bF74rxDK.js.map