@budibase/string-templates 3.2.5 → 3.2.6

package/src/processors/index.ts

@@ -1,37 +0,0 @@
-import { FIND_HBS_REGEX } from "../utilities"
-import * as preprocessor from "./preprocessor"
-import * as postprocessor from "./postprocessor"
-import { ProcessOptions } from "../types"
-
-function process(output: string, processors: any[], opts?: ProcessOptions) {
-  for (let processor of processors) {
-    // if a literal statement has occurred stop
-    if (typeof output !== "string") {
-      break
-    }
-    // re-run search each time incase previous processor updated/removed a match
-    let regexp = new RegExp(FIND_HBS_REGEX)
-    let matches = output.match(regexp)
-    if (matches == null) {
-      continue
-    }
-    for (let match of matches) {
-      output = processor.process(output, match, opts)
-    }
-  }
-  return output
-}
-
-export function preprocess(string: string, opts: ProcessOptions) {
-  let processors = preprocessor.processors
-  if (opts.noFinalise) {
-    processors = processors.filter(
-      processor => processor.name !== preprocessor.PreprocessorNames.FINALISE
-    )
-  }
-
-  return process(string, processors, opts)
-}
-export function postprocess(string: string) {
-  return process(string, postprocessor.processors)
-}

package/src/processors/postprocessor.ts

@@ -1,57 +0,0 @@
-import { LITERAL_MARKER } from "../helpers/constants"
-
-export enum PostProcessorNames {
-  CONVERT_LITERALS = "convert-literals",
-}
-
-type PostprocessorFn = (statement: string) => string
-
-class Postprocessor {
-  name: PostProcessorNames
-  private readonly fn: PostprocessorFn
-
-  constructor(name: PostProcessorNames, fn: PostprocessorFn) {
-    this.name = name
-    this.fn = fn
-  }
-
-  process(statement: string) {
-    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
-    }
-  ),
-]

package/src/processors/preprocessor.ts

@@ -1,90 +0,0 @@
-import { HelperNames } from "../helpers"
-import { swapStrings, isAlphaNumeric } from "../utilities"
-import { ProcessOptions } from "../types"
-
-const FUNCTION_CASES = ["#", "else", "/"]
-
-export enum PreprocessorNames {
-  SWAP_TO_DOT = "swap-to-dot-notation",
-  FIX_FUNCTIONS = "fix-functions",
-  FINALISE = "finalise",
-  NORMALIZE_SPACES = "normalize-spaces",
-}
-
-type PreprocessorFn = (statement: string, opts?: ProcessOptions) => string
-
-class Preprocessor {
-  name: string
-  private readonly fn: PreprocessorFn
-
-  constructor(name: PreprocessorNames, fn: PreprocessorFn) {
-    this.name = name
-    this.fn = fn
-  }
-
-  process(fullString: string, statement: string, opts: ProcessOptions) {
-    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.NORMALIZE_SPACES, (statement: string) => {
-    return statement.replace(/{{(\s{2,})/g, "{{ ")
-  }),
-  new Preprocessor(
-    PreprocessorNames.FINALISE,
-    (statement: string, opts?: ProcessOptions) => {
-      const noHelpers = opts?.noHelpers
-      const helpersEnabled = !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 (
-        helpersEnabled &&
-        !opts?.disabledHelpers?.includes(testHelper) &&
-        HelperNames().some(option => testHelper === option.toLowerCase())
-      ) {
-        insideStatement = `(${insideStatement})`
-      }
-      return `{{ all ${insideStatement} }}`
-    }
-  ),
-]

package/src/types.ts

@@ -1,10 +0,0 @@
-export interface ProcessOptions {
-  cacheTemplates?: boolean
-  noEscaping?: boolean
-  noHelpers?: boolean
-  noFinalise?: boolean
-  noThrow?: boolean
-  escapeNewlines?: boolean
-  onlyFound?: boolean
-  disabledHelpers?: string[]
-}

package/src/utilities.ts

@@ -1,88 +0,0 @@
-const ALPHA_NUMERIC_REGEX = /^[A-Za-z0-9]+$/g
-
-export const FIND_HBS_REGEX = /{{([^{].*?)}}/g
-export const FIND_ANY_HBS_REGEX = /{?{{([^{].*?)}}}?/g
-export const FIND_TRIPLE_HBS_REGEX = /{{{([^{].*?)}}}/g
-
-const isJest = () => typeof jest !== "undefined"
-
-export const isBackendService = () => {
-  // We consider the tests for string-templates to be frontend, so that they
-  // test the frontend JS functionality.
-  if (isJest()) {
-    return false
-  }
-  return typeof window === "undefined"
-}
-
-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
-export const findDoubleHbsInstances = (string: string): string[] => {
-  let copied = string
-  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: string) => {
-      copied = copied.replace(match, "")
-    })
-  }
-  const doubleMatches = copied.match(doubleRegex)
-  return doubleMatches ? doubleMatches : []
-}
-
-export const isAlphaNumeric = (char: string) => {
-  return char.match(ALPHA_NUMERIC_REGEX)
-}
-
-export const swapStrings = (
-  string: string,
-  start: number,
-  length: number,
-  swap: string
-) => {
-  return string.slice(0, start) + swap + string.slice(start + length)
-}
-
-export const removeHandlebarsStatements = (
-  string: string,
-  replacement = "Invalid binding"
-) => {
-  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 = swapStrings(string, idx, match.length, replacement)
-  }
-  return string
-}
-
-export const btoa = (plainText: string) => {
-  return Buffer.from(plainText, "utf-8").toString("base64")
-}
-
-export const atob = (base64: string) => {
-  return Buffer.from(base64, "base64").toString("utf-8")
-}
-
-export const prefixStrings = (
-  baseString: string,
-  strings: string[],
-  prefix: string
-) => {
-  // Escape any special characters in the strings to avoid regex errors
-  const escapedStrings = strings.map(str =>
-    str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-  )
-  const regexPattern = new RegExp(`\\b(${escapedStrings.join("|")})\\b`, "g")
-  return baseString.replace(regexPattern, `${prefix}$1`)
-}