@botonic/core 0.56.0-alpha.0 → 0.57.0-rslib-esm.0

package/lib/esm/routing/router-utils.js

@@ -1,47 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoMatchingRouteError = void 0;
-exports.isPathPayload = isPathPayload;
-exports.getPathParamsFromPathPayload = getPathParamsFromPathPayload;
-exports.pathParamsToParams = pathParamsToParams;
-exports.getEmptyAction = getEmptyAction;
-exports.getNotFoundAction = getNotFoundAction;
-exports.getComputedRoutes = getComputedRoutes;
-const constants_1 = require("../constants");
+import { EMPTY_ACTION_PATH, NOT_FOUND_PATH, PATH_PAYLOAD_IDENTIFIER, PATH_PAYLOAD_REGEXP } from "../constants.js";
+
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+
 class NoMatchingRouteError extends Error {
-    constructor(input) {
-        super(`No route found for input '${JSON.stringify(input)}' and no ${constants_1.NOT_FOUND_PATH} route defined`);
+    constructor(input){
+        super(`No route found for input '${JSON.stringify(input)}' and no ${NOT_FOUND_PATH} route defined`), _define_property(this, "input", void 0);
         this.input = input;
     }
 }
-exports.NoMatchingRouteError = NoMatchingRouteError;
-function isPathPayload(payload) {
+function router_utils_isPathPayload(payload) {
     if (!payload) {
         return false;
     }
-    const isPathPayload = constants_1.PATH_PAYLOAD_REGEXP.exec(payload);
+    const isPathPayload = PATH_PAYLOAD_REGEXP.exec(payload);
     return Boolean(isPathPayload);
 }
 function getPathParamsFromPathPayload(payload) {
     const defaultPathParams = {
         path: null,
-        params: {},
+        params: {}
     };
     if (!payload) {
         return defaultPathParams;
     }
-    if (!isPathPayload(payload)) {
+    if (!router_utils_isPathPayload(payload)) {
         return defaultPathParams;
     }
     try {
-        const pathWithParams = payload.split(constants_1.PATH_PAYLOAD_IDENTIFIER)[1];
+        const pathWithParams = payload.split(PATH_PAYLOAD_IDENTIFIER)[1];
         if (!pathWithParams) {
-            throw `${constants_1.PATH_PAYLOAD_IDENTIFIER} is empty`;
+            throw `${PATH_PAYLOAD_IDENTIFIER} is empty`;
         }
         const [path, params] = pathWithParams.split('?');
-        return { path: path ?? null, params: pathParamsToParams(params) };
-    }
-    catch (e) {
+        return {
+            path: path ?? null,
+            params: pathParamsToParams(params)
+        };
+    } catch (e) {
         console.error('Error getting path and params from input.payload:', e);
         return defaultPathParams;
     }
@@ -53,12 +59,11 @@ function pathParamsToParams(pathParams) {
     try {
         const params = {};
         const searchParams = new URLSearchParams(pathParams);
-        for (const [key, value] of searchParams) {
+        for (const [key, value] of searchParams){
             params[key] = value;
         }
         return params;
-    }
-    catch (_e) {
+    } catch (_e) {
         return {};
     }
 }
@@ -66,14 +71,14 @@ function getEmptyAction(childRoutes) {
     if (!childRoutes) {
         return null;
     }
-    const emptyActionRoute = childRoutes.find(r => r.path === constants_1.EMPTY_ACTION_PATH);
+    const emptyActionRoute = childRoutes.find((r)=>r.path === EMPTY_ACTION_PATH);
     if (!emptyActionRoute) {
         return null;
     }
     return emptyActionRoute.action;
 }
 function getNotFoundAction(input, routes) {
-    const notFoundActionRoute = routes.find(r => r.path === constants_1.NOT_FOUND_PATH);
+    const notFoundActionRoute = routes.find((r)=>r.path === NOT_FOUND_PATH);
     if (!notFoundActionRoute) {
         throw new NoMatchingRouteError(input);
     }
@@ -83,14 +88,16 @@ async function getComputedRoutes(routes, botContext) {
     if (routes instanceof Function) {
         return await getComputedRoutes(await routes(botContext), botContext);
     }
-    for (const [key, route] of Object.entries(routes)) {
+    for (const [key, route] of Object.entries(routes)){
         if (route.childRoutes && route.childRoutes instanceof Function) {
             routes[key].childRoutes = await getComputedRoutes(await route.childRoutes(botContext), botContext);
-        }
-        else {
+        } else {
             routes[key] = route;
         }
     }
     return routes;
 }
+
+export { NoMatchingRouteError, getComputedRoutes, getEmptyAction, getNotFoundAction, getPathParamsFromPathPayload, pathParamsToParams, router_utils_isPathPayload as isPathPayload };
+
 //# sourceMappingURL=router-utils.js.map

package/lib/esm/routing/router-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"router-utils.js","sourceRoot":"","sources":["../../../src/routing/router-utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"routing/router-utils.js","sources":["../../../src/routing/router-utils.ts"],"sourcesContent":["import {\n  EMPTY_ACTION_PATH,\n  NOT_FOUND_PATH,\n  PATH_PAYLOAD_IDENTIFIER,\n  PATH_PAYLOAD_REGEXP,\n} from '../constants'\nimport type {\n  Action,\n  BotContext,\n  Input,\n  Params,\n  PathParams,\n  Route,\n  Routes,\n} from '../models'\n\nexport class NoMatchingRouteError extends Error {\n  input: Input\n  constructor(input: Input) {\n    super(\n      `No route found for input '${JSON.stringify(\n        input\n      )}' and no ${NOT_FOUND_PATH} route defined`\n    )\n    this.input = input\n  }\n}\n\nexport function isPathPayload(payload?: string): boolean {\n  if (!payload) {\n    return false\n  }\n  const isPathPayload = PATH_PAYLOAD_REGEXP.exec(payload)\n  return Boolean(isPathPayload)\n}\n\nexport function getPathParamsFromPathPayload(payload?: string): PathParams {\n  const defaultPathParams = {\n    path: null,\n    params: {},\n  }\n  if (!payload) {\n    return defaultPathParams\n  }\n  if (!isPathPayload(payload)) {\n    return defaultPathParams\n  }\n  try {\n    const pathWithParams = payload.split(PATH_PAYLOAD_IDENTIFIER)[1]\n    if (!pathWithParams) {\n      throw `${PATH_PAYLOAD_IDENTIFIER} is empty`\n    }\n    const [path, params] = pathWithParams.split('?')\n    return { path: path ?? null, params: pathParamsToParams(params) }\n  } catch (e) {\n    console.error('Error getting path and params from input.payload:', e)\n    return defaultPathParams\n  }\n}\n\nexport function pathParamsToParams(pathParams?: string): Params {\n  if (!pathParams) {\n    return {}\n  }\n  try {\n    const params = {}\n    const searchParams = new URLSearchParams(pathParams)\n    for (const [key, value] of searchParams) {\n      params[key] = value\n    }\n    return params\n  } catch (_e) {\n    return {}\n  }\n}\n\nexport function getEmptyAction(childRoutes?: Route[]): Action {\n  if (!childRoutes) {\n    return null\n  }\n  const emptyActionRoute = childRoutes.find(r => r.path === EMPTY_ACTION_PATH)\n  if (!emptyActionRoute) {\n    return null\n  }\n  return emptyActionRoute.action\n}\n\nexport function getNotFoundAction(input: Input, routes: Route[]): Action {\n  const notFoundActionRoute = routes.find(r => r.path === NOT_FOUND_PATH)\n  if (!notFoundActionRoute) {\n    throw new NoMatchingRouteError(input)\n  }\n  return notFoundActionRoute.action\n}\n\nexport async function getComputedRoutes(\n  routes: Routes,\n  botContext: BotContext\n): Promise<Route[]> {\n  if (routes instanceof Function) {\n    return await getComputedRoutes(await routes(botContext), botContext)\n  }\n  for (const [key, route] of Object.entries(routes) as any) {\n    if (route.childRoutes && route.childRoutes instanceof Function) {\n      routes[key].childRoutes = await getComputedRoutes(\n        await route.childRoutes(botContext),\n        botContext\n      )\n    } else {\n      routes[key] = route\n    }\n  }\n  return routes\n}\n"],"names":["EMPTY_ACTION_PATH","NOT_FOUND_PATH","PATH_PAYLOAD_IDENTIFIER","PATH_PAYLOAD_REGEXP","NoMatchingRouteError","Error","input","JSON","isPathPayload","payload","Boolean","getPathParamsFromPathPayload","defaultPathParams","pathWithParams","path","params","pathParamsToParams","e","console","pathParams","searchParams","URLSearchParams","key","value","_e","getEmptyAction","childRoutes","emptyActionRoute","r","getNotFoundAction","routes","notFoundActionRoute","getComputedRoutes","botContext","Function","route","Object"],"mappings":";;;;;;;;;;;;;;AAKqB;AAWd,MAAMI,oBAAoBA,SAASC;IAExC,YAAYC,KAAY,CAAE;QACxB,KAAK,CACH,CAAC,0BAA0B,EAAEC,KAAK,SAAS,CACzCD,OACA,SAAS,EAAEL,cAAcA,CAAC,cAAc,CAAC,GAL/C;QAOE,IAAI,CAAC,KAAK,GAAGK;IACf;AACF;AAEO,SAASE,0BAAaA,CAACC,OAAgB;IAC5C,IAAI,CAACA,SAAS;QACZ,OAAO;IACT;IACA,MAAMD,gBAAgBL,wBAAwB,CAACM;IAC/C,OAAOC,QAAQF;AACjB;AAEO,SAASG,4BAA4BA,CAACF,OAAgB;IAC3D,MAAMG,oBAAoB;QACxB,MAAM;QACN,QAAQ,CAAC;IACX;IACA,IAAI,CAACH,SAAS;QACZ,OAAOG;IACT;IACA,IAAI,CAACJ,0BAAaA,CAACC,UAAU;QAC3B,OAAOG;IACT;IACA,IAAI;QACF,MAAMC,iBAAiBJ,QAAQ,KAAK,CAACP,uBAAuBA,CAAC,CAAC,EAAE;QAChE,IAAI,CAACW,gBAAgB;YACnB,MAAM,GAAGX,uBAAuBA,CAAC,SAAS,CAAC;QAC7C;QACA,MAAM,CAACY,MAAMC,OAAO,GAAGF,eAAe,KAAK,CAAC;QAC5C,OAAO;YAAE,MAAMC,QAAQ;YAAM,QAAQE,kBAAkBA,CAACD;QAAQ;IAClE,EAAE,OAAOE,GAAG;QACVC,QAAQ,KAAK,CAAC,qDAAqDD;QACnE,OAAOL;IACT;AACF;AAEO,SAASI,kBAAkBA,CAACG,UAAmB;IACpD,IAAI,CAACA,YAAY;QACf,OAAO,CAAC;IACV;IACA,IAAI;QACF,MAAMJ,SAAS,CAAC;QAChB,MAAMK,eAAe,IAAIC,gBAAgBF;QACzC,KAAK,MAAM,CAACG,KAAKC,MAAM,IAAIH,aAAc;YACvCL,MAAM,CAACO,IAAI,GAAGC;QAChB;QACA,OAAOR;IACT,EAAE,OAAOS,IAAI;QACX,OAAO,CAAC;IACV;AACF;AAEO,SAASC,cAAcA,CAACC,WAAqB;IAClD,IAAI,CAACA,aAAa;QAChB,OAAO;IACT;IACA,MAAMC,mBAAmBD,YAAY,IAAI,CAACE,CAAAA,IAAKA,EAAE,IAAI,KAAK5B,iBAAiBA;IAC3E,IAAI,CAAC2B,kBAAkB;QACrB,OAAO;IACT;IACA,OAAOA,iBAAiB,MAAM;AAChC;AAEO,SAASE,iBAAiBA,CAACvB,KAAY,EAAEwB,MAAe;IAC7D,MAAMC,sBAAsBD,OAAO,IAAI,CAACF,CAAAA,IAAKA,EAAE,IAAI,KAAK3B,cAAcA;IACtE,IAAI,CAAC8B,qBAAqB;QACxB,MAAM,IAAI3B,oBAAoBA,CAACE;IACjC;IACA,OAAOyB,oBAAoB,MAAM;AACnC;AAEO,eAAeC,iBAAiBA,CACrCF,MAAc,EACdG,UAAsB;IAEtB,IAAIH,kBAAkBI,UAAU;QAC9B,OAAO,MAAMF,iBAAiBA,CAAC,MAAMF,OAAOG,aAAaA;IAC3D;IACA,KAAK,MAAM,CAACX,KAAKa,MAAM,IAAIC,OAAO,OAAO,CAACN,QAAgB;QACxD,IAAIK,MAAM,WAAW,IAAIA,MAAM,WAAW,YAAYD,UAAU;YAC9DJ,MAAM,CAACR,IAAI,CAAC,WAAW,GAAG,MAAMU,iBAAiBA,CAC/C,MAAMG,MAAM,WAAW,CAACF,aACxBA;QAEJ,OAAO;YACLH,MAAM,CAACR,IAAI,GAAGa;QAChB;IACF;IACA,OAAOL;AACT"}

package/lib/esm/routing/router.d.ts

@@ -1,5 +1,5 @@
-import { RouteInspector } from '../debug/inspector';
-import type { Input, MatchedValue, Matcher, MatchingProp, Nullable, ProcessInputResult, Route, RouteParams, RoutePath, RoutingState, Session } from '../models';
+import { RouteInspector } from '../debug/inspector.js';
+import type { Input, MatchedValue, Matcher, MatchingProp, Nullable, ProcessInputResult, Route, RouteParams, RoutePath, RoutingState, Session } from '../models/index.js';
 export declare class Router {
     routes: Route[];
     routeInspector: RouteInspector;

package/lib/esm/routing/router.js

@@ -1,26 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = void 0;
-const constants_1 = require("../constants");
-const inspector_1 = require("../debug/inspector");
-const utils_1 = require("../utils");
-const router_utils_1 = require("./router-utils");
+import { NOT_FOUND_PATH } from "../constants.js";
+import { RouteInspector } from "../debug/inspector.js";
+import { cloneObject } from "../utils/index.js";
+import { getEmptyAction, getNotFoundAction, getPathParamsFromPathPayload, isPathPayload } from "./router-utils.js";
+
+
+
+
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+
+
+
+
 class Router {
-    constructor(routes, routeInspector = undefined) {
-        this.routes = routes;
-        this.routeInspector = routeInspector || new inspector_1.RouteInspector();
-    }
     /**
-     * Processes an input and return a representation of the new bot state.
-     * The algorithm is splitted in two main parts:
-     * 1. Getting the current routing state.
-     * 2. Given a routing state, resolve the different possible scenarios and return the new bot state.
-     * The new bot state can return three type of actions:
-     * - action: an action directly resolved from a matching route
-     * - emptyAction: optional action that can exists or not only within childRoutes
-     * - fallbackAction: any other action that acts as a fallback (404, )
-     */
-    // eslint-disable-next-line complexity
+   * Processes an input and return a representation of the new bot state.
+   * The algorithm is splitted in two main parts:
+   * 1. Getting the current routing state.
+   * 2. Given a routing state, resolve the different possible scenarios and return the new bot state.
+   * The new bot state can return three type of actions:
+   * - action: an action directly resolved from a matching route
+   * - emptyAction: optional action that can exists or not only within childRoutes
+   * - fallbackAction: any other action that acts as a fallback (404, )
+   */ // eslint-disable-next-line complexity
     processInput(input, session, lastRoutePath = null) {
         session.__retries = session?.__retries ?? 0;
         // 1. Getting the current routing state.
@@ -29,136 +41,127 @@ class Router {
         const matchedRoutePath = matchedRoute?.path ?? null;
         // 2. Given a routing state, resolve the different possible scenarios and return the new bot state.
         /**
-         * Redirect Scenario:
-         * We have matched a redirect route with a given redirection path, so we try to obtain the redirectionRoute with getRouteByPath.
-         * Independently of whether the redirectionRoute is found or not, the intent is to trigger a redirection which by definition breaks the flow, so retries are set to 0.
-         * It has preference over ignoring retries.
-         */
-        if (matchedRoute?.redirect) {
+     * Redirect Scenario:
+     * We have matched a redirect route with a given redirection path, so we try to obtain the redirectionRoute with getRouteByPath.
+     * Independently of whether the redirectionRoute is found or not, the intent is to trigger a redirection which by definition breaks the flow, so retries are set to 0.
+     * It has preference over ignoring retries.
+     */ if (matchedRoute?.redirect) {
             session.__retries = 0;
             const redirectionRoute = this.getRouteByPath(matchedRoute.redirect);
             if (redirectionRoute) {
                 return {
                     action: redirectionRoute.action,
-                    emptyAction: (0, router_utils_1.getEmptyAction)(redirectionRoute.childRoutes),
+                    emptyAction: getEmptyAction(redirectionRoute.childRoutes),
                     fallbackAction: null,
                     lastRoutePath: matchedRoute.redirect,
-                    params,
+                    params
                 };
             }
             return {
                 action: null,
                 emptyAction: null,
-                fallbackAction: (0, router_utils_1.getNotFoundAction)(input, this.routes),
+                fallbackAction: getNotFoundAction(input, this.routes),
                 lastRoutePath: null,
-                params,
+                params
             };
         }
         /**
-         * Ignore Retry Scenario:
-         * We have matched a route with an ignore retry, so we return directly the new bot state. The intent is to break the flow, so retries are set to 0.
-         */
-        if (matchedRoute?.ignoreRetry) {
+     * Ignore Retry Scenario:
+     * We have matched a route with an ignore retry, so we return directly the new bot state. The intent is to break the flow, so retries are set to 0.
+     */ if (matchedRoute?.ignoreRetry) {
             session.__retries = 0;
             return {
                 action: matchedRoute.action,
-                emptyAction: (0, router_utils_1.getEmptyAction)(matchedRoute.childRoutes),
+                emptyAction: getEmptyAction(matchedRoute.childRoutes),
                 fallbackAction: null,
                 lastRoutePath: matchedRoutePath,
-                params,
+                params
             };
         }
         /**
-         * Retry Scenario:
-         * We were in a route which had retries enabled, so we check if the number of retries is exceeded.
-         * If we have not surpassed the limit of retries and we haven't matched an ignoreRetry route, update them, and then return the new bot state.
-         */
-        if (isFlowBroken &&
-            currentRoute &&
-            currentRoute.retry &&
-            session.__retries < currentRoute.retry) {
+     * Retry Scenario:
+     * We were in a route which had retries enabled, so we check if the number of retries is exceeded.
+     * If we have not surpassed the limit of retries and we haven't matched an ignoreRetry route, update them, and then return the new bot state.
+     */ if (isFlowBroken && currentRoute && currentRoute.retry && session.__retries < currentRoute.retry) {
             session.__retries = session.__retries !== 0 ? session.__retries + 1 : 1;
-            if (matchedRoute && matchedRoutePath !== constants_1.NOT_FOUND_PATH) {
+            if (matchedRoute && matchedRoutePath !== NOT_FOUND_PATH) {
                 return {
                     action: currentRoute.action,
-                    emptyAction: (0, router_utils_1.getEmptyAction)(matchedRoute.childRoutes),
+                    emptyAction: getEmptyAction(matchedRoute.childRoutes),
                     fallbackAction: matchedRoute.action,
                     lastRoutePath: currentRoutePath,
-                    params,
+                    params
                 };
             }
             return {
                 action: currentRoute.action ?? null,
-                emptyAction: (0, router_utils_1.getEmptyAction)(currentRoute.childRoutes),
-                fallbackAction: (0, router_utils_1.getNotFoundAction)(input, this.routes),
+                emptyAction: getEmptyAction(currentRoute.childRoutes),
+                fallbackAction: getNotFoundAction(input, this.routes),
                 lastRoutePath: currentRoutePath,
-                params,
+                params
             };
         }
         /**
-         * Default Scenario:
-         * We have matched a route or not, but we don't need to execute retries logic, so retries stay to 0.
-         */
-        session.__retries = 0;
+     * Default Scenario:
+     * We have matched a route or not, but we don't need to execute retries logic, so retries stay to 0.
+     */ session.__retries = 0;
         /**
-         * Matching Route Scenario:
-         * We have matched a route, so we return the new bot state.
-         */
-        if (matchedRoute && matchedRoutePath !== constants_1.NOT_FOUND_PATH) {
+     * Matching Route Scenario:
+     * We have matched a route, so we return the new bot state.
+     */ if (matchedRoute && matchedRoutePath !== NOT_FOUND_PATH) {
             return {
                 action: matchedRoute.action ?? null,
-                emptyAction: (0, router_utils_1.getEmptyAction)(matchedRoute.childRoutes),
+                emptyAction: getEmptyAction(matchedRoute.childRoutes),
                 fallbackAction: null,
                 lastRoutePath: matchedRoutePath,
-                params,
+                params
             };
         }
         /**
-         * 404 Scenario (No Route Found):
-         * We have not matched any route, so we return the new bot state.
-         */
-        return {
+     * 404 Scenario (No Route Found):
+     * We have not matched any route, so we return the new bot state.
+     */ return {
             action: null,
             emptyAction: null,
-            fallbackAction: (0, router_utils_1.getNotFoundAction)(input, this.routes),
+            fallbackAction: getNotFoundAction(input, this.routes),
             params,
-            lastRoutePath: currentRoutePath,
+            lastRoutePath: currentRoutePath
         };
     }
     /**
-     * Find the route that matches the given input, if it match with some of the entries, return the whole Route of the entry with optional params captured if matcher was a regex.
-     * IMPORTANT: It returns a cloned route instead of the route itself to avoid modifying original routes and introduce side effects
-     * */
-    getRoute(input, routes, session, lastRoutePath) {
+   * Find the route that matches the given input, if it match with some of the entries, return the whole Route of the entry with optional params captured if matcher was a regex.
+   * IMPORTANT: It returns a cloned route instead of the route itself to avoid modifying original routes and introduce side effects
+   * */ getRoute(input, routes, session, lastRoutePath) {
         let params = {};
-        const route = routes.find(r => Object.entries(r)
-            .filter(([key, _]) => key !== 'action' && key !== 'childRoutes' && key !== 'path')
-            .some(([key, value]) => {
-            const match = this.matchRoute(r, key, value, input, session, lastRoutePath);
-            try {
-                if (match !== null && typeof match !== 'boolean' && match.groups) {
-                    // Strip '[Object: null prototype]' from groups result: https://stackoverflow.com/a/62945609/6237608
-                    params = { ...match.groups };
-                }
-            }
-            catch (_e) { }
-            return Boolean(match);
-        }));
+        const route = routes.find((r)=>Object.entries(r).filter(([key, _])=>key !== 'action' && key !== 'childRoutes' && key !== 'path').some(([key, value])=>{
+                const match = this.matchRoute(r, key, value, input, session, lastRoutePath);
+                try {
+                    if (match !== null && typeof match !== 'boolean' && match.groups) {
+                        // Strip '[Object: null prototype]' from groups result: https://stackoverflow.com/a/62945609/6237608
+                        params = {
+                            ...match.groups
+                        };
+                    }
+                } catch (_e) {}
+                return Boolean(match);
+            }));
         if (route) {
-            return { route: (0, utils_1.cloneObject)(route), params };
+            return {
+                route: cloneObject(route),
+                params
+            };
         }
         return null;
     }
     /**
-     * Find the route that matches the given path. Path can include concatenations, e.g: 'Flow1/Subflow1.1'.
-     * IMPORTANT: It returns a cloned route instead of the route itself to avoid modifying original routes and introduce side effects
-     * */
-    getRouteByPath(path, routeList = this.routes) {
+   * Find the route that matches the given path. Path can include concatenations, e.g: 'Flow1/Subflow1.1'.
+   * IMPORTANT: It returns a cloned route instead of the route itself to avoid modifying original routes and introduce side effects
+   * */ getRouteByPath(path, routeList = this.routes) {
         if (!path) {
             return null;
         }
         const [currentPath, ...childPath] = path.split('/');
-        for (const route of routeList) {
+        for (const route of routeList){
             // iterate over all routeList
             if (route.path === currentPath) {
                 if (route.childRoutes?.length && childPath.length > 0) {
@@ -166,53 +169,50 @@ class Router {
                     const computedRoute = this.getRouteByPath(childPath.join('/'), route.childRoutes);
                     // IMPORTANT: Returning a new object to avoid modifying dev routes and introduce side effects
                     if (computedRoute) {
-                        return (0, utils_1.cloneObject)(computedRoute);
+                        return cloneObject(computedRoute);
                     }
-                }
-                else if (childPath.length === 0) {
-                    return (0, utils_1.cloneObject)(route); // last action and found route
+                } else if (childPath.length === 0) {
+                    return cloneObject(route) // last action and found route
+                    ;
                 }
             }
         }
         return null;
     }
     /**
-     * Returns the matched value for a specific route.
-     * Matching Props: ('text' | 'payload' | 'intent' | 'type' | 'input' | 'session' | 'request' ...)
-     * Matchers: (string: exact match | regex: regular expression match | function: return true)
-     * input: user input object, e.g.: {type: 'text', data: 'Hi'}
-     * */
-    matchRoute(route, prop, matcher, input, session, lastRoutePath) {
+   * Returns the matched value for a specific route.
+   * Matching Props: ('text' | 'payload' | 'intent' | 'type' | 'input' | 'session' | 'request' ...)
+   * Matchers: (string: exact match | regex: regular expression match | function: return true)
+   * input: user input object, e.g.: {type: 'text', data: 'Hi'}
+   * */ matchRoute(route, prop, matcher, input, session, lastRoutePath) {
         let value = null;
         if (Object.keys(input).indexOf(prop) > -1) {
             value = input[prop];
-        }
-        else if (prop === 'text') {
+        } else if (prop === 'text') {
             value = input.data;
-        }
-        else if (prop === 'input') {
+        } else if (prop === 'input') {
             value = input;
-        }
-        else if (prop === 'session') {
+        } else if (prop === 'session') {
             value = session;
-        }
-        else if (prop === 'request') {
-            value = { input, session, lastRoutePath };
+        } else if (prop === 'request') {
+            value = {
+                input,
+                session,
+                lastRoutePath
+            };
         }
         const matched = this.matchValue(matcher, value);
         if (matched) {
             this.routeInspector.routeMatched(route, prop, matcher, value);
-        }
-        else {
+        } else {
             this.routeInspector.routeNotMatched(route, prop, matcher, value);
         }
         return matched;
     }
     /**
-     * Runs the matcher against the given value.
-     * If there is a match, it will return a truthy value (true, RegExp result), o.w., it will return a falsy value.
-     * */
-    matchValue(matcher, value) {
+   * Runs the matcher against the given value.
+   * If there is a match, it will return a truthy value (true, RegExp result), o.w., it will return a falsy value.
+   * */ matchValue(matcher, value) {
         if (typeof matcher === 'string') {
             return value === matcher;
         }
@@ -228,24 +228,22 @@ class Router {
         return false;
     }
     /**
-     * It resolves the current state of navigation. Two scenarios:
-     * 1. Given a path payload input (__PATH_PAYLOAD__somePath?someParam=someValue), we can resolve the routing state directly from it (using getRouteByPath).
-     * 2. Given any other type of input, we resolve the routing state with normal resolution (using getRoute).
-     * */
-    getRoutingState(input, session, lastRoutePath) {
+   * It resolves the current state of navigation. Two scenarios:
+   * 1. Given a path payload input (__PATH_PAYLOAD__somePath?someParam=someValue), we can resolve the routing state directly from it (using getRouteByPath).
+   * 2. Given any other type of input, we resolve the routing state with normal resolution (using getRoute).
+   * */ getRoutingState(input, session, lastRoutePath) {
         const currentRoute = this.getRouteByPath(lastRoutePath);
         if (currentRoute && lastRoutePath) {
             currentRoute.path = lastRoutePath;
         }
-        if (typeof input.payload === 'string' && (0, router_utils_1.isPathPayload)(input.payload)) {
+        if (typeof input.payload === 'string' && isPathPayload(input.payload)) {
             return this.getRoutingStateFromPathPayload(currentRoute, input.payload);
         }
         return this.getRoutingStateFromInput(currentRoute, input, session);
     }
     /**
-     * Given a non path payload input, try to run it against the routes, update matching routes information in consequence and dictamine if the flow has been broken.
-     * */
-    getRoutingStateFromInput(currentRoute, input, session) {
+   * Given a non path payload input, try to run it against the routes, update matching routes information in consequence and dictamine if the flow has been broken.
+   * */ getRoutingStateFromInput(currentRoute, input, session) {
         // get route depending of current ChildRoutes
         if (currentRoute?.childRoutes) {
             const routeParams = this.getRoute(input, currentRoute.childRoutes, session, currentRoute.path);
@@ -254,68 +252,65 @@ class Router {
                     currentRoute,
                     matchedRoute: {
                         ...routeParams.route,
-                        path: routeParams.route && currentRoute.path
-                            ? `${currentRoute.path}/${routeParams.route.path}`
-                            : currentRoute.path,
+                        path: routeParams.route && currentRoute.path ? `${currentRoute.path}/${routeParams.route.path}` : currentRoute.path
                     },
                     params: routeParams.params,
-                    isFlowBroken: false,
+                    isFlowBroken: false
                 };
             }
         }
         /**
-         * we couldn't find a route in the state of the currentRoute childRoutes,
-         * so let's find in the general routes
-         */
-        const routeParams = this.getRoute(input, this.routes, session, currentRoute?.path ?? null);
+     * we couldn't find a route in the state of the currentRoute childRoutes,
+     * so let's find in the general routes
+     */ const routeParams = this.getRoute(input, this.routes, session, currentRoute?.path ?? null);
         const isFlowBroken = Boolean(currentRoute?.path);
         if (routeParams?.route) {
             return {
                 currentRoute,
                 matchedRoute: {
                     ...routeParams.route,
-                    path: routeParams.route?.path ?? null,
+                    path: routeParams.route?.path ?? null
                 },
                 params: routeParams.params,
-                isFlowBroken,
+                isFlowBroken
             };
         }
         return {
             currentRoute,
             matchedRoute: null,
             params: {},
-            isFlowBroken,
+            isFlowBroken
         };
     }
     /**
-     * Given a path payload input, try to run the path against the routes, update matching routes information in consequence and dictamine if the flow has been broken.
-     * */
-    getRoutingStateFromPathPayload(currentRoute, pathPayload) {
-        const { path, params } = (0, router_utils_1.getPathParamsFromPathPayload)(pathPayload);
+   * Given a path payload input, try to run the path against the routes, update matching routes information in consequence and dictamine if the flow has been broken.
+   * */ getRoutingStateFromPathPayload(currentRoute, pathPayload) {
+        const { path, params } = getPathParamsFromPathPayload(pathPayload);
         /**
-         * shorthand function to update the matching information given a path
-         */
-        const getRoutingStateFromPath = (seekPath) => {
+     * shorthand function to update the matching information given a path
+     */ const getRoutingStateFromPath = (seekPath)=>{
             const matchedRoute = this.getRouteByPath(seekPath);
             if (!matchedRoute) {
                 return {
                     currentRoute,
                     matchedRoute: null,
                     params: {},
-                    isFlowBroken: true,
+                    isFlowBroken: true
                 };
             }
             return {
                 currentRoute,
-                matchedRoute: { ...matchedRoute, path: seekPath },
+                matchedRoute: {
+                    ...matchedRoute,
+                    path: seekPath
+                },
                 params,
-                isFlowBroken: false,
+                isFlowBroken: false
             };
         };
         /**
-         * Given a valid path: 'Flow1/Subflow1' we are in one of the two scenarios below.
-         */
-        //  1. Received __PATH_PAYLOAD__Subflow2, so we need to first try to concatenate it with Flow1 (lastRoutePath)
+     * Given a valid path: 'Flow1/Subflow1' we are in one of the two scenarios below.
+     */ //  1. Received __PATH_PAYLOAD__Subflow2, so we need to first try to concatenate it with Flow1 (lastRoutePath)
         if (currentRoute?.path) {
             const routingState = getRoutingStateFromPath(`${currentRoute.path}/${path}`);
             if (routingState.matchedRoute) {
@@ -325,6 +320,14 @@ class Router {
         // 2. Received __PATH_PAYLOAD__Flow1/Subflow1, so we can resolve it directly
         return getRoutingStateFromPath(path);
     }
+    constructor(routes, routeInspector = undefined){
+        _define_property(this, "routes", void 0);
+        _define_property(this, "routeInspector", void 0);
+        this.routes = routes;
+        this.routeInspector = routeInspector || new RouteInspector();
+    }
 }
-exports.Router = Router;
+
+export { Router };
+
 //# sourceMappingURL=router.js.map