ts-server-lib 0.0.48

package/ussd/TSUssdMenu.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSUssdMenu = exports.TSUssdState = void 0;
+/**
+ *  USSD Menu with state
+ *
+ *  - General rules
+ *      - Routing
+ *          - ussd text in form 1*2*7
+ *          - * bring back to start menu
+ *
+ *  - Development Section
+ *      - To publish local ussd receiver to remote through ssh
+ *      # ssh -R 9093:localhost:9090 root@185.41.154.247 -N
+ *
+ */
+const events_1 = require("events");
+const object_keys_1 = require("../utils/object-keys");
+class TSUssdState {
+    menu;
+    name;
+    run;
+    defaultNext;
+    val;
+    next = null;
+    constructor(menu) {
+        this.menu = menu;
+        this.name = null;
+        this.run = null;
+        this.defaultNext = null;
+        this.val = null;
+    }
+}
+exports.TSUssdState = TSUssdState;
+class TSUssdMenu extends events_1.EventEmitter {
+    map;
+    static START_STATE = '__start__';
+    static config = {
+        debug: true,
+        general: { separator: ')' },
+        navigation: { back: '00', main: '01' },
+        pager: {
+            default: 3, maxLength: 90, mapping: {},
+            strategies: [{ term: ' - ', enabled: true, type: 'truncate' }]
+        }
+    };
+    session;
+    args;
+    states;
+    result;
+    onResult;
+    current;
+    val;
+    static forOwn(items, cb) {
+        const obj = items;
+        for (const i in obj) {
+            if (Object.hasOwn(obj, i)) {
+                cb(obj[i], i);
+            }
+        }
+    }
+    static mapArgs(args = {}, map = {}) {
+        const results = { provider: map.provider };
+        for (const p in args) {
+            if (Object.hasOwn(args, p) && Object.hasOwn(map, p)) {
+                results[String(map[p])] = args[p];
+            }
+            else if (Object.hasOwn(args, p)) {
+                results[p] = args[p];
+            }
+        }
+        return results;
+    }
+    static cleanRoute(route) {
+        if (route && route.includes('*000')) {
+            const reset = route.substring(route.lastIndexOf('*000') + 4);
+            route = '*' + (reset === '0' ? '' : reset);
+        }
+        return route;
+    }
+    constructor(args = {}, map) {
+        super();
+        this.map = map;
+        this.session = null;
+        this.args = TSUssdMenu.mapArgs(args, map);
+        this.states = {};
+        this.result = '';
+        this.onResult = null;
+        this.val = '';
+    }
+    /**
+     * A callback after result is set
+     */
+    callOnResult() {
+        if (this.onResult) {
+            this.onResult(this.result);
+        }
+    }
+    /**
+     * This method send message to the client and take the session opened
+     *
+     * @param text string Message to sent
+     */
+    con(text) {
+        this.result = 'CON ' + this.print(text);
+        this.callOnResult();
+        return this.result;
+    }
+    /**
+     * This method send message to the client and close the session
+     *
+     * @param text string Message to sent
+     */
+    end(text) {
+        this.result = 'END ' + this.print(text);
+        this.callOnResult();
+        if (this.session) {
+            this.session.end();
+        }
+        return this.result;
+    }
+    /**
+    * This method format the message and if debug calcualte the length
+    *
+    * @param text string Message to sent
+    */
+    print(text) {
+        return TSUssdMenu.config.debug ? '[' + (this.current ? this.current.name : 'N/A') + ':' + text.length + '] ' + text : text;
+    }
+    testLinkRule(rule, val) {
+        // if rule starts with *, treat as regex
+        if (typeof rule === 'string' && rule.startsWith('*')) {
+            return new RegExp(rule.substring(1)).test(val);
+        }
+        return rule === val;
+    }
+    /**
+     * Find state based on route — async/await, no external dependencies.
+     *
+     * next values may be: a string, a callback-based function (cb) => void,
+     * a function returning a string synchronously, or a function returning a Promise.
+     */
+    async resolveRoute(route) {
+        route = TSUssdMenu.cleanRoute(route);
+        const parts = !route ? [] : route.split('*');
+        let state = this.states[TSUssdMenu.START_STATE];
+        // CLY-3: emptiness, not a count. Cold path compared with the feed, so this is consistency rather than
+        // measured cost — but the pattern is the one being removed everywhere, and leaving exceptions is how a
+        // rule stops being applied.
+        if (!state.next || !(0, object_keys_1.hasOwnKey)(state.next)) {
+            return this.states[state.defaultNext];
+        }
+        if ('' in state.next) {
+            parts.unshift('');
+        }
+        while (parts.length > 0) {
+            const part = parts.shift();
+            let nextFound = false;
+            this.val = part ?? '';
+            for (const [link, next] of Object.entries(state.next)) {
+                if (!this.testLinkRule(link, part ?? ''))
+                    continue;
+                let nextPath;
+                if (typeof next === 'string') {
+                    nextPath = next;
+                }
+                else if (typeof next === 'function') {
+                    // supports: callback-based fn(cb), sync-returning fn, and promise-returning fn
+                    nextPath = await new Promise((resolve, reject) => {
+                        const result = next(resolve);
+                        if (typeof result === 'string')
+                            resolve(result);
+                        else if (result && typeof result.then === 'function')
+                            result.then(resolve).catch(reject);
+                    });
+                }
+                if (!nextPath)
+                    continue;
+                state = this.states[nextPath];
+                this.current = state;
+                if (!state)
+                    throw new Error(`[TSUssdMenu]: declared state does not exist: ${nextPath}`);
+                state.val = part ?? '';
+                nextFound = true;
+                break;
+            }
+            if (!nextFound && state.defaultNext) {
+                state = this.states[state.defaultNext];
+                this.current = state;
+                state.val = part;
+            }
+        }
+        return state;
+    }
+    runState(state) {
+        if (!state.run) {
+            return this.emit('error', new Error(`run function not defined for state: ${state.name}`));
+        }
+        state.run(state);
+    }
+    go(stateName) {
+        const state = this.states[stateName];
+        state.val = this.val;
+        this.current = state;
+        this.runState(state);
+    }
+    goStart() {
+        this.go(TSUssdMenu.START_STATE);
+    }
+    /**
+     * Configure custom session handler cross-compatible between callbacks and promises
+     *
+     * @example Memory configuration example with callback
+     *
+     * let sessions = {};
+     * let menu = new UssdMenu();
+     * menu.sessionConfig({
+     *   start: (sessionId, callback) {
+     *     // initialize current session if it doesn't exist this is called by menu.run()
+     *     if(!(sessionId in sessions)) sessions[sessionId] = {};
+     *     callback();
+     *   },
+     *   end: (sessionId, callback) {
+     *     // clear current session this is called by menu.end()
+     *     delete sessions[sessionId];
+     *     callback();
+     *   },
+     *   set: (sessionId, key, value, callback) {
+     *       // store key-value pair in current session
+     *       sessions[sessionId][key] = value;
+     *       callback();
+     *   },
+     *   get: (sessionId, key, callback) {
+     *       // retrieve value by key in current session
+     *       callback(null, sessions[sessionId][key]);
+     *   },
+     *   del: (sessionId, key, callback) {
+     *       delete sessions[sessionId][key];
+     *       callback();
+     *   }
+     * });
+     *
+     * @param {Object} c object with implementation for get, set, start and end methods
+     * @param {String} a attribute of args
+     */
+    sessionConfig(c, a = 'sessionId') {
+        // creates a callback that calls the promise resolve and reject functions as well as the provided callback
+        const makeCb = (resolve, reject, cb) => (err, res) => {
+            if (err) {
+                if (cb) {
+                    cb(err);
+                }
+                reject(err);
+                this.emit('error', err);
+            }
+            else {
+                if (cb) {
+                    cb(null, res);
+                }
+                resolve(res);
+            }
+        };
+        // if p is a promise, handle its resolve and reject chains and invoke the provided callback
+        const resolveIfPromise = (p, resolve, reject, cb) => {
+            if (p && typeof p.then === 'function') {
+                p.then((res) => {
+                    if (cb) {
+                        cb(null, res);
+                    }
+                    resolve(res);
+                }).catch((err) => {
+                    if (cb) {
+                        cb(err);
+                    }
+                    reject(err);
+                    this.emit('error', err);
+                });
+            }
+        };
+        // implement session methods based on user-defined handlers
+        this.session = {
+            start: async (cb) => new Promise((resolve, reject) => {
+                const res = c.start(this.args[a], makeCb(resolve, reject, cb));
+                resolveIfPromise(res, resolve, reject, cb);
+            }),
+            get: async (key, cb) => new Promise((resolve, reject) => {
+                const res = c.get(this.args[a], key, makeCb(resolve, reject, cb));
+                resolveIfPromise(res, resolve, reject, cb);
+            }),
+            del: async (key, cb) => new Promise((resolve, reject) => {
+                const res = c.del(this.args[a], key, makeCb(resolve, reject, cb));
+                resolveIfPromise(res, resolve, reject, cb);
+            }),
+            set: async (key, val, cb) => new Promise((resolve, reject) => {
+                const res = c.set(this.args[a], key, val, makeCb(resolve, reject, cb));
+                resolveIfPromise(res, resolve, reject, cb);
+            }),
+            end: async (cb) => new Promise((resolve, reject) => {
+                const res = c.end(this.args[a], makeCb(resolve, reject, cb));
+                resolveIfPromise(res, resolve, reject, cb);
+            })
+        };
+    }
+    /**
+     * Create a state on the ussd chain
+     *
+     * @param string name name of the state
+     * @param object options
+     * @param object options.next object mapping of route val to state names
+     * @param string options.defaultNext name of state to run when the given route from this state can't be resolved
+     * @param function options.run the method to run when this state is resolved
+     * @return TSUssdMenu the same instance of Ussd
+     */
+    state(name, options) {
+        const state = new TSUssdState(this);
+        this.states[name] = state;
+        state.name = name;
+        state.next = options.next ?? null;
+        state.run = options.run ?? null;
+        // default defaultNext to same state
+        state.defaultNext = options.defaultNext || name;
+        return this;
+    }
+    /**
+     * Create the start state of the ussd chain
+     */
+    startState(options) {
+        return this.state(TSUssdMenu.START_STATE, options);
+    }
+    /**
+     * Run the ussd menu
+     *
+     * @param function onResult a callback to handle on result
+     * @param TSUssdArgs options request args from the gateway api
+     */
+    run(onResult, map) {
+        if (map.provider !== this.args.provider) {
+            this.args = TSUssdMenu.mapArgs(this.args, map);
+        }
+        const mapAny = map;
+        const mapUnderscore = mapAny._;
+        if (mapUnderscore?.[String(this.args.phoneNumber)] && /\d/.test(String(mapUnderscore[String(this.args.phoneNumber)]))) {
+            this.args.phoneNumber = mapUnderscore[String(this.args.phoneNumber)];
+        }
+        else if (mapUnderscore) {
+            this.args._ = mapUnderscore;
+        }
+        this.onResult = onResult;
+        const run = async () => {
+            try {
+                const state = await this.resolveRoute(this.args.message);
+                this.current = state;
+                if (state)
+                    this.runState(state);
+            }
+            catch (err) {
+                this.emit('error', err);
+            }
+        };
+        if (this.session) {
+            void this.session.start().then(run);
+        }
+        else {
+            void run();
+        }
+    }
+}
+exports.TSUssdMenu = TSUssdMenu;

package/ussd/TSUssdScreen.d.ts

@@ -0,0 +1,58 @@
+import { TSUssdMenu } from './TSUssdMenu';
+type PagerStrategy = {
+    term?: string;
+    type?: string;
+};
+export declare class TSUssdScreen {
+    menu: TSUssdMenu;
+    storage?: {
+        hget: (k: string, f: string) => Promise<unknown>;
+        hset: (k: string, f: string, d: unknown) => Promise<unknown>;
+    } | undefined;
+    strategies: {
+        truncate: (data: {
+            name?: string;
+        }[], c: PagerStrategy & {
+            term: string;
+        }, factor: number) => {
+            name?: string;
+        }[];
+    };
+    static nav(command: number | string): unknown;
+    static pagerChoice(max?: number, min?: number): string;
+    constructor(menu: TSUssdMenu, storage?: {
+        hget: (k: string, f: string) => Promise<unknown>;
+        hset: (k: string, f: string, d: unknown) => Promise<unknown>;
+    } | undefined);
+    render(items: unknown[]): void;
+    bind(m: number | string, s: unknown): void;
+    screen(title: number | string, items: Record<string, unknown>): any;
+    list(items: unknown[], title?: string, key?: string, meta?: Record<string, boolean>): string;
+    getAndSet(key: string, field: string): Promise<Record<string, unknown> | null>;
+    pager(items: {
+        name?: string;
+        length?: number;
+    }[] | undefined, key: string, pagerSize: number): Promise<{
+        meta: {
+            command: number;
+            total: number;
+            length: number;
+            offset: number;
+            limit: number;
+        };
+        data: unknown[];
+    }>;
+    _pager(items: unknown[] | undefined, key: string, pagerSize: number): Promise<{
+        meta: {
+            command: number;
+            total: number;
+            length: number;
+            offset: number;
+            limit: number;
+        };
+        data: unknown[];
+    }>;
+    pagerPickAndSet(dataSet: unknown[] | undefined, field: string, size?: number): Promise<any>;
+    checkPick(entity: unknown, state?: string): boolean;
+}
+export {};

package/ussd/TSUssdScreen.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSUssdScreen = void 0;
+const i18n_1 = __importDefault(require("i18n"));
+const TSUssdMenu_1 = require("./TSUssdMenu");
+class TSUssdScreen {
+    menu;
+    storage;
+    strategies = {
+        truncate: (data, c, factor) => {
+            let parts = [];
+            let factors = {};
+            let f = 0;
+            TSUssdMenu_1.TSUssdMenu.forOwn(data, (i) => {
+                const item = i;
+                factors = {};
+                if (item.name && item.name.length > factor) {
+                    parts = item.name.split(c.term);
+                    if (parts.length > 1) {
+                        f = factor / parts.length;
+                        if (parts[0].length < f) {
+                            factors[1] = factor - parts[0].length;
+                            factors[0] = parts[0].length;
+                        }
+                        else if (parts[1].length < f) {
+                            factors[0] = factor - parts[1].length;
+                            factors[1] = parts[1].length;
+                        }
+                        parts.forEach((v, k) => parts[k] = v.substring(0, factors[k] ?? f));
+                        item.name = parts.join(c.term);
+                    }
+                }
+            });
+            return data;
+        }
+    };
+    static nav(command) {
+        return TSUssdMenu_1.TSUssdMenu.config.navigation[String(command)];
+    }
+    static pagerChoice(max = 3, min = 1) {
+        return '*\\^\\[' + min + '-' + max + '\\]\\{1\\}\\$';
+    }
+    constructor(menu, storage) {
+        this.menu = menu;
+        this.storage = storage;
+    }
+    render(items) {
+        TSUssdMenu_1.TSUssdMenu.forOwn(items, (m) => { const mr = m; if (mr)
+            TSUssdMenu_1.TSUssdMenu.forOwn(mr, (v, k) => { if (v !== undefined && k !== undefined)
+                this.bind(k, v); }); });
+    }
+    bind(m, s) {
+        const sObj = s;
+        if (m === 'start') {
+            this.menu.startState({
+                run: () => this.menu.con(sObj.next ? i18n_1.default.__(String(m) + '.' + sObj.key, TSUssdMenu_1.TSUssdMenu.config.general || {}) : this.screen(m, sObj)), next: sObj.next ? sObj.next : sObj
+            });
+        }
+        else {
+            let options = {};
+            if (typeof s === 'function') {
+                options.run = s;
+            }
+            else if (typeof s === 'object' && s !== null && Object.hasOwn(s, 'next')) {
+                const navMain = TSUssdScreen.nav('main');
+                sObj.next = { [navMain]: TSUssdMenu_1.TSUssdMenu.START_STATE, ...sObj.next };
+                options = sObj;
+            }
+            else {
+                options.run = () => this.menu.con(this.screen(m, sObj));
+                const navMain = TSUssdScreen.nav('main');
+                options.next = { [navMain]: TSUssdMenu_1.TSUssdMenu.START_STATE, ...sObj };
+            }
+            this.menu.state(String(m), options);
+        }
+    }
+    screen(title, items) {
+        let context = i18n_1.default.__(String(title), TSUssdMenu_1.TSUssdMenu.config.general || {});
+        const data = TSUssdMenu_1.TSUssdMenu.config.general || {};
+        TSUssdMenu_1.TSUssdMenu.forOwn(items, (v, k) => {
+            if (v != null && !isNaN(Number(k))) {
+                context += isNaN(Number(k)) ? '\n' : '\n' + k + data.separator + ' ';
+                context += i18n_1.default.__(String(title) + '.' + v, data || {});
+            }
+        });
+        if (this.menu.current.name !== TSUssdMenu_1.TSUssdMenu.START_STATE) {
+            context += '\n' + TSUssdScreen.nav('main');
+            context += data.separator + ' ' + i18n_1.default.__('main', data);
+        }
+        return context;
+    }
+    list(items, title = '', key = 'name', meta = { back: true, main: true }) {
+        let context = title;
+        TSUssdMenu_1.TSUssdMenu.forOwn(items, (v, k) => {
+            if (typeof v === 'object' && v !== null && key in v) {
+                context += isNaN(Number(k)) ? '\n' : '\n' + (parseInt(String(k), 10) + 1) + TSUssdMenu_1.TSUssdMenu.config.general.separator + ' ';
+                context += v[key];
+            }
+            else if (['number', 'string', 'boolean'].includes(typeof v)) {
+                context += String(v).indexOf('\n') === -1 ? '\n' + v : String(v);
+            }
+            else {
+                console.error(`TSUssdScreen:list[${key} -> ${k}] not mapped with ->`, JSON.stringify(v, null, 2));
+            }
+        });
+        TSUssdMenu_1.TSUssdMenu.forOwn(meta, (v, k) => { if (k !== undefined)
+            context += '\n' + TSUssdScreen.nav(String(k)) + TSUssdMenu_1.TSUssdMenu.config.general.separator + ' ' + i18n_1.default.__(String(k)); });
+        return context;
+    }
+    async getAndSet(key, field) {
+        if (!this.storage)
+            throw new Error('TSUssdScreen: storage not configured');
+        let data = await this.storage.hget(String(this.menu.args.phoneNumber), field);
+        if (this.menu.val && this.menu.val.toString().length > 0) {
+            if (!data) {
+                data = { [key]: this.menu.val };
+            }
+            else {
+                data[key] = this.menu.val;
+            }
+            await this.storage.hset(String(this.menu.args.phoneNumber), field, data);
+        }
+        return data;
+    }
+    async pager(items = [], key, pagerSize) {
+        let length = 0;
+        const result = await this._pager(items, key, pagerSize);
+        TSUssdMenu_1.TSUssdMenu.forOwn(result.data, (i) => { const it = i; length += (it.name?.length ?? 0) || (it.length ?? 0); });
+        if (TSUssdMenu_1.TSUssdMenu.config.pager.maxLength < length) {
+            TSUssdMenu_1.TSUssdMenu.forOwn(TSUssdMenu_1.TSUssdMenu.config.pager.strategies, (s) => {
+                const strat = s;
+                if (strat.enabled && strat.type && this.strategies[strat.type]) {
+                    this.strategies[strat.type](result.data, strat, parseInt((TSUssdMenu_1.TSUssdMenu.config.pager.maxLength / pagerSize).toString(), 10));
+                }
+            });
+        }
+        return result;
+    }
+    async _pager(items = [], key, pagerSize) {
+        if (!this.storage)
+            throw new Error('TSUssdScreen: storage not configured');
+        const pagerOptions = (await this.storage.hget(String(this.menu.args.phoneNumber), key + 'Pager') || {}), command = parseInt(this.menu.val, 10), calculatePaging = () => {
+            if (pagerSize >= items.length) {
+                offset = 0;
+                limit = pagerSize;
+            }
+            else if (command === 7) {
+                limit = offset;
+                offset -= pagerSize;
+                if (offset < 0) {
+                    offset = 0;
+                    limit = pagerSize;
+                }
+            }
+            else if (command === 9) {
+                offset = limit;
+                limit = offset + pagerSize;
+                if (limit > items.length) {
+                    limit = items.length;
+                    offset = limit - pagerSize;
+                }
+            }
+        };
+        let offset = pagerOptions.offset || 0, limit = pagerOptions.limit || (offset + pagerSize);
+        calculatePaging();
+        let data = items.slice(offset, limit), { length } = data, dataLength = 0;
+        TSUssdMenu_1.TSUssdMenu.forOwn(data, (i) => { const it = i; dataLength += it.name ? it.name.length : (it.length ?? 0); });
+        if (TSUssdMenu_1.TSUssdMenu.config.pager.maxLength < dataLength) {
+            pagerSize = pagerSize - 1;
+            offset = pagerOptions.offset || 0;
+            limit = pagerOptions.limit || (offset + pagerSize);
+            calculatePaging();
+            data = items.slice(offset, limit);
+            length = data.length;
+        }
+        await this.storage.hset(String(this.menu.args.phoneNumber), key + 'Pager', { offset: offset, limit: limit });
+        if (offset < 1 && items.length > limit) {
+            data.push(i18n_1.default.__('\n9 [Next]', TSUssdMenu_1.TSUssdMenu.config.general));
+        }
+        else if (items.length > limit && offset > 0) {
+            data.push(i18n_1.default.__('\n7 [Prev] | 9 [Next]', TSUssdMenu_1.TSUssdMenu.config.general));
+        }
+        else if (offset > 0) {
+            data.push(i18n_1.default.__('\n7 [Prev]', TSUssdMenu_1.TSUssdMenu.config.general));
+        }
+        return { meta: { command: command, total: items.length, length: length, offset: offset, limit: limit }, data: data };
+    }
+    async pagerPickAndSet(dataSet = [], field, size = 0) {
+        if (!this.storage)
+            throw new Error('TSUssdScreen: storage not configured');
+        const pagerOptions = (await this.storage.hget(String(this.menu.args.phoneNumber), field + 'Pager') || {}), offset = pagerOptions.offset || 0, limit = pagerOptions.limit || (offset + size), cursor = parseInt(this.menu.val, 10) - 1;
+        let data;
+        dataSet = size ? dataSet.slice(offset, limit) : dataSet;
+        if (size && dataSet.length >= cursor) {
+            data = dataSet[cursor];
+        }
+        if (!size) {
+            data = dataSet[cursor + offset];
+        }
+        await this.storage.hset(String(this.menu.args.phoneNumber), field, data);
+        return data;
+    }
+    checkPick(entity, state) {
+        if (!entity && state) {
+            this.menu.go(state);
+            return false;
+        }
+        else if (!entity) {
+            this.menu.end(i18n_1.default.__('invalid.input', { input: this.menu.val }));
+            return false;
+        }
+        return true;
+    }
+}
+exports.TSUssdScreen = TSUssdScreen;

package/ussd/index.d.ts

@@ -0,0 +1,3 @@
+export * from './TSUssdMenu';
+export * from './TSUssdScreen';
+export * from './providers/index';

package/ussd/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TSUssdMenu"), exports);
+__exportStar(require("./TSUssdScreen"), exports);
+__exportStar(require("./providers/index"), exports);

package/ussd/providers/AfricasTalking.d.ts

@@ -0,0 +1,3 @@
+export declare function response(text: string, _rr?: unknown): string;
+export declare function request(request: any, _response: unknown): any;
+export declare function text(_prev: string | undefined, body: any): any;

package/ussd/providers/AfricasTalking.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = response;
+exports.request = request;
+exports.text = text;
+const _1 = require("./_");
+function response(text, _rr) {
+    return text;
+}
+function request(request, _response) {
+    const body = (0, _1.body)(request);
+    request.body = (0, _1.mapArgs)(body, _1.providersMap[_1.TSUssdProviders.africastalking]);
+    return request.body;
+}
+function text(_prev = '', body) {
+    return body.message;
+}