@questwork/q-utilities 0.1.9 → 0.1.10

package/dist/index.min.cjs

@@ -55,7 +55,7 @@ __webpack_require__.d(__webpack_exports__, {
   QMeta: () => (/* reexport */ QMeta),
   Repo: () => (/* reexport */ Repo),
   Service: () => (/* reexport */ Service),
-  Template: () => (/* reexport */ Template),
+  TemplateCompiler: () => (/* reexport */ TemplateCompiler),
   UniqueKeyGenerator: () => (/* reexport */ UniqueKeyGenerator),
   convertString: () => (/* reexport */ convertString),
   formatDate: () => (/* reexport */ formatDate),
@@ -232,6 +232,16 @@ function getValidation(rule, data, getDataByKey, KeyValueObject) {
       }
       return false
     }
+    case '$intervalTimeGt': {
+      const now = new Date().getTime()
+      const timestamp = new Date(rowValue).getTime()
+      return (now - timestamp) > value['$intervalTimeGt']
+    }
+    case '$intervalTimeLt': {
+      const now = new Date().getTime()
+      const timestamp = new Date(rowValue).getTime()
+      return (now - timestamp) < value['$intervalTimeLt']
+    }
     case '$notInValue': {
       const result = getDataByKey(value['$notInValue'], data)
       const _value = Array.isArray(result) ? result : []
@@ -1146,8 +1156,8 @@ function makeService({ repo }) {
 
 
 
-;// ./lib/models/template/templateException.js
-const TEMPLATE_EXCEPTION_TYPE = {
+;// ./lib/models/templateCompiler/templateCompilerException.js
+const TEMPLATE_COMPILER_EXCEPTION_TYPE = {
   argumentEmptyException: 'Argument is empty',
   argumentFormatException: 'Incorrect number or format of argument',
   invalidFuntionException: 'Function Name is invalid',
@@ -1158,7 +1168,7 @@ const TEMPLATE_EXCEPTION_TYPE = {
   resultMoreThanOneException: 'More than one result'
 }
 
-class TemplateException extends Error {
+class TemplateCompilerException extends Error {
   constructor(message) {
     super(message)
     this.message = message
@@ -1167,10 +1177,10 @@ class TemplateException extends Error {
 
 
 
-;// ./lib/models/template/constants.js
+;// ./lib/models/templateCompiler/constants.js
 const _EMPTY = '_EMPTY'
 const _FN_NAMES = [
-  'get', 'map', 'join', 'concatIf', 'filterOne', 'filterAll', 'formatDate', 'eq', 'neq', 'gt', 'lt', 'gte', 'lte', 'isEmpty', 'isNotEmpty', 'toLowerCase', 'toUpperCase'
+  'get', 'map', 'join', 'concatIf', 'exec', 'filterOne', 'filterAll', 'formatDate', 'eq', 'neq', 'gt', 'lt', 'gte', 'lte', 'isEmpty', 'isNotEmpty', 'toLowerCase', 'toUpperCase'
 ]
 const _HIDE = '_HIDE'
 const _NOT_EMPTY = '_NOT_EMPTY'
@@ -1180,14 +1190,45 @@ const TAGS_HANDLEBAR = ['{{', '}}']
 
 
 
-;// ./lib/models/template/helpers/_eq.js
+;// ./lib/models/templateCompiler/helpers/_concatIf.js
+
+
+
+
+function _concatIf(data, args) {
+  if (typeof data !== 'string') {
+    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string :${data.join(', ')}`)
+  }
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  const [condition, success, failover] = args
+  const validConditions = [_EMPTY, _NOT_EMPTY]
+  if (validConditions.includes(condition) || success.length !== 2) {
+    throw new TemplateCompilerException(`concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException}: ${condition}, ${success}`)
+  }
+  if (data === '' && failover.includes(_HIDE)) {
+    return ''
+  }
+  if (data !== '' && (data !== null || data !== undefined) && failover.includes(_HIDE)) {
+    return `${success[0]}${data}${success[success.length - 1]}`
+  }
+  return failover
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_eq.js
 
 
 
 
 function _eq(data, args) {
   if (args.length !== 3) {
-    throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.argumentFormatException)
+    throw new TemplateCompilerException(`eq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
   }
   if (data === null || (typeof data === 'undefined')) {
     return null
@@ -1203,15 +1244,28 @@ function _eq(data, args) {
 
 
 
-;// ./lib/models/template/helpers/_filterAll.js
+;// ./lib/models/templateCompiler/helpers/_exec.js
+function _exec(data, args) {
+  try {
+    const [methodName, ..._args] = args
+    return data[methodName](..._args)
+  } catch (e) {
+    throw e
+  }
+}
 
 
-const _filterAll_DELIMITER = '~~~'
+
+;// ./lib/models/templateCompiler/helpers/_filterAll.js
+
+
+
+// const DELIMITER = '~~~'
 
 function _filterAll(data, args) {
   try {
     if (!Array.isArray(args) || args.length === 0) {
-      throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.argumentEmptyException)
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
     }
     if (!Array.isArray(data) || data.length === 0) {
       return []
@@ -1229,25 +1283,140 @@ function _filterAll(data, args) {
 }
 
 function _exist(data, args) {
-  const _str = `${_filterAll_DELIMITER}${args.join(_filterAll_DELIMITER)}${_filterAll_DELIMITER}`
-  return data.filter((e) => {
-    return _str.includes(`${_filterAll_DELIMITER}${e}${_filterAll_DELIMITER}`) && args.includes(e)
-  })
+  const _args = args.flat()
+  return data.filter((e) => _args.some((arg) => _performOperation(arg, e)))
 }
 
 function _existObject(data, args) {
-  if (args.length !== 2) {
-    return []
+  if (args.length === 1) {
+    const arg = args[0]
+    return data.filter((e) => {
+      if (arg.includes('.')) {
+        return getValueByKeys(arg.split('.'), e)
+      }
+      return Object.prototype.hasOwnProperty.call(e, arg)
+    })
   }
-  const [key, _args] = args
+
+  if (args.length > 2) {
+    let res = data
+    for (let i = 0; i < args.length; i += 2) {
+      const group = [args[i], args[i + 1]]
+      res = _existObject(res, group)
+    }
+    return res
+  }
+
+  const [key, ..._argsArr] = args
+  const _args = _argsArr.flat()
   return data.filter((e) => {
-    return _args.includes(e[key])
+    const value = key.includes('.') ? getValueByKeys(key.split('.'), e) : e[key]
+    return _args.some((arg) => _performOperation(arg, value))
   })
 }
 
+function _performOperation(arg, value) {
+  // the arg is undefined
+  if (arg === undefined && value === undefined) return true
 
+  // the arg is null
+  if (arg === null && value === null) return true
 
-;// ./lib/models/template/helpers/_filterOne.js
+  // the arg is boolean
+  if (typeof arg === 'boolean') {
+    return arg === value
+  }
+
+  // the arg is blank or *: Blank => Empty, * => Not Empty
+  if (arg === '' || arg === '*') {
+    // null and undefined are not included in either case
+    if (value === null || value === undefined) {
+      return false
+    }
+    if (typeof value === 'string') {
+      return arg === '' ? value === '' : value !== ''
+    }
+    if (Array.isArray(value)) {
+      return arg === '' ? value.length === 0 : value.length !== 0
+    }
+    return arg !== ''
+  }
+
+  // the arg is alphabetic or number
+  if (_isPureStringOrNumber(arg)) {
+    return arg === value
+  }
+
+  // the arg is array of [] or [*]: [] => Empty, [*] => Not Empty
+  if (arg.startsWith('[') && arg.endsWith(']')) {
+    if (arg === '[]') {
+      return Array.isArray(value) && value.length === 0
+    }
+    if (arg === '[*]') {
+      return Array.isArray(value) && value.length !== 0
+    }
+    return false
+  }
+
+  // the arg is 'operator + string | number'
+  const { operator, value: argValue } = _splitOperator(arg)
+  if (!operator || (argValue !== 0 && !argValue)) {
+    return false
+  }
+  switch (operator) {
+    case '>':
+      return value > argValue
+    case '<':
+      return value < argValue
+    case '!=':
+      return value !== argValue
+    case '>=':
+      return value >= argValue
+    case '<=':
+      return value <= argValue
+    default:
+      return false
+  }
+}
+
+function _isPureStringOrNumber(input) {
+  if (typeof input === 'string') {
+    if (input.startsWith('[') && input.endsWith(']')) {
+      return false
+    }
+    if (/!=|>=|<=|>|</.test(input)) {
+      return false
+    }
+    return true
+  }
+  return !Number.isNaN(input)
+}
+
+function _splitOperator(str) {
+  const operators = ['!=', '>=', '<=', '>', '<']
+
+  const matchedOp = operators.find((op) => str.startsWith(op))
+  if (!matchedOp) return { operator: null, value: null }
+
+  const remaining = str.slice(matchedOp.length)
+
+  // '>Primary' or '<Primary' is invalid
+  if (/^[a-zA-Z]*$/.test(remaining) && matchedOp !== '!=') {
+    return { operator: null, value: null }
+  }
+
+  // if it is a number it is converted to a number
+  const value = (!Number.isNaN(parseFloat(remaining)) && !Number.isNaN(remaining)) ? Number(remaining) : remaining
+
+  return {
+    operator: matchedOp,
+    value
+  }
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_filterOne.js
 
 
 
@@ -1260,7 +1429,7 @@ function _filterOne(data, args) {
     if (list.length === 0) {
       return null
     }
-    throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.resultMoreThanOneException)
+    throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.resultMoreThanOneException)
   } catch (e) {
     throw e
   }
@@ -1268,13 +1437,49 @@ function _filterOne(data, args) {
 
 
 
-;// ./lib/models/template/helpers/_get.js
+;// ./lib/models/templateCompiler/helpers/_formatDate.js
+
+
+function _formatDate(timestamp, format) {
+  if (format.length === 0) {
+    throw new TemplateCompilerException(`_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: format parts must be not empty array`)
+  }
+
+  if (timestamp === null || timestamp === undefined) {
+    return null
+  }
+
+  const date = new Date(timestamp)
+
+  const partsMap = {
+    yyyy: String(date.getFullYear()),
+    mm: String(date.getMonth() + 1).padStart(2, '0'),
+    dd: String(date.getDate()).padStart(2, '0')
+  }
+
+  // Check for invalid format tokens
+  const validTokens = ['yyyy', 'mm', 'dd']
+  const invalidTokens = format.filter((part) => part.length > 1 && !validTokens.includes(part))
+
+  if (invalidTokens.length > 0) {
+    throw new TemplateCompilerException(
+      `_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the format type is not valid: ${format.join(', ')}`
+    )
+  }
+
+  // Build the formatted string using reduce
+  return format.reduce((result, part) => result + (partsMap[part] || part), '')
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_get.js
 
 
 function _get(data, key, failover = null) {
   try {
     if (key === null || (typeof key === 'undefined') || key === '') {
-      throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.argumentEmptyException)
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
     }
     if (data === null) {
       return null
@@ -1304,30 +1509,186 @@ function _handleFailover(key, failover) {
     return failover
   }
   return null
-  // throw new TemplateException(`Key "${key}" does not exist and no failover`)
+  // throw new TemplateCompilerException(`Key "${key}" does not exist and no failover`)
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_gt.js
+
+
+
+
+function _gt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data > expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_gte.js
+
+
+
+
+function _gte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_gte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data >= expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_isEmpty.js
+
+
+
+
+function _isEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[0]
+  }
+  return (data === '' || data === null || data === undefined || data.length === 0) ? args[0] : args[1]
 }
 
 
 
-;// ./lib/models/template/helpers/_join.js
+;// ./lib/models/templateCompiler/helpers/_isNotEmpty.js
+
+
+
+
+function _isNotEmpty(data, args) {
+  if (args.length !== 2) {
+    throw new TemplateCompilerException(`_isNotEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  // if (data === null || (typeof data === 'undefined')) {
+  //   return null
+  // }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
+    return args[1]
+  }
+  if (Array.isArray(data) && data.length === 0) {
+    return args[1]
+  }
+  if (typeof data === 'string' && data === '') {
+    return args[1]
+  }
+  if (data === null || data === undefined) {
+    return args[1]
+  }
+  return args[0]
+}
+
+
+;// ./lib/models/templateCompiler/helpers/_join.js
 function _join(data, delimiter) {
   try {
-    return data.join(delimiter)
+    if (data.length === 0) return ''
+    if (data.length === 1) return _stringifyObject(data[0])
+    return data.map((item) => _stringifyObject(item)).join(delimiter)
   } catch (e) {
     throw e
   }
 }
 
+function _stringifyObject(obj) {
+  return JSON.stringify(obj).replace(/"([^"]+)":/g, '$1: ').replace(/"([^"]+)"/g, '$1').replace(/,/g, ', ')
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_lt.js
+
+
+
+
+function _lt(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data < expected ? args[1] : args[2]
+}
+
 
 
-;// ./lib/models/template/helpers/_map.js
+;// ./lib/models/templateCompiler/helpers/_lte.js
+
+
+
+
+function _lte(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_lte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data <= expected ? args[1] : args[2]
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/_map.js
 
 
 
 function _map(data, args) {
   try {
     if (args.length === 0) {
-      throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.argumentEmptyException)
+      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
     }
     if (data === null || (typeof data === 'undefined')) {
       return null
@@ -1369,43 +1730,162 @@ function _map(data, args) {
 
 
 
-;// ./lib/models/template/helpers/index.js
+;// ./lib/models/templateCompiler/helpers/_neq.js
 
 
 
 
+function _neq(data, args) {
+  if (args.length !== 3) {
+    throw new TemplateCompilerException(`_neq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined')) {
+    return null
+  }
+  if (args.includes(_SELF)) {
+    args = args.map((arg) => {
+      return (arg === _SELF) ? data : arg
+    })
+  }
+  const expected = args[0]
+  return data !== expected ? args[1] : args[2]
+}
 
 
 
+;// ./lib/models/templateCompiler/helpers/_toLowerCase.js
 
 
-;// ./lib/models/template/template.js
+function _toLowerCase(data, args) {
+  if (args !== undefined) {
+    throw new TemplateCompilerException(`_toLowerCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
+    return null
+  }
+  return String(data).toLowerCase()
+}
+
 
 
+;// ./lib/models/templateCompiler/helpers/_toUpperCase.js
 
 
-class Template {
-  constructor({ data }) {
+function _toUpperCase(data, args) {
+  if (typeof data !== 'string') {
+    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string: ${data}`)
+  }
+  if (args !== undefined) {
+    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the argument must be empty: ${args.join(', ')}`)
+  }
+  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
+    return null
+  }
+  return String(data).toUpperCase()
+}
+
+
+
+;// ./lib/models/templateCompiler/helpers/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./lib/models/templateCompiler/templateCompiler.js
+
+
+
+
+class TemplateCompiler {
+  constructor(data) {
     this.data = data
   }
+  static init(options) {
+    return new this(options)
+  }
+  static initFromArray(arr = []) {
+    if (Array.isArray(arr)) {
+      return arr.map((a) => this.init(a))
+    }
+    return []
+  }
+  static initOnlyValidFromArray(arr = []) {
+    return this.initFromArray(arr).filter((i) => i)
+  }
+  static concatIf(data, args) {
+    return _concatIf(data, args)
+  }
   static eq(data, args) {
     return _eq(data, args)
   }
+
+  static filterAll(data, args) {
+    return _filterAll(data, args)
+  }
+
+  static formatDate(data, args) {
+    return _formatDate(data, args)
+  }
+  
   static get(data, key, failover = null) {
     return _get(data, key, failover)
   }
+  static gt(data, args) {
+    return _gt(data, args)
+  }
+  static gte(data, args) {
+    return _gte(data, args)
+  }
+  static isEmpty(data, args) {
+    return _isEmpty(data, args)
+  }
+  static isNotEmpty(data, args) {
+    return _isNotEmpty(data, args)
+  }
   static join(data, separator = '') {
     return _join(data, separator)
   }
+  static lt(data, args) {
+    return _lt(data, args)
+  }
+  static lte(data, args) {
+    return _lte(data, args)
+  }
   static map(data, args = []) {
     return _map(data, args)
   }
+  static neq(data, args) {
+    return _neq(data, args)
+  }
+  static toLowerCase(data, args) {
+    return _toLowerCase(data, args)
+  }
+  static toUpperCase(data, args) {
+    return _toUpperCase(data, args)
+  }
   static parseFunction(expression) {
     return _parseFunction(expression, _FN_NAMES)
   }
 
   pipe(expression = '') {
-    this.delimiters = expression.substring(0,2) === '<%' ? TAGS_EJS : TAGS_HANDLEBAR
+    this.delimiters = expression.substring(0, 2) === '{{' ? TAGS_HANDLEBAR : TAGS_EJS
     const regex = new RegExp(`${this.delimiters[0]}\\s(.*?)\\s${this.delimiters[1]}`)
     const match = expression.match(regex)
     if (match !== null) {
@@ -1415,10 +1895,10 @@ class Template {
           return _callFunction(acc, fn.name, fn.args)
         }, this.data)
       } catch (e) {
-        throw new TemplateException(`Template engine error: ${e.message}`)
+        throw new TemplateCompilerException(`TemplateCompiler engine error: ${e.message}`)
       }
     }
-    throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.invalidRegExpException)
+    throw new TemplateCompilerException(`TemplateCompiler engine error: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.invalidRegExpException}`)
   }
 }
 
@@ -1442,7 +1922,7 @@ function _parseFunction(expression, existFunctionNames) {
           args: paramList
         })
       } else {
-        throw new TemplateException(`${functionName} is not a valid function`)
+        throw new TemplateCompilerException(`${functionName} is not a valid function`)
       }
     }
     return acc
@@ -1486,12 +1966,18 @@ function _parseSinglePart(input) {
       return input.substring(1, input.length - 1)
     }
 
+    const _input = _toBasicType(input)
+
+    if (typeof _input !== 'string') {
+      return _input
+    }
+
     // 如果是一个列表形式（例如 ["p", "d"] 或 [p, d]）
-    if (input.startsWith('[') && input.endsWith(']')) {
-      const listContent = input.substring(1, input.length - 1).trim()
+    if (_input.startsWith('[') && _input.endsWith(']')) {
+      const listContent = _input.substring(1, _input.length - 1).trim()
       if (listContent !== '') {
         return listContent.split(',').map((item) => {
-          return item.trim().replaceAll('"', '') // 去除可能的双引号
+          return _toBasicType(item.trim())
         })
       }
       return []
@@ -1501,59 +1987,75 @@ function _parseSinglePart(input) {
   return input
 }
 
+function _toBasicType(input) {
+  if (input.startsWith('"') && input.endsWith('"')) {
+    // 去掉双引号，返回
+    return input.substring(1, input.length - 1)
+  }
+  if (input === 'true') {
+    return true
+  }
+  if (input === 'false') {
+    return false
+  }
+  if (input === 'undefined') {
+    return undefined
+  }
+  if (input === 'null') {
+    return null
+  }
+  if (!Number.isNaN(input) && !Number.isNaN(Number.parseFloat(input))) {
+    return Number(input)
+  }
+  return input
+}
+
 function _callFunction(data, functionName, parameters) {
   try {
     let failover
     switch (functionName) {
+      case 'exec':
+        return _exec(data, parameters)
       case 'get':
         if (parameters.length > 2) {
-          throw new TemplateException(TEMPLATE_EXCEPTION_TYPE.argumentFormatException)
+          throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException)
         }
         if (parameters.length === 2) {
           failover = parameters[parameters.length - 1]
         }
         return _get(data, parameters[0], failover)
-      case 'map':
-        return _map(data, parameters)
       case 'join':
         return _join(data, parameters[0])
-      // case 'concatIf':
-      //   if (parameters.length != 3) {
-      //     throw const TemplateException(TemplateExceptionType.argumentFormatException);
-      //   }
-      //   var condition = parameters.first;
-      //   var success = parameters[1];
-      //   var failover = parameters[2];
-      //   return _concatIf(data, condition, success, failover);
+      case 'map':
+        return _map(data, parameters)
+      case 'concatIf':
+        return _concatIf(data, parameters)
       case 'filterOne':
         return _filterOne(data, parameters)
       case 'filterAll':
         return _filterAll(data, parameters)
-      // case 'formatDate':
-      //   if (parameters is List<String>) {
-      //     return _formatDate(data, parameters);
-      //   }
-      //   throw const TemplateException(TemplateExceptionType.argumentFormatException);
+      case 'formatDate':
+        return _formatDate(data, parameters)
       case 'eq':
         return _eq(data, parameters)
-      // case 'neq':
-      //   return _neq(data, parameters);
-      // case 'gt':
-      //   return _gt(data, parameters);
-      // case 'gte':
-      //   return _gte(data, parameters);
-      // case 'lt':
-      //   return _lt(data, parameters);
-      // case 'lte':
-      //   return _lte(data, parameters);
-      // case 'isEmpty':
-      //   return _isEmpty(data, parameters);
-      // case 'isNotEmpty':
-      //   return _isNotEmpty(data, parameters);
-      // case 'toLowerCase':
-      //   return _toLowerCase(data);
-      // case 'toUpperCase':
-      //   return _toUpperCase(data);
+      case 'neq':
+        return _neq(data, parameters)
+      case 'gt':
+        return _gt(data, parameters)
+      case 'gte':
+        return _gte(data, parameters)
+      case 'lt':
+        return _lt(data, parameters)
+      case 'lte':
+        return _lte(data, parameters)
+      case 'isEmpty':
+        return _isEmpty(data, parameters)
+      case 'isNotEmpty':
+        return _isNotEmpty(data, parameters)
+      case 'toLowerCase':
+        return _toLowerCase(data)
+      case 'toUpperCase':
+        return _toUpperCase(data)
       default:
         throw new Error(`${functionName} is not a valid function`)
     }
@@ -1564,7 +2066,7 @@ function _callFunction(data, functionName, parameters) {
 
 
 
-;// ./lib/models/template/index.js
+;// ./lib/models/templateCompiler/index.js