@botonic/core 1.0.0-dev.2 → 2.23.1

package/src/output-parser/parsers.ts

@@ -1,202 +0,0 @@
-import {
-  AudioMessageEvent,
-  BotonicMessageEvent,
-  Button,
-  CarouselElement,
-  CarouselMessageEvent,
-  CustomMessageEvent,
-  DocumentMessageEvent,
-  EventTypes,
-  ImageMessageEvent,
-  LocationMessageEvent,
-  PostbackMessageEvent,
-  Reply,
-  TextMessageEvent,
-  VideoMessageEvent,
-  WithButtons,
-  WithReplies,
-} from '../models'
-import { TEXT_NODE_NAME } from './botonic-output-parser'
-
-export function parseNumber(strNumber: string): number {
-  return parseInt(strNumber)
-}
-
-export function parseBoolean(strNumber: string): boolean {
-  if (strNumber === '0') return false
-  return true
-}
-
-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,
-      ack: args.toParse.ack,
-      from: args.toParse.from,
-      channel: args.toParse.channel,
-      idFromChannel: args.toParse.idFromChannel,
-      ...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],
-      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,
-    },
-  }
-}
-
-// 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,
-      json: JSON.parse(args.toParse.json),
-    },
-  }
-}

package/src/plugins.ts

@@ -1,59 +0,0 @@
-import {
-  BotonicEvent,
-  BotState,
-  Input,
-  PluginConfig,
-  RoutePath,
-  Session,
-} from './models'
-
-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,
-  botState: BotState,
-  response: string | null = null,
-  messageEvents: Partial<BotonicEvent>[] | null = null,
-  dataProvider?: any // TODO: type as dataProvider
-): Promise<void> {
-  for (const key in plugins) {
-    const p = await plugins[key]
-    try {
-      if (mode === 'pre')
-        await p.pre({ input, session, botState, dataProvider, plugins })
-      if (mode === 'post')
-        await p.post({
-          input,
-          session,
-          botState,
-          response,
-          messageEvents,
-          dataProvider,
-          plugins,
-        })
-    } catch (e) {
-      console.log(e)
-    }
-  }
-}

package/src/routing/index.ts

@@ -1,2 +0,0 @@
-export * from './router'
-export * from './router-utils'

package/src/routing/router-utils.ts

@@ -1,100 +0,0 @@
-import {
-  EMPTY_ACTION_PATH,
-  NOT_FOUND_PATH,
-  PATH_PAYLOAD_IDENTIFIER,
-  PATH_PAYLOAD_REGEXP,
-} from '../constants'
-import {
-  Action,
-  BotRequest,
-  Input,
-  Params,
-  PathParams,
-  Route,
-  Routes,
-} from '../models'
-
-export class NoMatchingRouteError extends Error {
-  input: Input
-  constructor(input: Input) {
-    super(
-      `No route found for input '${JSON.stringify(
-        input
-      )}' and no ${NOT_FOUND_PATH} route defined`
-    )
-    this.input = input
-  }
-}
-
-export function isPathPayload(payload?: string): boolean {
-  if (!payload) return false
-  const isPathPayload = PATH_PAYLOAD_REGEXP.exec(payload)
-  return Boolean(isPathPayload)
-}
-
-export function getPathParamsFromPathPayload(payload?: string): PathParams {
-  const defaultPathParams = {
-    path: null,
-    params: {},
-  }
-  if (!payload) return defaultPathParams
-  if (!isPathPayload(payload)) return defaultPathParams
-  try {
-    const pathWithParams = payload.split(PATH_PAYLOAD_IDENTIFIER)[1]
-    if (!pathWithParams) {
-      throw `${PATH_PAYLOAD_IDENTIFIER} is empty`
-    }
-    const [path, params] = pathWithParams.split('?')
-    return { path: path ?? null, params: pathParamsToParams(params) }
-  } catch (e) {
-    console.error('Error getting path and params from input.payload:', e)
-    return defaultPathParams
-  }
-}
-
-export function pathParamsToParams(pathParams?: string): Params {
-  if (!pathParams) return {}
-  try {
-    const params = {}
-    const searchParams = new URLSearchParams(pathParams)
-    for (const [key, value] of searchParams) {
-      params[key] = value
-    }
-    return params
-  } catch (e) {
-    return {}
-  }
-}
-
-export function getEmptyAction(childRoutes?: Route[]): Action {
-  if (!childRoutes) return null
-  const emptyActionRoute = childRoutes.find(r => r.path === EMPTY_ACTION_PATH)
-  if (!emptyActionRoute) return null
-  return emptyActionRoute.action
-}
-
-export function getNotFoundAction(input: Input, routes: Route[]): Action {
-  const notFoundActionRoute = routes.find(r => r.path === NOT_FOUND_PATH)
-  if (!notFoundActionRoute) throw new NoMatchingRouteError(input)
-  return notFoundActionRoute.action
-}
-
-export async function getComputedRoutes(
-  routes: Routes,
-  request: BotRequest
-): Promise<Route[]> {
-  if (routes instanceof Function) {
-    return await getComputedRoutes(await routes(request), request)
-  }
-  for (const [key, route] of Object.entries(routes) as any) {
-    if (route.childRoutes && route.childRoutes instanceof Function) {
-      routes[key].childRoutes = await getComputedRoutes(
-        await route.childRoutes(request),
-        request
-      )
-    } else {
-      routes[key] = route
-    }
-  }
-  return routes
-}