@budibase/string-templates 3.2.5 → 3.2.7

package/dist/iife.mjs

@@ -0,0 +1 @@
+!function(){const s={};try{if(process)return process.env=Object.assign({},process.env),void Object.assign(process.env,s)}catch(s){}globalThis.process={env:s}}();const s=s=>`(function(){\n${s}\n})();`;export{s as iifeWrapper};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@budibase/string-templates",
-  "version": "3.2.5",
+  "version": "3.2.7",
   "description": "Handlebars wrapper for Budibase templating.",
   "main": "dist/bundle.cjs",
   "module": "dist/bundle.mjs",
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "license": "MPL-2.0",
   "exports": {
     ".": {
@@ -12,12 +12,8 @@
       "import": "./dist/bundle.mjs"
     },
     "./package.json": "./package.json",
-    "./iife": "./src/iife.js"
+    "./iife": "./dist/iife.mjs"
   },
-  "files": [
-    "dist",
-    "src"
-  ],
   "scripts": {
     "build": "tsc --emitDeclarationOnly && rollup -c",
     "dev": "rollup -cw",
@@ -48,5 +44,5 @@
     "ts-jest": "29.1.1",
     "typescript": "5.5.2"
   },
-  "gitHead": "c1ee7b00e6687d588565b3d74ee24084a8d1ceab"
+  "gitHead": "fbfab71c1e93d79cf64736a218bf08fddde0ccd0"
 }

package/src/conversion/index.ts

@@ -1,131 +0,0 @@
-import { getJsHelperList } from "../helpers"
-
-function getLayers(fullBlock: string): string[] {
-  let layers = []
-  while (fullBlock.length) {
-    const start = fullBlock.lastIndexOf("("),
-      end = fullBlock.indexOf(")")
-    let layer: string
-    if (start === -1 || end === -1) {
-      layer = fullBlock.trim()
-      fullBlock = ""
-    } else {
-      const untrimmed = fullBlock.substring(start, end + 1)
-      layer = untrimmed.substring(1, untrimmed.length - 1).trim()
-      fullBlock =
-        fullBlock.slice(0, start) +
-        fullBlock.slice(start + untrimmed.length + 1, fullBlock.length)
-    }
-    layers.push(layer)
-  }
-  return layers
-}
-
-function getVariable(variableName: string) {
-  if (!variableName || typeof variableName !== "string") {
-    return variableName
-  }
-  // it is an array
-  const arrayOrObject = [",", "{", ":"]
-  let contains = false
-  arrayOrObject.forEach(char => {
-    if (variableName.includes(char)) {
-      contains = true
-    }
-  })
-  if (variableName.startsWith("[") && contains) {
-    return variableName
-  }
-  // it is just a number
-  if (!isNaN(parseFloat(variableName))) {
-    return variableName
-  }
-  if (variableName.startsWith("'") || variableName.startsWith('"')) {
-    return variableName
-  }
-  // extract variable
-  return `$("${variableName}")`
-}
-
-function buildList(parts: string[], value: any) {
-  function build() {
-    return parts
-      .map((part: string) =>
-        part.startsWith("helper") ? part : getVariable(part)
-      )
-      .join(", ")
-  }
-  if (!value) {
-    return parts.length > 1 ? `${build()}` : build()
-  } else {
-    return parts.length === 0 ? value : `${build()}, ${value}`
-  }
-}
-
-function splitBySpace(layer: string) {
-  const parts: string[] = []
-  let started = null,
-    endChar = null,
-    last = 0
-  function add(str: string) {
-    const startsWith = ["]"]
-    while (startsWith.indexOf(str.substring(0, 1)) !== -1) {
-      str = str.substring(1, str.length)
-    }
-    if (str.length > 0) {
-      parts.push(str.trim())
-    }
-  }
-  const continuationChars = ["[", "'", '"']
-  for (let index = 0; index < layer.length; index++) {
-    const char = layer[index]
-    if (continuationChars.indexOf(char) !== -1 && started == null) {
-      started = index
-      endChar = char === "[" ? "]" : char
-    } else if (
-      char === endChar &&
-      started != null &&
-      layer[index + 1] !== "."
-    ) {
-      add(layer.substring(started, index + 1))
-      started = null
-      endChar = null
-      last = index + 1
-    } else if (started == null && char === " ") {
-      add(layer.substring(last, index))
-      last = index
-    }
-  }
-  if (
-    (!layer.startsWith("[") || parts.length === 0) &&
-    last !== layer.length - 1
-  ) {
-    add(layer.substring(last, layer.length))
-  }
-  return parts
-}
-
-export function convertHBSBlock(block: string, blockNumber: number) {
-  const braceLength = block[2] === "{" ? 3 : 2
-  block = block.substring(braceLength, block.length - braceLength).trim()
-  const layers = getLayers(block)
-
-  let value = null
-  const list = getJsHelperList()
-  for (let layer of layers) {
-    const parts = splitBySpace(layer)
-    if (value || parts.length > 1 || list[parts[0]]) {
-      // first of layer should always be the helper
-      const [helper] = parts.splice(0, 1)
-      if (list[helper]) {
-        value = `helpers.${helper}(${buildList(parts, value)})`
-      }
-    }
-    // no helpers
-    else {
-      value = getVariable(parts[0])
-    }
-  }
-  // split by space will remove square brackets
-  return { variable: `var${blockNumber}`, value }
-}

package/src/errors.ts

@@ -1,20 +0,0 @@
-export class JsTimeoutError extends Error {
-  static message = "Timed out while executing JS"
-  static code = "JS_TIMEOUT_ERROR"
-  code: string = JsTimeoutError.code
-
-  constructor() {
-    super(JsTimeoutError.message)
-  }
-}
-
-export class UserScriptError extends Error {
-  static code = "USER_SCRIPT_ERROR"
-  code: string = UserScriptError.code
-
-  constructor(readonly userScriptError: Error) {
-    super(
-      `error while running user-supplied JavaScript: ${userScriptError.toString()}`
-    )
-  }
-}

package/src/helpers/Helper.ts

@@ -1,36 +0,0 @@
-import Handlebars from "handlebars"
-
-export default class Helper {
-  private name: any
-  private fn: any
-  private useValueFallback: boolean
-
-  constructor(name: string, fn: any, useValueFallback = true) {
-    this.name = name
-    this.fn = fn
-    this.useValueFallback = useValueFallback
-  }
-
-  register(handlebars: typeof Handlebars) {
-    // wrap the function so that no helper can cause handlebars to break
-    handlebars.registerHelper(
-      this.name,
-      (value: any, info: { data: { root: {} } }) => {
-        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: { unregisterHelper: any }) {
-    handlebars.unregisterHelper(this.name)
-  }
-}

package/src/helpers/constants.ts

@@ -1,41 +0,0 @@
-export const HelperFunctionBuiltin = [
-  "#if",
-  "#unless",
-  "#each",
-  "#with",
-  "lookup",
-  "log",
-  "blockHelperMissing",
-  "each",
-  "helperMissing",
-  "if",
-  "unless",
-  "log",
-  "lookup",
-  "with",
-]
-
-/**
- * full list of supported helpers can be found here:
- * https://github.com/Budibase/handlebars-helpers
- */
-export const EXTERNAL_FUNCTION_COLLECTIONS = [
-  "math",
-  "array",
-  "number",
-  "url",
-  "string",
-  "comparison",
-  "object",
-  "regex",
-  "uuid",
-]
-
-export const HelperFunctionNames = {
-  OBJECT: "object",
-  ALL: "all",
-  LITERAL: "literal",
-  JS: "js",
-}
-
-export const LITERAL_MARKER = "%LITERAL%"

package/src/helpers/date.ts

@@ -1,133 +0,0 @@
-import dayjs from "dayjs"
-
-import dayjsDurationPlugin from "dayjs/plugin/duration"
-import dayjsAdvancedFormatPlugin from "dayjs/plugin/advancedFormat"
-import dayjsIsoWeekPlugin from "dayjs/plugin/isoWeek"
-import dayjsWeekYearPlugin from "dayjs/plugin/weekYear"
-import dayjsWeekOfYearPlugin from "dayjs/plugin/weekOfYear"
-import dayjsRelativeTimePlugin from "dayjs/plugin/relativeTime"
-import dayjsUtcPlugin from "dayjs/plugin/utc"
-import dayjsTimezonePlugin from "dayjs/plugin/timezone"
-
-dayjs.extend(dayjsDurationPlugin)
-dayjs.extend(dayjsAdvancedFormatPlugin)
-dayjs.extend(dayjsIsoWeekPlugin)
-dayjs.extend(dayjsWeekYearPlugin)
-dayjs.extend(dayjsWeekOfYearPlugin)
-dayjs.extend(dayjsRelativeTimePlugin)
-dayjs.extend(dayjsUtcPlugin)
-dayjs.extend(dayjsTimezonePlugin)
-
-/**
- * This file was largely taken from the helper-date package - we did this for two reasons:
- * 1. It made use of both moment of date.js - this caused some weird bugs with some relatively simple
- * syntax and didn't offer much in return.
- * 2. Replacing moment with dayjs helps massively reduce bundle size.
- * The original package can be found here:
- * https://github.com/helpers/helper-date
- */
-
-function isOptions(val: any) {
-  return typeof val === "object" && typeof val.hash === "object"
-}
-
-function isApp(thisArg: any) {
-  return (
-    typeof thisArg === "object" &&
-    typeof thisArg.options === "object" &&
-    typeof thisArg.app === "object"
-  )
-}
-
-function getContext(thisArg: any, locals: any, options: any) {
-  if (isOptions(thisArg)) {
-    return getContext({}, locals, thisArg)
-  }
-  // ensure args are in the correct order
-  if (isOptions(locals)) {
-    return getContext(thisArg, options, locals)
-  }
-  const appContext = isApp(thisArg) ? thisArg.context : {}
-  options = options || {}
-
-  // if "options" is not handlebars options, merge it onto locals
-  if (!isOptions(options)) {
-    locals = Object.assign({}, locals, options)
-  }
-  // merge handlebars root data onto locals if specified on the hash
-  if (isOptions(options) && options.hash.root === true) {
-    locals = Object.assign({}, options.data.root, locals)
-  }
-  let context = Object.assign({}, appContext, locals, options.hash)
-  if (!isApp(thisArg)) {
-    context = Object.assign({}, thisArg, context)
-  }
-  if (isApp(thisArg) && thisArg.view && thisArg.view.data) {
-    context = Object.assign({}, context, thisArg.view.data)
-  }
-  return context
-}
-
-function initialConfig(str: any, pattern: any, options?: any) {
-  if (isOptions(pattern)) {
-    options = pattern
-    pattern = null
-  }
-
-  if (isOptions(str)) {
-    options = str
-    pattern = null
-    str = null
-  }
-  return { str, pattern, options }
-}
-
-function setLocale(this: any, str: any, pattern: any, options?: any) {
-  // if options is null then it'll get updated here
-  const config = initialConfig(str, pattern, options)
-  const defaults = { lang: "en", date: new Date(config.str) }
-  // for now don't allow this to be configurable, don't pass in options
-  const opts = getContext(this, defaults, {})
-
-  // set the language to use
-  dayjs.locale(opts.lang || opts.language)
-}
-
-export const date = (str: any, pattern: any, options: any) => {
-  const config = initialConfig(str, pattern, options)
-
-  // if no args are passed, return a formatted date
-  if (config.str == null && config.pattern == null) {
-    dayjs.locale("en")
-    return dayjs().format("MMMM DD, YYYY")
-  }
-
-  setLocale(config.str, config.pattern, config.options)
-
-  let date = dayjs(new Date(config.str))
-  if (typeof config.options === "string") {
-    date =
-      config.options.toLowerCase() === "utc"
-        ? date.utc()
-        : date.tz(config.options)
-  } else {
-    date = date.tz(dayjs.tz.guess())
-  }
-  if (config.pattern === "") {
-    return date.toISOString()
-  }
-  return date.format(config.pattern)
-}
-
-export const duration = (str: any, pattern: any, format: any) => {
-  const config = initialConfig(str, pattern)
-
-  setLocale(config.str, config.pattern)
-
-  const duration = dayjs.duration(config.str, config.pattern)
-  if (format && !isOptions(format)) {
-    return duration.format(format)
-  } else {
-    return duration.humanize()
-  }
-}

package/src/helpers/external.ts

@@ -1,57 +0,0 @@
-// @ts-ignore we don't have types for it
-import helpers from "@budibase/handlebars-helpers"
-
-import { date, duration } from "./date"
-import {
-  HelperFunctionBuiltin,
-  EXTERNAL_FUNCTION_COLLECTIONS,
-} from "./constants"
-import Handlebars from "handlebars"
-
-const ADDED_HELPERS = {
-  date: date,
-  duration: duration,
-}
-
-export const externalCollections = EXTERNAL_FUNCTION_COLLECTIONS
-export const addedHelpers = ADDED_HELPERS
-
-export function registerAll(handlebars: typeof Handlebars) {
-  for (let [name, helper] of Object.entries(ADDED_HELPERS)) {
-    handlebars.registerHelper(name, helper)
-  }
-  let externalNames = []
-  for (let collection of EXTERNAL_FUNCTION_COLLECTIONS) {
-    // collect information about helper
-    let hbsHelperInfo = helpers[collection]()
-    for (let entry of Object.entries(hbsHelperInfo)) {
-      const name = entry[0]
-      // skip built-in functions and ones seen already
-      if (
-        HelperFunctionBuiltin.indexOf(name) !== -1 ||
-        externalNames.indexOf(name) !== -1
-      ) {
-        continue
-      }
-      externalNames.push(name)
-    }
-    // attach it to our handlebars instance
-    helpers[collection]({
-      handlebars,
-    })
-  }
-  // add date external functionality
-  externalHelperNames = externalNames.concat(Object.keys(ADDED_HELPERS))
-}
-
-export function unregisterAll(handlebars: typeof Handlebars) {
-  for (let name of Object.keys(ADDED_HELPERS)) {
-    handlebars.unregisterHelper(name)
-  }
-  for (let name of externalHelperNames) {
-    handlebars.unregisterHelper(name)
-  }
-  externalHelperNames = []
-}
-
-export let externalHelperNames: any[] = []

package/src/helpers/index.ts

@@ -1,103 +0,0 @@
-import Helper from "./Helper"
-import Handlebars from "handlebars"
-import * as externalHandlebars from "./external"
-import { processJS } from "./javascript"
-import {
-  HelperFunctionNames,
-  HelperFunctionBuiltin,
-  LITERAL_MARKER,
-} from "./constants"
-
-export { getJsHelperList } from "./list"
-
-const HTML_SWAPS = {
-  "<": "&lt;",
-  ">": "&gt;",
-}
-
-function isObject(value: string | any[]) {
-  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: any) => {
-    return new Handlebars.SafeString(JSON.stringify(value))
-  }),
-  // javascript helper
-  new Helper(HelperFunctionNames.JS, processJS, false),
-  // this help is applied to all statements
-  new Helper(
-    HelperFunctionNames.ALL,
-    (value: string, inputs: { __opts: any }) => {
-      const { __opts } = inputs
-      if (isObject(value)) {
-        return new Handlebars.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
-      }
-      // TODO: check, this should always be false
-      if (value && (value as any).string) {
-        value = (value as any).string
-      }
-      let text: any = value
-      if (__opts && __opts.escapeNewlines) {
-        text = value.replace(/\n/g, "\\n")
-      }
-      text = new Handlebars.SafeString(text.replace(/&amp;/g, "&"))
-      if (text == null || typeof text !== "string") {
-        return text
-      }
-      return text.replace(/[<>]/g, (tag: string) => {
-        return HTML_SWAPS[tag as keyof typeof HTML_SWAPS] || tag
-      })
-    }
-  ),
-  // adds a note for post-processor
-  new Helper(HelperFunctionNames.LITERAL, (value: any) => {
-    if (value === undefined) {
-      return ""
-    }
-    const type = typeof value
-    const outputVal = type === "object" ? JSON.stringify(value) : value
-    return `{{${LITERAL_MARKER} ${type}-${outputVal}}}`
-  }),
-]
-
-export function HelperNames() {
-  return Object.values(HelperFunctionNames).concat(
-    HelperFunctionBuiltin,
-    externalHandlebars.externalHelperNames
-  )
-}
-
-export function registerMinimum(handlebars: typeof Handlebars) {
-  for (let helper of HELPERS) {
-    helper.register(handlebars)
-  }
-}
-
-export function registerAll(handlebars: typeof Handlebars) {
-  registerMinimum(handlebars)
-  // register imported helpers
-  externalHandlebars.registerAll(handlebars)
-}
-
-export function unregisterAll(handlebars: any) {
-  for (let helper of HELPERS) {
-    helper.unregister(handlebars)
-  }
-  // unregister all imported helpers
-  externalHandlebars.unregisterAll(handlebars)
-}