@botonic/core 1.0.0-dev.0 → 2.23.0

package/src/output-parser/parsers.ts

@@ -1,190 +0,0 @@
-import { EventTypes } from '../models/events'
-import { BotonicMessageEvent } from '../models/events/message'
-import { Button, WithButtons } from '../models/events/message/buttons'
-import {
-  CarouselElement,
-  CarouselMessageEvent,
-} from '../models/events/message/carousel'
-import { CustomMessageEvent } from '../models/events/message/custom'
-import { LocationMessageEvent } from '../models/events/message/location'
-import {
-  AudioMessageEvent,
-  DocumentMessageEvent,
-  ImageMessageEvent,
-  VideoMessageEvent,
-} from '../models/events/message/media'
-import { PostbackMessageEvent } from '../models/events/message/postback'
-import { Reply, WithReplies } from '../models/events/message/replies'
-import { TextMessageEvent } from '../models/events/message/text'
-import { TEXT_NODE_NAME } from '.'
-import { parseBoolean, parseNumber } from './util'
-
-export type ParseFunction<Out> = (args: {
-  toParse: any
-  parsed?: any
-}) => {
-  toParse: any
-  parsed: Partial<Out>
-}
-
-// COMMON
-export const parseMessage: ParseFunction<BotonicMessageEvent> = args => {
-  const typingAndDelay = {}
-  if (args.toParse.delay !== undefined) {
-    typingAndDelay['delay'] = parseNumber(args.toParse.delay)
-  }
-  if (args.toParse.typing !== undefined) {
-    typingAndDelay['typing'] = parseNumber(args.toParse.typing)
-  }
-  return {
-    toParse: args.toParse,
-    parsed: {
-      // Following properties added later before saving event: eventId, userId, createdAt, from, ack
-      eventType: EventTypes.MESSAGE,
-      type: args.toParse.type,
-      ...typingAndDelay,
-    },
-  }
-}
-
-// BUTTONS
-export const parseButton = (button: any): Button => {
-  const title = button[TEXT_NODE_NAME]
-  if ('payload' in button) {
-    return { title, payload: button.payload }
-  }
-  if ('url' in button) {
-    const b = { title, url: button.url, target: button.target }
-    if (button.target) b.target = button.target
-    return b
-  }
-  if ('webview' in button) {
-    return {
-      title,
-      webview: button.webview,
-      params: button.params,
-    }
-  }
-  throw new Error('Invalid parsed Button')
-}
-
-export const parseButtons: ParseFunction<WithButtons> = args => {
-  const hasButtons = args.toParse?.button?.length > 0
-  let buttons: Button[] = []
-  if (hasButtons) {
-    buttons = args.toParse.button.map(button => parseButton(button))
-  }
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      buttons,
-    },
-  }
-}
-
-// REPLIES
-export const parseReply = (reply: any): Reply => ({
-  title: reply[TEXT_NODE_NAME],
-  payload: reply.payload,
-})
-
-export const parseReplies: ParseFunction<WithReplies> = args => {
-  const hasReplies = args.toParse?.reply?.length > 0
-  let replies: Reply[] = []
-  if (hasReplies) {
-    replies = args.toParse.reply.map(reply => parseReply(reply))
-  }
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      replies,
-    },
-  }
-}
-
-// TEXT
-export const parseText: ParseFunction<TextMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      text: args.toParse[TEXT_NODE_NAME] || args.toParse.data,
-      markdown: parseBoolean(args.toParse.markdown),
-    },
-  }
-}
-
-// POSTBACK
-
-export const parsePostback: ParseFunction<PostbackMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      payload: args.toParse.payload,
-    },
-  }
-}
-
-// MEDIA
-export const parseMedia: ParseFunction<
-  | AudioMessageEvent
-  | DocumentMessageEvent
-  | ImageMessageEvent
-  | VideoMessageEvent
-> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      src: args.toParse.src || args.toParse.data,
-    },
-  }
-}
-
-// LOCATION
-export const parseLocation: ParseFunction<LocationMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      lat: args.toParse.lat,
-      long: args.toParse.long,
-    },
-  }
-}
-
-// CAROUSEL
-export const parseElement = (element: any): CarouselElement => {
-  const e: CarouselElement = {
-    pic: element.pic,
-    title: element.title,
-    subtitle: element.desc,
-  }
-  const hasButtons = element.button !== undefined
-  if (hasButtons) e.buttons = element.button.map(b => parseButton(b))
-  return e
-}
-
-export const parseCarousel: ParseFunction<CarouselMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      elements: args.toParse.element.map(element => parseElement(element)),
-    },
-  }
-}
-
-// CUSTOM
-export const parseCustom: ParseFunction<CustomMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      customTypeName: JSON.parse(args.toParse.json).customTypeName,
-    },
-  }
-}

package/src/output-parser/util.ts

@@ -1,8 +0,0 @@
-export function parseNumber(strNumber: string): number {
-  return parseInt(strNumber)
-}
-
-export function parseBoolean(strNumber: string): boolean {
-  if (strNumber === '0') return false
-  return true
-}

package/src/plugins.ts

@@ -1,49 +0,0 @@
-import { Input, PluginConfig, Session } from './index'
-import { BotonicEvent } from './models/events'
-
-type PluginMode = 'pre' | 'post'
-
-export function loadPlugins(plugins: PluginConfig<any>[]): any {
-  if (!plugins) return []
-  const _plugins = {}
-  const pluginsLength = plugins.length
-  for (let i = 0; i < pluginsLength; i++) {
-    const pluginRequired = plugins[i].resolve
-    const options = plugins[i].options
-    const Plugin = pluginRequired.default
-    const instance = new Plugin(options)
-    const id = plugins[i].id || `${instance.constructor.name}`
-    _plugins[id] = instance
-    _plugins[id].id = id
-    _plugins[id].config = options
-    _plugins[id].name = `${instance.constructor.name}`
-  }
-  return _plugins
-}
-
-export async function runPlugins(
-  plugins: any, // // TODO: Add type for resolvedPlugins, they differ from loaded plugins
-  mode: PluginMode,
-  input: Input,
-  session: Session,
-  lastRoutePath: string,
-  response: string | null = null,
-  parsedResponse: Partial<BotonicEvent>[] | null = null
-): Promise<void> {
-  for (const key in plugins) {
-    const p = await plugins[key]
-    try {
-      if (mode == 'pre') await p.pre({ input, session, lastRoutePath })
-      if (mode == 'post')
-        await p.post({
-          input,
-          session,
-          lastRoutePath,
-          response,
-          parsedResponse,
-        })
-    } catch (e) {
-      console.log(e)
-    }
-  }
-}

package/src/router.ts

@@ -1,316 +0,0 @@
-import { RouteInspector } from './debug/inspector'
-import { NoMatchingRouteError } from './errors'
-import { Input, Route, Routes, Session } from './index'
-import { isFunction } from './utils'
-
-interface RouteParams {
-  route: Route
-  params: any
-}
-type MatchingProp =
-  | 'text'
-  | 'payload'
-  | 'intent'
-  | 'type'
-  | 'input'
-  | 'session'
-  | 'request'
-
-type Matcher = string | RegExp | ((args) => boolean)
-
-export class Router {
-  routes: Routes
-  routeInspector: RouteInspector
-  lastRoutePath: string | null
-  /**
-   * @param {Route[]} routes
-   * @param routeInspector
-   */
-  constructor(
-    routes: Routes,
-    routeInspector: RouteInspector | undefined = undefined
-  ) {
-    this.routes = routes
-    this.routeInspector = routeInspector || new RouteInspector()
-  }
-
-  // eslint-disable-next-line complexity
-  processInput(
-    input: Input,
-    session: Partial<Session> = {},
-    lastRoutePath: string | null = null
-  ): any {
-    let routeParams: any = {}
-    if (input.payload && input.payload.includes('__PATH_PAYLOAD__')) {
-      const pathParam = input.payload.split('__PATH_PAYLOAD__')
-      routeParams.route = this.getRouteByPath(pathParam[1], this.routes)
-    }
-    const pathParams = this.getOnFinishParams(input)
-    let brokenFlow = false
-    const lastRoute = this.getRouteByPath(lastRoutePath, this.routes)
-    if (!lastRoute && input.path)
-      routeParams.route = this.getRouteByPath(input.path, this.routes)
-    if (lastRoute && lastRoute.childRoutes && !routeParams.route)
-      //get route depending of current ChildRoute
-      routeParams = this.getRoute(
-        input,
-        lastRoute.childRoutes,
-        session as Session,
-        lastRoutePath
-      )
-    if (!routeParams || !Object.keys(routeParams).length) {
-      /*
-          we couldn't find a route in the state of the lastRoute, so let's find in
-          the general conf.route
-        */
-      brokenFlow = Boolean(lastRoutePath)
-      routeParams = this.getRoute(
-        input,
-        this.routes,
-        session as Session,
-        lastRoutePath
-      )
-    }
-    try {
-      if (pathParams) {
-        const searchParams = new URLSearchParams(pathParams)
-        for (const [key, value] of searchParams) {
-          routeParams.params
-            ? (routeParams.params[key] = value)
-            : (routeParams.params = { [key]: value })
-        }
-      }
-    } catch (e) {}
-    if (routeParams && Object.keys(routeParams).length) {
-      //get in childRoute if one has path ''
-      let defaultAction
-      if (routeParams.route) {
-        if (
-          !routeParams.route.path &&
-          routeParams.route.childRoutes &&
-          routeParams.route.childRoutes.length
-        ) {
-          defaultAction = this.getRoute(
-            { path: '' },
-            routeParams.route.childRoutes,
-            session as Session,
-            lastRoutePath
-          )
-        }
-        if ('action' in routeParams.route) {
-          if (
-            brokenFlow &&
-            routeParams.route.ignoreRetry != true &&
-            lastRoute &&
-            (session.__retries || 0) < (lastRoute.retry || 0) &&
-            routeParams.route.path != lastRoute.action
-          ) {
-            session.__retries = session.__retries ? session.__retries + 1 : 1
-            // The flow was broken, but we want to recover it
-            return {
-              action: routeParams.route.action,
-              params: routeParams.params,
-              retryAction: lastRoute ? lastRoute.action : null,
-              defaultAction: defaultAction ? defaultAction.route.action : null,
-              lastRoutePath: lastRoutePath,
-            }
-          } else {
-            session.__retries = 0
-            if (lastRoutePath && !brokenFlow)
-              lastRoutePath = `${lastRoutePath}/${routeParams.route.path}`
-            else lastRoutePath = routeParams.route.path
-            return {
-              action: routeParams.route.action,
-              params: routeParams.params,
-              retryAction: null,
-              defaultAction: defaultAction ? defaultAction.route.action : null,
-              lastRoutePath: lastRoutePath,
-            }
-          }
-        } else if (defaultAction) {
-          return {
-            action: defaultAction.route.action,
-            params: defaultAction.params,
-            lastRoutePath: lastRoutePath,
-          }
-        } else if ('redirect' in routeParams.route) {
-          lastRoutePath = routeParams.route.redirect
-          const redirectRoute = this.getRouteByPath(lastRoutePath, this.routes)
-          if (redirectRoute) {
-            return {
-              action: redirectRoute.action,
-              params: redirectRoute.params,
-              lastRoutePath: lastRoutePath,
-            }
-          }
-        }
-      }
-    }
-    const notFound = this.getRouteByPath('404', this.routes)
-    if (!notFound) throw new NoMatchingRouteError(input)
-    if (lastRoute && (session.__retries || 0) < (lastRoute.retry || 0)) {
-      session.__retries = session.__retries ? session.__retries + 1 : 1
-      return {
-        action: notFound.action,
-        params: {},
-        retryAction: lastRoute.action,
-        lastRoutePath: lastRoutePath,
-      }
-    } else {
-      this.lastRoutePath = null
-      session.__retries = 0
-      return {
-        action: notFound.action,
-        params: {},
-        retryAction: null,
-        lastRoutePath: lastRoutePath,
-      }
-    }
-  }
-
-  getOnFinishParams(input: Input): string | undefined {
-    try {
-      if (!input.payload) {
-        return undefined
-      }
-      const params = input.payload.split('__PATH_PAYLOAD__')
-      if (params.length < 2) {
-        return undefined
-      }
-      const pathParams = params[1].split('?')
-      if (pathParams.length > 0) {
-        input.path = pathParams[0]
-        delete input.payload
-      }
-      if (pathParams.length > 1) {
-        return pathParams[1]
-      }
-    } catch (e) {
-      console.error('ERROR getOnFinishParams', e)
-    }
-    return undefined
-  }
-
-  /**
-   * @return {null|RouteParams}
-   */
-  getRoute(
-    input: Input | Partial<Input>,
-    routes: Routes,
-    session: Session,
-    lastRoutePath: string | null
-  ): RouteParams | null {
-    const computedRoutes = isFunction(routes)
-      ? // @ts-ignore
-        routes({ input, session, lastRoutePath })
-      : routes
-    /* 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 */
-    /** @type {{ [key: string]: string }}*/
-    let params = {}
-    const route = computedRoutes.find(r =>
-      Object.entries(r)
-        .filter(([key, _]) => key != 'action' && key != 'childRoutes')
-        .some(([key, value]) => {
-          const match = this.matchRoute(
-            r,
-            key as MatchingProp,
-            value as Matcher,
-            input as Input,
-            session,
-            lastRoutePath
-          )
-          try {
-            params = match.groups
-          } catch (e) {}
-          return Boolean(match)
-        })
-    )
-    if (route) {
-      return { route, params }
-    }
-    return null
-  }
-
-  getRouteByPath(
-    path: string | null,
-    routeList: Routes | null = null
-  ): Route | null {
-    if (!path) return null
-    let route: Route | null = null
-    routeList = routeList || this.routes
-    const [currentPath, ...childPath] = path.split('/')
-    if (Array.isArray(routeList)) {
-      for (const r of routeList) {
-        //iterate over all routeList
-        if (r.path == currentPath) {
-          route = r
-          if (r.childRoutes && r.childRoutes.length && childPath.length > 0) {
-            //evaluate childroute over next actions
-            route = this.getRouteByPath(childPath.join('/'), r.childRoutes)
-            if (route) return route
-          } else if (childPath.length === 0) return route //last action and found route
-        }
-      }
-    }
-    return null
-  }
-
-  /**
-   * @return {Params|boolean}
-   */
-  matchRoute(
-    route: Route,
-    prop: MatchingProp,
-    matcher: Matcher,
-    input: Input,
-    session: Session,
-    lastRoutePath: string | null
-  ): any {
-    /*
-        prop: ('text' | 'payload' | 'intent' | 'type' | 'input' | 'session' | 'request' ...)
-        matcher: (string: exact match | regex: regular expression match | function: return true)
-        input: user input object, ex: {type: 'text', data: 'Hi'}
-      */
-    /** @type {any} */
-    let value: any = ''
-    if (Object.keys(input).indexOf(prop) > -1) value = input[prop]
-    if (prop === 'text') {
-      if (input.type === 'text') value = input.data
-    } else if (prop === 'input') value = input
-    else if (prop === 'session') value = session
-    else if (prop === 'request') value = { input, session, lastRoutePath }
-    const matched = this.matchValue(matcher, value)
-    if (matched) {
-      this.routeInspector.routeMatched(route, prop, matcher, value)
-    } else {
-      this.routeInspector.routeNotMatched(route, prop, matcher, value)
-    }
-    return matched
-  }
-
-  /**
-   *
-   * @return {*|boolean|Params}
-   */
-  matchValue(
-    matcher: string | RegExp | ((args) => boolean),
-    value: any
-  ): boolean {
-    if (typeof matcher === 'string') {
-      // TODO should this be === to avoid matching '' with undefined?
-      return value == matcher
-    }
-    if (matcher instanceof RegExp) {
-      // check if undefined to avoid conversion to 'undefined'
-      if (value === undefined) {
-        return false
-      }
-      return Boolean(matcher.exec(value))
-    }
-    if (typeof matcher === 'function') {
-      return matcher(value)
-    }
-    return false
-  }
-}

package/src/utils.ts

@@ -1,84 +0,0 @@
-export const isNode = (): boolean => {
-  // @ts-ignore
-  return typeof IS_NODE !== 'undefined'
-    ? // @ts-ignore
-      IS_NODE
-    : typeof process !== 'undefined' &&
-        process.versions !== null &&
-        process.versions.node !== null
-}
-
-export const isBrowser = (): boolean => {
-  // @ts-ignore
-  return typeof IS_BROWSER !== 'undefined'
-    ? // @ts-ignore
-      IS_BROWSER
-    : typeof window !== 'undefined' &&
-        typeof window.document !== 'undefined' &&
-        !window.process
-}
-
-export function getWebpackEnvVar(
-  webpackEnvVar: string | false,
-  name: string,
-  defaultValue: string
-): string {
-  return (
-    webpackEnvVar ||
-    (typeof process !== 'undefined' && process.env[name]) ||
-    defaultValue
-  )
-}
-
-export const isMobile = (mobileBreakpoint = 460): boolean => {
-  if (isBrowser()) {
-    const w = Math.max(
-      document.documentElement.clientWidth,
-      window.innerWidth || 0
-    )
-    if (w < mobileBreakpoint) {
-      return true
-    }
-  }
-  return false
-}
-export function isFunction(o: any): boolean {
-  return typeof o === 'function'
-}
-
-export const params2queryString = (params: { [key: string]: string }): string =>
-  Object.entries(params)
-    .map(([k, v]: any) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
-    .join('&')
-
-// Joins path segments.  Preserves initial "/" and resolves ".." and "."
-// Does not support using ".." to go above/outside the root.
-// This means that join("foo", "../../bar") will not resolve to "../bar"
-export const join = (...segments: string[]): string => {
-  // Split the inputs into a list of path commands.
-  let parts: string[] = []
-  for (let i = 0, l = segments.length; i < l; i++) {
-    parts = parts.concat(segments[i].split('/'))
-  }
-  // Interpret the path commands to get the new resolved path.
-  const newParts: string[] = []
-  for (let i = 0, l = parts.length; i < l; i++) {
-    const part = parts[i]
-    // Remove leading and trailing slashes
-    // Also remove "." segments
-    if (!part || part === '.') continue
-    // Interpret ".." to pop the last segment
-    if (part === '..') newParts.pop()
-    // Push new path segments.
-    else newParts.push(part)
-  }
-  // Preserve the initial slash if there was one.
-  // @ts-ignore
-  if (parts[0] === '') newParts.unshift('')
-  // Turn back into a single string path.
-  return newParts.join('/') || (newParts.length ? '/' : '.')
-}
-
-// A simple function to get the dirname of a path
-// Trailing slashes are ignored. Leading slash is preserved.
-export const dirname = (path: string): string => join(path, '..')