@budibase/string-templates 2.22.0 → 2.22.2

package/src/processors/preprocessor.ts

@@ -0,0 +1,82 @@
+import { HelperNames } from "../helpers"
+import { swapStrings, isAlphaNumeric } from "../utilities"
+
+const FUNCTION_CASES = ["#", "else", "/"]
+
+export const PreprocessorNames = {
+  SWAP_TO_DOT: "swap-to-dot-notation",
+  FIX_FUNCTIONS: "fix-functions",
+  FINALISE: "finalise",
+}
+
+/* eslint-disable no-unused-vars */
+class Preprocessor {
+  name: string
+  private fn: any
+
+  constructor(name: string, fn: any) {
+    this.name = name
+    this.fn = fn
+  }
+
+  process(fullString: string, statement: string, opts: Object) {
+    const output = this.fn(statement, opts)
+    const idx = fullString.indexOf(statement)
+    return swapStrings(fullString, idx, statement.length, output)
+  }
+}
+
+export const processors = [
+  new Preprocessor(PreprocessorNames.SWAP_TO_DOT, (statement: string) => {
+    let startBraceIdx = statement.indexOf("[")
+    let lastIdx = 0
+    while (startBraceIdx !== -1) {
+      // if the character previous to the literal specifier is alphanumeric this should happen
+      if (isAlphaNumeric(statement.charAt(startBraceIdx - 1))) {
+        statement = swapStrings(statement, startBraceIdx + lastIdx, 1, ".[")
+      }
+      lastIdx = startBraceIdx + 1
+      const nextBraceIdx = statement.substring(lastIdx + 1).indexOf("[")
+      startBraceIdx = nextBraceIdx > 0 ? lastIdx + 1 + nextBraceIdx : -1
+    }
+    return statement
+  }),
+
+  new Preprocessor(PreprocessorNames.FIX_FUNCTIONS, (statement: string) => {
+    for (let specialCase of FUNCTION_CASES) {
+      const toFind = `{ ${specialCase}`,
+        replacement = `{${specialCase}`
+      statement = statement.replace(new RegExp(toFind, "g"), replacement)
+    }
+    return statement
+  }),
+
+  new Preprocessor(
+    PreprocessorNames.FINALISE,
+    (statement: string, opts: { noHelpers: any }) => {
+      const noHelpers = opts && opts.noHelpers
+      let insideStatement = statement.slice(2, statement.length - 2)
+      if (insideStatement.charAt(0) === " ") {
+        insideStatement = insideStatement.slice(1)
+      }
+      if (insideStatement.charAt(insideStatement.length - 1) === " ") {
+        insideStatement = insideStatement.slice(0, insideStatement.length - 1)
+      }
+      const possibleHelper = insideStatement.split(" ")[0]
+      // function helpers can't be wrapped
+      for (let specialCase of FUNCTION_CASES) {
+        if (possibleHelper.includes(specialCase)) {
+          return statement
+        }
+      }
+      const testHelper = possibleHelper.trim().toLowerCase()
+      if (
+        !noHelpers &&
+        HelperNames().some(option => testHelper === option.toLowerCase())
+      ) {
+        insideStatement = `(${insideStatement})`
+      }
+      return `{{ all ${insideStatement} }}`
+    }
+  ),
+]

package/src/types.ts

@@ -0,0 +1,8 @@
+export interface ProcessOptions {
+  cacheTemplates?: boolean
+  noEscaping?: boolean
+  noHelpers?: boolean
+  noFinalise?: boolean
+  escapeNewlines?: boolean
+  onlyFound?: boolean
+}

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

@@ -1,28 +1,28 @@
 const ALPHA_NUMERIC_REGEX = /^[A-Za-z0-9]+$/g
 
-module.exports.FIND_HBS_REGEX = /{{([^{].*?)}}/g
-module.exports.FIND_ANY_HBS_REGEX = /{?{{([^{].*?)}}}?/g
-module.exports.FIND_TRIPLE_HBS_REGEX = /{{{([^{].*?)}}}/g
+export const FIND_HBS_REGEX = /{{([^{].*?)}}/g
+export const FIND_ANY_HBS_REGEX = /{?{{([^{].*?)}}}?/g
+export const FIND_TRIPLE_HBS_REGEX = /{{{([^{].*?)}}}/g
 
-module.exports.isBackendService = () => {
+export const isBackendService = () => {
   return typeof window === "undefined"
 }
 
-module.exports.isJSAllowed = () => {
+export const isJSAllowed = () => {
   return process && !process.env.NO_JS
 }
 
 // originally this could be done with a single regex using look behinds
 // but safari does not support this feature
 // original regex: /(?<!{){{[^{}]+}}(?!})/g
-module.exports.findDoubleHbsInstances = string => {
+export const findDoubleHbsInstances = (string: string): string[] => {
   let copied = string
-  const doubleRegex = new RegExp(exports.FIND_HBS_REGEX)
-  const regex = new RegExp(exports.FIND_TRIPLE_HBS_REGEX)
+  const doubleRegex = new RegExp(FIND_HBS_REGEX)
+  const regex = new RegExp(FIND_TRIPLE_HBS_REGEX)
   const tripleMatches = copied.match(regex)
   // remove triple braces
   if (tripleMatches) {
-    tripleMatches.forEach(match => {
+    tripleMatches.forEach((match: string) => {
       copied = copied.replace(match, "")
     })
   }
@@ -30,34 +30,39 @@ module.exports.findDoubleHbsInstances = string => {
   return doubleMatches ? doubleMatches : []
 }
 
-module.exports.isAlphaNumeric = char => {
+export const isAlphaNumeric = (char: string) => {
   return char.match(ALPHA_NUMERIC_REGEX)
 }
 
-module.exports.swapStrings = (string, start, length, swap) => {
+export const swapStrings = (
+  string: string,
+  start: number,
+  length: number,
+  swap: string
+) => {
   return string.slice(0, start) + swap + string.slice(start + length)
 }
 
-module.exports.removeHandlebarsStatements = (
-  string,
+export const removeHandlebarsStatements = (
+  string: string,
   replacement = "Invalid binding"
 ) => {
-  let regexp = new RegExp(exports.FIND_HBS_REGEX)
+  let regexp = new RegExp(FIND_HBS_REGEX)
   let matches = string.match(regexp)
   if (matches == null) {
     return string
   }
   for (let match of matches) {
     const idx = string.indexOf(match)
-    string = exports.swapStrings(string, idx, match.length, replacement)
+    string = swapStrings(string, idx, match.length, replacement)
   }
   return string
 }
 
-module.exports.btoa = plainText => {
+export const btoa = (plainText: string) => {
   return Buffer.from(plainText, "utf-8").toString("base64")
 }
 
-module.exports.atob = base64 => {
+export const atob = (base64: string) => {
   return Buffer.from(base64, "base64").toString("utf-8")
 }

package/dist/index.d.mts

@@ -1,23 +0,0 @@
-/**
- * ES6 entrypoint for rollup
- */
-export const isValid: (string: any, opts?: any) => boolean;
-export const makePropSafe: (property: string) => string;
-export const getManifest: () => any;
-export const isJSBinding: (handlebars: any) => boolean;
-export const encodeJSBinding: (javascript: any) => string;
-export const decodeJSBinding: (handlebars: any) => string;
-export const processStringSync: (string: string, context: any, opts?: any) => string;
-export const processObjectSync: (object: any, context: any, opts?: any) => any;
-export const processString: (string: string, context: any, opts?: any) => Promise<string>;
-export const processObject: (object: any, context: any, opts?: any) => Promise<any>;
-export const doesContainStrings: (template: string, strings: string[]) => boolean;
-export const doesContainString: (template: string, string: string) => boolean;
-export const disableEscaping: (string: any) => any;
-export const findHBSBlocks: (string: string) => string[];
-export const convertToJS: (hbs: any) => string;
-export const setJSRunner: (runner: any) => any;
-export const setOnErrorLog: (delegate: any) => any;
-export const FIND_ANY_HBS_REGEX: RegExp;
-export const helpersToRemoveForJs: string[];
-export * from "./errors.js";

package/src/errors.js

@@ -1,11 +0,0 @@
-class JsErrorTimeout extends Error {
-  code = "ERR_SCRIPT_EXECUTION_TIMEOUT"
-
-  constructor() {
-    super()
-  }
-}
-
-module.exports = {
-  JsErrorTimeout,
-}

package/src/helpers/Helper.js

@@ -1,29 +0,0 @@
-class Helper {
-  constructor(name, fn, useValueFallback = true) {
-    this.name = name
-    this.fn = fn
-    this.useValueFallback = useValueFallback
-  }
-
-  register(handlebars) {
-    // wrap the function so that no helper can cause handlebars to break
-    handlebars.registerHelper(this.name, (value, info) => {
-      let context = {}
-      if (info && info.data && info.data.root) {
-        context = info.data.root
-      }
-      const result = this.fn(value, context)
-      if (result == null) {
-        return this.useValueFallback ? value : null
-      } else {
-        return result
-      }
-    })
-  }
-
-  unregister(handlebars) {
-    handlebars.unregisterHelper(this.name)
-  }
-}
-
-module.exports = Helper

package/src/helpers/index.js

@@ -1,100 +0,0 @@
-const Helper = require("./Helper")
-const { SafeString } = require("handlebars")
-const externalHandlebars = require("./external")
-const { processJS } = require("./javascript")
-const {
-  HelperFunctionNames,
-  HelperFunctionBuiltin,
-  LITERAL_MARKER,
-} = require("./constants")
-const { getJsHelperList } = require("./list")
-
-const HTML_SWAPS = {
-  "<": "&lt;",
-  ">": "&gt;",
-}
-
-function isObject(value) {
-  if (value == null || typeof value !== "object") {
-    return false
-  }
-  return (
-    value.toString() === "[object Object]" ||
-    (value.length > 0 && typeof value[0] === "object")
-  )
-}
-
-const HELPERS = [
-  // external helpers
-  new Helper(HelperFunctionNames.OBJECT, value => {
-    return new SafeString(JSON.stringify(value))
-  }),
-  // javascript helper
-  new Helper(HelperFunctionNames.JS, processJS, false),
-  // this help is applied to all statements
-  new Helper(HelperFunctionNames.ALL, (value, inputs) => {
-    const { __opts } = inputs
-    if (isObject(value)) {
-      return new SafeString(JSON.stringify(value))
-    }
-    // null/undefined values produce bad results
-    if (__opts && __opts.onlyFound && value == null) {
-      return __opts.input
-    }
-    if (value == null || typeof value !== "string") {
-      return value == null ? "" : value
-    }
-    if (value && value.string) {
-      value = value.string
-    }
-    let text = value
-    if (__opts && __opts.escapeNewlines) {
-      text = value.replace(/\n/g, "\\n")
-    }
-    text = new SafeString(text.replace(/&amp;/g, "&"))
-    if (text == null || typeof text !== "string") {
-      return text
-    }
-    return text.replace(/[<>]/g, tag => {
-      return HTML_SWAPS[tag] || tag
-    })
-  }),
-  // adds a note for post-processor
-  new Helper(HelperFunctionNames.LITERAL, value => {
-    if (value === undefined) {
-      return ""
-    }
-    const type = typeof value
-    const outputVal = type === "object" ? JSON.stringify(value) : value
-    return `{{${LITERAL_MARKER} ${type}-${outputVal}}}`
-  }),
-]
-
-module.exports.HelperNames = () => {
-  return Object.values(HelperFunctionNames).concat(
-    HelperFunctionBuiltin,
-    externalHandlebars.externalHelperNames
-  )
-}
-
-module.exports.registerMinimum = handlebars => {
-  for (let helper of HELPERS) {
-    helper.register(handlebars)
-  }
-}
-
-module.exports.registerAll = handlebars => {
-  module.exports.registerMinimum(handlebars)
-  // register imported helpers
-  externalHandlebars.registerAll(handlebars)
-}
-
-module.exports.unregisterAll = handlebars => {
-  for (let helper of HELPERS) {
-    helper.unregister(handlebars)
-  }
-  // unregister all imported helpers
-  externalHandlebars.unregisterAll(handlebars)
-}
-
-module.exports.getJsHelperList = getJsHelperList

package/src/iife.js

@@ -1,3 +0,0 @@
-module.exports.iifeWrapper = script => {
-  return `(function(){\n${script}\n})();`
-}

package/src/index.mjs

@@ -1,26 +0,0 @@
-import templates from "./index.js"
-
-/**
- * ES6 entrypoint for rollup
- */
-export const isValid = templates.isValid
-export const makePropSafe = templates.makePropSafe
-export const getManifest = templates.getManifest
-export const isJSBinding = templates.isJSBinding
-export const encodeJSBinding = templates.encodeJSBinding
-export const decodeJSBinding = templates.decodeJSBinding
-export const processStringSync = templates.processStringSync
-export const processObjectSync = templates.processObjectSync
-export const processString = templates.processString
-export const processObject = templates.processObject
-export const doesContainStrings = templates.doesContainStrings
-export const doesContainString = templates.doesContainString
-export const disableEscaping = templates.disableEscaping
-export const findHBSBlocks = templates.findHBSBlocks
-export const convertToJS = templates.convertToJS
-export const setJSRunner = templates.setJSRunner
-export const setOnErrorLog = templates.setOnErrorLog
-export const FIND_ANY_HBS_REGEX = templates.FIND_ANY_HBS_REGEX
-export const helpersToRemoveForJs = templates.helpersToRemoveForJs
-
-export * from "./errors.js"

package/src/processors/postprocessor.js

@@ -1,49 +0,0 @@
-const { LITERAL_MARKER } = require("../helpers/constants")
-
-const PostProcessorNames = {
-  CONVERT_LITERALS: "convert-literals",
-}
-
-/* eslint-disable no-unused-vars */
-class Postprocessor {
-  constructor(name, fn) {
-    this.name = name
-    this.fn = fn
-  }
-
-  process(statement) {
-    return this.fn(statement)
-  }
-}
-
-module.exports.PostProcessorNames = PostProcessorNames
-
-module.exports.processors = [
-  new Postprocessor(PostProcessorNames.CONVERT_LITERALS, statement => {
-    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
-  }),
-]

package/src/processors/preprocessor.js

@@ -1,78 +0,0 @@
-const { HelperNames } = require("../helpers")
-const { swapStrings, isAlphaNumeric } = require("../utilities")
-
-const FUNCTION_CASES = ["#", "else", "/"]
-
-const PreprocessorNames = {
-  SWAP_TO_DOT: "swap-to-dot-notation",
-  FIX_FUNCTIONS: "fix-functions",
-  FINALISE: "finalise",
-}
-
-/* eslint-disable no-unused-vars */
-class Preprocessor {
-  constructor(name, fn) {
-    this.name = name
-    this.fn = fn
-  }
-
-  process(fullString, statement, opts) {
-    const output = this.fn(statement, opts)
-    const idx = fullString.indexOf(statement)
-    return swapStrings(fullString, idx, statement.length, output)
-  }
-}
-
-module.exports.processors = [
-  new Preprocessor(PreprocessorNames.SWAP_TO_DOT, statement => {
-    let startBraceIdx = statement.indexOf("[")
-    let lastIdx = 0
-    while (startBraceIdx !== -1) {
-      // if the character previous to the literal specifier is alphanumeric this should happen
-      if (isAlphaNumeric(statement.charAt(startBraceIdx - 1))) {
-        statement = swapStrings(statement, startBraceIdx + lastIdx, 1, ".[")
-      }
-      lastIdx = startBraceIdx + 1
-      const nextBraceIdx = statement.substring(lastIdx + 1).indexOf("[")
-      startBraceIdx = nextBraceIdx > 0 ? lastIdx + 1 + nextBraceIdx : -1
-    }
-    return statement
-  }),
-
-  new Preprocessor(PreprocessorNames.FIX_FUNCTIONS, statement => {
-    for (let specialCase of FUNCTION_CASES) {
-      const toFind = `{ ${specialCase}`,
-        replacement = `{${specialCase}`
-      statement = statement.replace(new RegExp(toFind, "g"), replacement)
-    }
-    return statement
-  }),
-
-  new Preprocessor(PreprocessorNames.FINALISE, (statement, opts) => {
-    const noHelpers = opts && opts.noHelpers
-    let insideStatement = statement.slice(2, statement.length - 2)
-    if (insideStatement.charAt(0) === " ") {
-      insideStatement = insideStatement.slice(1)
-    }
-    if (insideStatement.charAt(insideStatement.length - 1) === " ") {
-      insideStatement = insideStatement.slice(0, insideStatement.length - 1)
-    }
-    const possibleHelper = insideStatement.split(" ")[0]
-    // function helpers can't be wrapped
-    for (let specialCase of FUNCTION_CASES) {
-      if (possibleHelper.includes(specialCase)) {
-        return statement
-      }
-    }
-    const testHelper = possibleHelper.trim().toLowerCase()
-    if (
-      !noHelpers &&
-      HelperNames().some(option => testHelper === option.toLowerCase())
-    ) {
-      insideStatement = `(${insideStatement})`
-    }
-    return `{{ all ${insideStatement} }}`
-  }),
-]
-
-module.exports.PreprocessorNames = PreprocessorNames