@budibase/string-templates 2.22.0 → 2.22.2

package/src/helpers/{javascript.js → javascript.ts}

@@ -1,22 +1,24 @@
-const { atob, isBackendService, isJSAllowed } = require("../utilities")
-const cloneDeep = require("lodash.clonedeep")
-const { LITERAL_MARKER } = require("../helpers/constants")
-const { getJsHelperList } = require("./list")
-const { iifeWrapper } = require("../iife")
+import { atob, isJSAllowed } from "../utilities"
+import cloneDeep from "lodash/fp/cloneDeep"
+import { LITERAL_MARKER } from "../helpers/constants"
+import { getJsHelperList } from "./list"
+import { iifeWrapper } from "../iife"
 
 // The method of executing JS scripts depends on the bundle being built.
 // This setter is used in the entrypoint (either index.js or index.mjs).
-let runJS
-module.exports.setJSRunner = runner => (runJS = runner)
-module.exports.removeJSRunner = () => {
+let runJS: ((js: string, context: any) => any) | undefined = undefined
+export const setJSRunner = (runner: typeof runJS) => (runJS = runner)
+
+export const removeJSRunner = () => {
   runJS = undefined
 }
 
-let onErrorLog
-module.exports.setOnErrorLog = delegate => (onErrorLog = delegate)
+let onErrorLog: (message: Error) => void
+export const setOnErrorLog = (delegate: typeof onErrorLog) =>
+  (onErrorLog = delegate)
 
 // Helper utility to strip square brackets from a value
-const removeSquareBrackets = value => {
+const removeSquareBrackets = (value: string) => {
   if (!value || typeof value !== "string") {
     return value
   }
@@ -30,7 +32,7 @@ const removeSquareBrackets = value => {
 
 // Our context getter function provided to JS code as $.
 // Extracts a value from context.
-const getContextValue = (path, context) => {
+const getContextValue = (path: string, context: any) => {
   let data = context
   path.split(".").forEach(key => {
     if (data == null || typeof data !== "object") {
@@ -42,8 +44,8 @@ const getContextValue = (path, context) => {
 }
 
 // Evaluates JS code against a certain context
-module.exports.processJS = (handlebars, context) => {
-  if (!isJSAllowed() || (isBackendService() && !runJS)) {
+export function processJS(handlebars: string, context: any) {
+  if (!isJSAllowed() || !runJS) {
     throw new Error("JS disabled in environment.")
   }
   try {
@@ -53,8 +55,8 @@ module.exports.processJS = (handlebars, context) => {
 
     // Transform snippets into an object for faster access, and cache previously
     // evaluated snippets
-    let snippetMap = {}
-    let snippetCache = {}
+    let snippetMap: any = {}
+    let snippetCache: any = {}
     for (let snippet of context.snippets || []) {
       snippetMap[snippet.name] = snippet.code
     }
@@ -64,7 +66,7 @@ module.exports.processJS = (handlebars, context) => {
     // app context.
     const clonedContext = cloneDeep({ ...context, snippets: null })
     const sandboxContext = {
-      $: path => getContextValue(path, clonedContext),
+      $: (path: string) => getContextValue(path, clonedContext),
       helpers: getJsHelperList(),
 
       // Proxy to evaluate snippets when running in the browser
@@ -84,7 +86,7 @@ module.exports.processJS = (handlebars, context) => {
     // Create a sandbox with our context and run the JS
     const res = { data: runJS(js, sandboxContext) }
     return `{{${LITERAL_MARKER} js_result-${JSON.stringify(res)}}}`
-  } catch (error) {
+  } catch (error: any) {
     onErrorLog && onErrorLog(error)
 
     if (error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {

package/src/helpers/{list.js → list.ts}

@@ -1,7 +1,7 @@
-const { date, duration } = require("./date")
+import { date, duration } from "./date"
 
 // https://github.com/evanw/esbuild/issues/56
-const externalCollections = {
+const getExternalCollections = (): Record<string, () => any> => ({
   math: require("@budibase/handlebars-helpers/lib/math"),
   array: require("@budibase/handlebars-helpers/lib/array"),
   number: require("@budibase/handlebars-helpers/lib/number"),
@@ -11,32 +11,32 @@ const externalCollections = {
   object: require("@budibase/handlebars-helpers/lib/object"),
   regex: require("@budibase/handlebars-helpers/lib/regex"),
   uuid: require("@budibase/handlebars-helpers/lib/uuid"),
-}
+})
 
-const helpersToRemoveForJs = ["sortBy"]
-module.exports.helpersToRemoveForJs = helpersToRemoveForJs
+export const helpersToRemoveForJs = ["sortBy"]
 
 const addedHelpers = {
   date: date,
   duration: duration,
 }
 
-let helpers = undefined
+let helpers: Record<string, any>
 
-module.exports.getJsHelperList = () => {
+export function getJsHelperList() {
   if (helpers) {
     return helpers
   }
 
   helpers = {}
-  for (let collection of Object.values(externalCollections)) {
+  for (let collection of Object.values(getExternalCollections())) {
     for (let [key, func] of Object.entries(collection)) {
       // Handlebars injects the hbs options to the helpers by default. We are adding an empty {} as a last parameter to simulate it
-      helpers[key] = (...props) => func(...props, {})
+      helpers[key] = (...props: any) => func(...props, {})
     }
   }
-  for (let key of Object.keys(addedHelpers)) {
-    helpers[key] = addedHelpers[key]
+  helpers = {
+    ...helpers,
+    addedHelpers,
   }
 
   for (const toRemove of helpersToRemoveForJs) {

package/src/iife.ts

@@ -0,0 +1,3 @@
+export const iifeWrapper = (script: string) => {
+  return `(function(){\n${script}\n})();`
+}

package/src/{index.js → index.ts}

@@ -1,24 +1,30 @@
-const vm = require("vm")
-const handlebars = require("handlebars")
-const { registerAll, registerMinimum } = require("./helpers/index")
-const processors = require("./processors")
-const { atob, btoa, isBackendService } = require("./utilities")
-const { iifeWrapper } = require("./iife")
-const manifest = require("../manifest.json")
-const {
+import { Context, createContext, runInNewContext } from "vm"
+import { create } from "handlebars"
+import { registerAll, registerMinimum } from "./helpers/index"
+import { preprocess, postprocess } from "./processors"
+import {
+  atob,
+  btoa,
+  isBackendService,
   FIND_HBS_REGEX,
   FIND_ANY_HBS_REGEX,
   findDoubleHbsInstances,
-} = require("./utilities")
-const { convertHBSBlock } = require("./conversion")
-const javascript = require("./helpers/javascript")
-const { helpersToRemoveForJs } = require("./helpers/list")
+} from "./utilities"
+import { convertHBSBlock } from "./conversion"
+import { setJSRunner, removeJSRunner } from "./helpers/javascript"
+import { helpersToRemoveForJs } from "./helpers/list"
 
-const hbsInstance = handlebars.create()
+import manifest from "./manifest.json"
+import { ProcessOptions } from "./types"
+
+export { setJSRunner, setOnErrorLog } from "./helpers/javascript"
+export { iifeWrapper } from "./iife"
+
+const hbsInstance = create()
 registerAll(hbsInstance)
-const hbsInstanceNoHelpers = handlebars.create()
+const hbsInstanceNoHelpers = create()
 registerMinimum(hbsInstanceNoHelpers)
-const defaultOpts = {
+const defaultOpts: ProcessOptions = {
   noHelpers: false,
   cacheTemplates: false,
   noEscaping: false,
@@ -29,7 +35,7 @@ const defaultOpts = {
 /**
  * Utility function to check if the object is valid.
  */
-function testObject(object) {
+function testObject(object: any) {
   // JSON stringify will fail if there are any cycles, stops infinite recursion
   try {
     JSON.stringify(object)
@@ -41,8 +47,8 @@ function testObject(object) {
 /**
  * Creates a HBS template function for a given string, and optionally caches it.
  */
-let templateCache = {}
-function createTemplate(string, opts) {
+const templateCache: Record<string, HandlebarsTemplateDelegate<any>> = {}
+function createTemplate(string: string, opts?: ProcessOptions) {
   opts = { ...defaultOpts, ...opts }
 
   // Finalising adds a helper, can't do this with no helpers
@@ -53,11 +59,11 @@ function createTemplate(string, opts) {
     return templateCache[key]
   }
 
-  string = processors.preprocess(string, opts)
+  string = preprocess(string, opts)
 
   // Optionally disable built in HBS escaping
   if (opts.noEscaping) {
-    string = exports.disableEscaping(string)
+    string = disableEscaping(string)
   }
 
   // This does not throw an error when template can't be fulfilled,
@@ -78,24 +84,25 @@ function createTemplate(string, opts) {
  * @param {object|undefined} [opts] optional - specify some options for processing.
  * @returns {Promise<object|array>} The structure input, as fully updated as possible.
  */
-module.exports.processObject = async (object, context, opts) => {
+export async function processObject<T extends Record<string, any>>(
+  object: T,
+  context: object,
+  opts?: { noHelpers?: boolean; escapeNewlines?: boolean; onlyFound?: boolean }
+): Promise<T> {
   testObject(object)
-  for (let key of Object.keys(object || {})) {
+
+  for (const key of Object.keys(object || {})) {
     if (object[key] != null) {
-      let val = object[key]
+      const val = object[key]
+      let parsedValue
       if (typeof val === "string") {
-        object[key] = await module.exports.processString(
-          object[key],
-          context,
-          opts
-        )
+        parsedValue = await processString(object[key], context, opts)
       } else if (typeof val === "object") {
-        object[key] = await module.exports.processObject(
-          object[key],
-          context,
-          opts
-        )
+        parsedValue = await processObject(object[key], context, opts)
       }
+
+      // @ts-ignore
+      object[key] = parsedValue
     }
   }
   return object
@@ -109,9 +116,13 @@ module.exports.processObject = async (object, context, opts) => {
  * @param {object|undefined} [opts] optional - specify some options for processing.
  * @returns {Promise<string>} The enriched string, all templates should have been replaced if they can be.
  */
-module.exports.processString = async (string, context, opts) => {
+export async function processString(
+  string: string,
+  context: object,
+  opts?: ProcessOptions
+): Promise<string> {
   // TODO: carry out any async calls before carrying out async call
-  return module.exports.processStringSync(string, context, opts)
+  return processStringSync(string, context, opts)
 }
 
 /**
@@ -123,14 +134,18 @@ module.exports.processString = async (string, context, opts) => {
  * @param {object|undefined} [opts] optional - specify some options for processing.
  * @returns {object|array} The structure input, as fully updated as possible.
  */
-module.exports.processObjectSync = (object, context, opts) => {
+export function processObjectSync(
+  object: { [x: string]: any },
+  context: any,
+  opts: any
+): object | Array<any> {
   testObject(object)
   for (let key of Object.keys(object || {})) {
     let val = object[key]
     if (typeof val === "string") {
-      object[key] = module.exports.processStringSync(object[key], context, opts)
+      object[key] = processStringSync(object[key], context, opts)
     } else if (typeof val === "object") {
-      object[key] = module.exports.processObjectSync(object[key], context, opts)
+      object[key] = processObjectSync(object[key], context, opts)
     }
   }
   return object
@@ -144,29 +159,32 @@ module.exports.processObjectSync = (object, context, opts) => {
  * @param {object|undefined} [opts] optional - specify some options for processing.
  * @returns {string} The enriched string, all templates should have been replaced if they can be.
  */
-module.exports.processStringSync = (string, context, opts) => {
+export function processStringSync(
+  string: string,
+  context?: object,
+  opts?: ProcessOptions
+): string {
   // Take a copy of input in case of error
   const input = string
   if (typeof string !== "string") {
     throw "Cannot process non-string types."
   }
-  function process(stringPart) {
+  function process(stringPart: string) {
     const template = createTemplate(stringPart, opts)
     const now = Math.floor(Date.now() / 1000) * 1000
-    return processors.postprocess(
-      template({
-        now: new Date(now).toISOString(),
-        __opts: {
-          ...opts,
-          input: stringPart,
-        },
-        ...context,
-      })
-    )
+    const processedString = template({
+      now: new Date(now).toISOString(),
+      __opts: {
+        ...opts,
+        input: stringPart,
+      },
+      ...context,
+    })
+    return postprocess(processedString)
   }
   try {
     if (opts && opts.onlyFound) {
-      const blocks = exports.findHBSBlocks(string)
+      const blocks = findHBSBlocks(string)
       for (let block of blocks) {
         const outcome = process(block)
         string = string.replace(block, outcome)
@@ -186,7 +204,7 @@ module.exports.processStringSync = (string, context, opts) => {
  * this function will find any double braces and switch to triple.
  * @param string the string to have double HBS statements converted to triple.
  */
-module.exports.disableEscaping = string => {
+export function disableEscaping(string: string) {
   const matches = findDoubleHbsInstances(string)
   if (matches == null) {
     return string
@@ -207,7 +225,7 @@ module.exports.disableEscaping = string => {
  * @param {string} property The property which is to be wrapped.
  * @returns {string} The wrapped property ready to be added to a templating string.
  */
-module.exports.makePropSafe = property => {
+export function makePropSafe(property: any): string {
   return `[${property}]`.replace("[[", "[").replace("]]", "]")
 }
 
@@ -217,7 +235,7 @@ module.exports.makePropSafe = property => {
  * @param [opts] optional - specify some options for processing.
  * @returns {boolean} Whether or not the input string is valid.
  */
-module.exports.isValid = (string, opts) => {
+export function isValid(string: any, opts?: any): boolean {
   const validCases = [
     "string",
     "number",
@@ -238,7 +256,7 @@ module.exports.isValid = (string, opts) => {
     })
     template(context)
     return true
-  } catch (err) {
+  } catch (err: any) {
     const msg = err && err.message ? err.message : err
     if (!msg) {
       return false
@@ -259,7 +277,7 @@ module.exports.isValid = (string, opts) => {
  * This manifest provides information about each of the helpers and how it can be used.
  * @returns The manifest JSON which has been generated from the helpers.
  */
-module.exports.getManifest = () => {
+export function getManifest() {
   return manifest
 }
 
@@ -268,8 +286,8 @@ module.exports.getManifest = () => {
  * @param handlebars the HBS expression to check
  * @returns {boolean} whether the expression is JS or not
  */
-module.exports.isJSBinding = handlebars => {
-  return module.exports.decodeJSBinding(handlebars) != null
+export function isJSBinding(handlebars: any): boolean {
+  return decodeJSBinding(handlebars) != null
 }
 
 /**
@@ -277,7 +295,7 @@ module.exports.isJSBinding = handlebars => {
  * @param javascript the JS code to encode
  * @returns {string} the JS HBS expression
  */
-module.exports.encodeJSBinding = javascript => {
+export function encodeJSBinding(javascript: string): string {
   return `{{ js "${btoa(javascript)}" }}`
 }
 
@@ -286,7 +304,7 @@ module.exports.encodeJSBinding = javascript => {
  * @param handlebars the JS HBS expression
  * @returns {string|null} the raw JS code
  */
-module.exports.decodeJSBinding = handlebars => {
+export function decodeJSBinding(handlebars: string): string | null {
   if (!handlebars || typeof handlebars !== "string") {
     return null
   }
@@ -311,7 +329,7 @@ module.exports.decodeJSBinding = handlebars => {
  * @param {string[]} strings The strings to look for.
  * @returns {boolean} Will return true if all strings found in HBS statement.
  */
-module.exports.doesContainStrings = (template, strings) => {
+export function doesContainStrings(template: string, strings: any[]): boolean {
   let regexp = new RegExp(FIND_HBS_REGEX)
   let matches = template.match(regexp)
   if (matches == null) {
@@ -319,8 +337,8 @@ module.exports.doesContainStrings = (template, strings) => {
   }
   for (let match of matches) {
     let hbs = match
-    if (exports.isJSBinding(match)) {
-      hbs = exports.decodeJSBinding(match)
+    if (isJSBinding(match)) {
+      hbs = decodeJSBinding(match)!
     }
     let allFound = true
     for (let string of strings) {
@@ -341,7 +359,7 @@ module.exports.doesContainStrings = (template, strings) => {
  * @param {string} string The string to search within.
  * @return {string[]} The found HBS blocks.
  */
-module.exports.findHBSBlocks = string => {
+export function findHBSBlocks(string: string): string[] {
   if (!string || typeof string !== "string") {
     return []
   }
@@ -362,18 +380,15 @@ module.exports.findHBSBlocks = string => {
  * @param {string} string The word or sentence to search for.
  * @returns {boolean} The this return true if the string is found, false if not.
  */
-module.exports.doesContainString = (template, string) => {
-  return exports.doesContainStrings(template, [string])
+export function doesContainString(template: any, string: any): boolean {
+  return doesContainStrings(template, [string])
 }
 
-module.exports.setJSRunner = javascript.setJSRunner
-module.exports.setOnErrorLog = javascript.setOnErrorLog
-
-module.exports.convertToJS = hbs => {
-  const blocks = exports.findHBSBlocks(hbs)
+export function convertToJS(hbs: string) {
+  const blocks = findHBSBlocks(hbs)
   let js = "return `",
-    prevBlock = null
-  const variables = {}
+    prevBlock: string | null = null
+  const variables: Record<string, any> = {}
   if (blocks.length === 0) {
     js += hbs
   }
@@ -387,7 +402,7 @@ module.exports.convertToJS = hbs => {
     prevBlock = block
     const { variable, value } = convertHBSBlock(block, count++)
     variables[variable] = value
-    js += `${stringPart.split()}\${${variable}}`
+    js += `${[stringPart]}\${${variable}}`
   }
   let varBlock = ""
   for (let [variable, value] of Object.entries(variables)) {
@@ -397,34 +412,34 @@ module.exports.convertToJS = hbs => {
   return `${varBlock}${js}`
 }
 
-module.exports.FIND_ANY_HBS_REGEX = FIND_ANY_HBS_REGEX
+const _FIND_ANY_HBS_REGEX = FIND_ANY_HBS_REGEX
+export { _FIND_ANY_HBS_REGEX as FIND_ANY_HBS_REGEX }
 
-const errors = require("./errors")
-// We cannot use dynamic exports, otherwise the typescript file will not be generating it
-module.exports.JsErrorTimeout = errors.JsErrorTimeout
+export { JsErrorTimeout } from "./errors"
 
-module.exports.helpersToRemoveForJs = helpersToRemoveForJs
+const _helpersToRemoveForJs = helpersToRemoveForJs
+export { _helpersToRemoveForJs as helpersToRemoveForJs }
 
 function defaultJSSetup() {
   if (!isBackendService()) {
     /**
      * Use polyfilled vm to run JS scripts in a browser Env
      */
-    javascript.setJSRunner((js, context) => {
+    setJSRunner((js: string, context: Context) => {
       context = {
         ...context,
         alert: undefined,
         setInterval: undefined,
         setTimeout: undefined,
       }
-      vm.createContext(context)
-      return vm.runInNewContext(js, context, { timeout: 1000 })
+      createContext(context)
+      return runInNewContext(js, context, { timeout: 1000 })
     })
   } else {
-    javascript.removeJSRunner()
+    removeJSRunner()
   }
 }
 defaultJSSetup()
 
-module.exports.defaultJSSetup = defaultJSSetup
-module.exports.iifeWrapper = iifeWrapper
+const _defaultJSSetup = defaultJSSetup
+export { _defaultJSSetup as defaultJSSetup }

package/src/processors/{index.js → index.ts}

@@ -1,8 +1,9 @@
-const { FIND_HBS_REGEX } = require("../utilities")
-const preprocessor = require("./preprocessor")
-const postprocessor = require("./postprocessor")
+import { FIND_HBS_REGEX } from "../utilities"
+import * as preprocessor from "./preprocessor"
+import * as postprocessor from "./postprocessor"
+import { ProcessOptions } from "../types"
 
-function process(output, processors, opts) {
+function process(output: string, processors: any[], opts?: ProcessOptions) {
   for (let processor of processors) {
     // if a literal statement has occurred stop
     if (typeof output !== "string") {
@@ -21,7 +22,7 @@ function process(output, processors, opts) {
   return output
 }
 
-module.exports.preprocess = (string, opts) => {
+export function preprocess(string: string, opts: ProcessOptions) {
   let processors = preprocessor.processors
   if (opts.noFinalise) {
     processors = processors.filter(
@@ -30,7 +31,7 @@ module.exports.preprocess = (string, opts) => {
   }
   return process(string, processors, opts)
 }
-module.exports.postprocess = string => {
+export function postprocess(string: string) {
   let processors = postprocessor.processors
   return process(string, processors)
 }

package/src/processors/postprocessor.ts

@@ -0,0 +1,56 @@
+import { LITERAL_MARKER } from "../helpers/constants"
+
+export const PostProcessorNames = {
+  CONVERT_LITERALS: "convert-literals",
+}
+
+/* eslint-disable no-unused-vars */
+class Postprocessor {
+  name: string
+  private fn: any
+
+  constructor(name: string, fn: any) {
+    this.name = name
+    this.fn = fn
+  }
+
+  process(statement: any) {
+    return this.fn(statement)
+  }
+}
+
+export const processors = [
+  new Postprocessor(
+    PostProcessorNames.CONVERT_LITERALS,
+    (statement: string) => {
+      if (
+        typeof statement !== "string" ||
+        !statement.includes(LITERAL_MARKER)
+      ) {
+        return statement
+      }
+      const splitMarkerIndex = statement.indexOf("-")
+      const type = statement.substring(12, splitMarkerIndex)
+      const value = statement.substring(
+        splitMarkerIndex + 1,
+        statement.length - 2
+      )
+      switch (type) {
+        case "string":
+          return value
+        case "number":
+          return parseFloat(value)
+        case "boolean":
+          return value === "true"
+        case "object":
+          return JSON.parse(value)
+        case "js_result":
+          // We use the literal helper to process the result of JS expressions
+          // as we want to be able to return any types.
+          // We wrap the value in an abject to be able to use undefined properly.
+          return JSON.parse(value).data
+      }
+      return value
+    }
+  ),
+]