Skip to content

Beautiful Open-Source Form Builder

20.6 KB
Raw Blame
import { compareDates } from './dateComparison.js'
import { default as _isEqual } from "lodash/isEqual"

const mentionSpanRegex = /<span\b(?=[^>]*\bmention\b)[^>]*>.*?<\/span>/gis

function getAttributeValue(html, attribute) {
  const match = html.match(new RegExp(`${attribute}=(["'])(.*?)\\1`, 'i'))
  return match?.[2] ?? null
}

function getMentionText(fieldValue, fallback = '') {
  if (fieldValue !== undefined && fieldValue !== null) {
    return Array.isArray(fieldValue) ? fieldValue.join(', ') : String(fieldValue)
  }
  return fallback || ''
}

function stripHtml(value) {
  return value.replace(/<[^>]+>/g, '').trim()
}

function resolveConditionValue(value, formData) {
  if (typeof value !== 'string' || !value.includes('mention-field-id')) {
    return value
  }

  const mentions = [...value.matchAll(mentionSpanRegex)].map(match => match[0])
  if (mentions.length === 0) return value

  if (mentions.length === 1) {
    const mention = mentions[0]
    const fieldId = getAttributeValue(mention, 'mention-field-id')
    const fallback = getAttributeValue(mention, 'mention-fallback')
    const remainingText = stripHtml(value.replace(mentionSpanRegex, ''))

    // Single mention with no surrounding text — return the raw field value to preserve type
    if (remainingText === '') {
      const resolved = formData[fieldId]
      if (resolved !== undefined && resolved !== null) return resolved
      if (fallback) return fallback
      return null
    }
  }

  // Multiple mentions or mixed content — resolve to string
  const resolvedValue = value.replace(mentionSpanRegex, mention => {
    const fieldId = getAttributeValue(mention, 'mention-field-id')
    const fallback = getAttributeValue(mention, 'mention-fallback')
    const fieldValue = formData[fieldId]
    return getMentionText(fieldValue, fallback)
  })

  return stripHtml(resolvedValue)
}

export function conditionsMet(conditions, formData, properties = []) {
  if (conditions === undefined || conditions === null) {
    return false
  }

  // If it's not a group, just a single condition
  if (conditions.operatorIdentifier === undefined) {
    const condition = conditions.value
    if (!condition) return false

    const field = properties.find(property => property.id === condition.property_meta?.id)
    const resolvedCondition = { ...condition, property_meta: {
      ...condition.property_meta,
      ...(field?.type === 'date' ? { with_time: field.with_time === true } : {}),
    } }
    if (resolvedCondition.value !== undefined && resolvedCondition.value !== null) {
      resolvedCondition.value = resolveConditionValue(resolvedCondition.value, formData)
    }

    return propertyConditionMet(
      resolvedCondition,
      formData[condition.property_meta.id],
    )
  }

  if (conditions.operatorIdentifier === "and") {
    let isvalid = true
    if (!Array.isArray(conditions.children) || conditions.children.length === 0) return false
    conditions.children.forEach((childrenCondition) => {
      if (!conditionsMet(childrenCondition, formData, properties)) {
        isvalid = false
      }
    })
    return isvalid
  } else if (conditions.operatorIdentifier === "or") {
    let isvalid = false
    if (!Array.isArray(conditions.children) || conditions.children.length === 0) return false
    conditions.children.forEach((childrenCondition) => {
      if (conditionsMet(childrenCondition, formData, properties)) {
        isvalid = true
      }
    })
    return isvalid
  }

  throw new Error(
    "Unexcepted operatorIdentifier:" + conditions.operatorIdentifier,
  )
}

function propertyConditionMet(propertyCondition, value) {
  if (!propertyCondition) {
    return false
  }
  switch (propertyCondition.property_meta.type) {
    case "text":
    case "url":
    case "email":
    case "phone_number":
      return textConditionMet(propertyCondition, value)
    case "number":
    case "rating":
    case "scale":
    case "slider":
      return numberConditionMet(propertyCondition, value)
    case "checkbox":
      return checkboxConditionMet(propertyCondition, value)
    case "select":
      return selectConditionMet(propertyCondition, value)
    case "date":
      return dateConditionMet(propertyCondition, value)
    case "multi_select":
      return multiSelectConditionMet(propertyCondition, value)
    case "files":
      return filesConditionMet(propertyCondition, value)
    case "matrix":
      return matrixConditionMet(propertyCondition, value)
    case "payment":
      return paymentConditionMet(propertyCondition, value)
    case "computed":
      return computedConditionMet(propertyCondition, value)
  }
  return false
}

function isComputedNumberCondition(propertyCondition, value) {
  const resultType = propertyCondition?.property_meta?.result_type
  if (['number', 'numeric', 'integer', 'float'].includes(resultType)) {
    return true
  }
  return typeof value === 'number'
}

function computedConditionMet(propertyCondition, value) {
  if (isComputedNumberCondition(propertyCondition, value)) {
    switch (propertyCondition.operator) {
      case "equals":
        return safeParseFloat(propertyCondition.value) !== null &&
          safeParseFloat(value) !== null &&
          parseFloat(propertyCondition.value) === parseFloat(value)
      case "does_not_equal":
        return safeParseFloat(propertyCondition.value) === null ||
          safeParseFloat(value) === null ||
          parseFloat(propertyCondition.value) !== parseFloat(value)
      default:
        return numberConditionMet(propertyCondition, value)
    }
  }

  return textConditionMet(propertyCondition, value)
}

// Helper function to safely parse numeric values
function safeParseFloat(value) {
  if (value === undefined || value === null) return null
  const parsed = parseFloat(value)
  return isNaN(parsed) ? null : parsed
}

// Helper function to check if values are valid for numeric comparison
function areValidNumbers(condition, fieldValue) {
  const conditionValue = safeParseFloat(condition.value)
  const parsedFieldValue = safeParseFloat(fieldValue)
  return conditionValue !== null && parsedFieldValue !== null
}

function checkEquals(condition, fieldValue) {
  const conditionValue = condition.value
  // For numeric values, convert to numbers before comparison
  if (areValidNumbers(condition, fieldValue) && (typeof conditionValue === 'number' || typeof fieldValue === 'number')
      && String(conditionValue).trim() !== '' && String(fieldValue).trim() !== ''
      && Number.isFinite(Number(conditionValue)) && Number.isFinite(Number(fieldValue))) {
    return parseFloat(conditionValue) === parseFloat(fieldValue)
  }
  return conditionValue === fieldValue
}

function checkObjectEquals(condition, fieldValue) {
  return _isEqual(condition.value, fieldValue)
}

function checkMatrixContains(condition, fieldValue)
{
  if (!fieldValue || typeof fieldValue !== "object" || !condition.value || typeof condition.value !== "object") {
    return false
  }
  const entries = Object.entries(condition.value)
  return entries.some(([key, value]) => Object.prototype.hasOwnProperty.call(fieldValue, key) && _isEqual(value, fieldValue[key]))
}

function checkContains(condition, fieldValue) {
  if (!fieldValue || typeof fieldValue !== 'string') return false
  if (typeof condition.value !== 'string') return false
  return fieldValue.includes(condition.value)
}

function checkListContains(condition, fieldValue) {
  if (!fieldValue) return false

  if (Array.isArray(condition.value)) {
    return condition.value.every((r) => fieldValue.includes(r))
  } else {
    return fieldValue.includes(condition.value)
  }
}

function checkStartsWith(condition, fieldValue) {
  if (typeof fieldValue !== 'string' || typeof condition.value !== 'string') return false
  return fieldValue?.startsWith(condition.value)
}

function checkendsWith(condition, fieldValue) {
  if (typeof fieldValue !== 'string' || typeof condition.value !== 'string') return false
  return fieldValue?.endsWith(condition.value)
}

function checkIsEmpty(condition, fieldValue) {
  return fieldValue === null || fieldValue === undefined || fieldValue === ''
    || (Array.isArray(fieldValue) && fieldValue.length === 0)
}

function checkGreaterThan(condition, fieldValue) {
  if (!areValidNumbers(condition, fieldValue)) return false
  return parseFloat(fieldValue) > parseFloat(condition.value)
}

function checkGreaterThanEqual(condition, fieldValue) {
  if (!areValidNumbers(condition, fieldValue)) return false
  return parseFloat(fieldValue) >= parseFloat(condition.value)
}

function checkLessThan(condition, fieldValue) {
  if (!areValidNumbers(condition, fieldValue)) return false
  return parseFloat(fieldValue) < parseFloat(condition.value)
}

function checkLessThanEqual(condition, fieldValue) {
  if (!areValidNumbers(condition, fieldValue)) return false
  return parseFloat(fieldValue) <= parseFloat(condition.value)
}

function checkPastWeek(condition, fieldValue) {
  if (!fieldValue) return false
  const fieldDate = new Date(fieldValue)
  const today = new Date()
  return (
    fieldDate <= today &&
    fieldDate >=
    new Date(today.getFullYear(), today.getMonth(), today.getDate() - 7)
  )
}

function checkPastMonth(condition, fieldValue) {
  if (!fieldValue) return false
  const fieldDate = new Date(fieldValue)
  const today = new Date()
  return (
    fieldDate <= today &&
    fieldDate >=
    new Date(today.getFullYear(), today.getMonth() - 1, today.getDate())
  )
}

function checkPastYear(condition, fieldValue) {
  if (!fieldValue) return false
  const fieldDate = new Date(fieldValue)
  const today = new Date()
  return (
    fieldDate <= today &&
    fieldDate >=
    new Date(today.getFullYear() - 1, today.getMonth(), today.getDate())
  )
}

function checkNextWeek(condition, fieldValue) {
  if (!fieldValue) return false
  const fieldDate = new Date(fieldValue)
  const today = new Date()
  return (
    fieldDate >= today &&
    fieldDate <=
    new Date(today.getFullYear(), today.getMonth(), today.getDate() + 7)
  )
}

function checkNextMonth(condition, fieldValue) {
  if (!fieldValue) return false
  const fieldDate = new Date(fieldValue)
  const today = new Date()
  return (
    fieldDate >= today &&
    fieldDate <=
    new Date(today.getFullYear(), today.getMonth() + 1, today.getDate())
  )
}

function checkNextYear(condition, fieldValue) {
  if (!fieldValue) return false
  const fieldDate = new Date(fieldValue)
  const today = new Date()
  return (
    fieldDate >= today &&
    fieldDate <=
    new Date(today.getFullYear() + 1, today.getMonth(), today.getDate())
  )
}

function checkAtLeastXDaysAgo(condition, fieldValue) {
  if (!fieldValue || condition.value === null || condition.value === undefined || condition.value === '') return false
  const fieldDate = new Date(fieldValue)
  if (Number.isNaN(fieldDate.getTime())) return false
  const today = new Date()
  const daysBefore = parseInt(condition.value, 10)
  if (isNaN(daysBefore) || daysBefore < 0) return false
  // Create target date by setting the date properly to avoid timezone issues
  const targetDate = new Date(today.getFullYear(), today.getMonth(), today.getDate() - daysBefore)
  // Return true if fieldDate is on or before the target date (X days before today)
  return fieldDate <= targetDate
}

function checkAtLeastXDaysFromNow(condition, fieldValue) {
  if (!fieldValue || condition.value === null || condition.value === undefined || condition.value === '') return false
  const fieldDate = new Date(fieldValue)
  if (Number.isNaN(fieldDate.getTime())) return false
  const today = new Date()
  const daysAfter = parseInt(condition.value, 10)
  if (isNaN(daysAfter) || daysAfter < 0) return false
  // Create target date by setting the date properly to avoid timezone issues
  const targetDate = new Date(today.getFullYear(), today.getMonth(), today.getDate() + daysAfter)
  // Return true if fieldDate is on or after the target date (X days after today)
  return fieldDate >= targetDate
}

function checkWithinPastXDays(condition, fieldValue) {
  if (!fieldValue || condition.value === null || condition.value === undefined || condition.value === '') return false
  const fieldDate = new Date(fieldValue)
  if (Number.isNaN(fieldDate.getTime())) return false
  const today = new Date()
  const daysBefore = parseInt(condition.value, 10)
  if (isNaN(daysBefore) || daysBefore < 0) return false
  // Create target date by setting the date properly to avoid timezone issues
  const targetDate = new Date(today.getFullYear(), today.getMonth(), today.getDate() - daysBefore)
  const todayDate = new Date(today.getFullYear(), today.getMonth(), today.getDate())
  // Return true if fieldDate is between target date (X days ago) and today (inclusive)
  return fieldDate >= targetDate && fieldDate <= todayDate
}

function checkWithinNextXDays(condition, fieldValue) {
  if (!fieldValue || condition.value === null || condition.value === undefined || condition.value === '') return false
  const fieldDate = new Date(fieldValue)
  if (Number.isNaN(fieldDate.getTime())) return false
  const today = new Date()
  const daysAfter = parseInt(condition.value, 10)
  if (isNaN(daysAfter) || daysAfter < 0) return false
  // Create target date by setting the date properly to avoid timezone issues
  const targetDate = new Date(today.getFullYear(), today.getMonth(), today.getDate() + daysAfter)
  const todayDate = new Date(today.getFullYear(), today.getMonth(), today.getDate())
  // Return true if fieldDate is between today and target date (X days from now) (inclusive)
  return fieldDate >= todayDate && fieldDate <= targetDate
}

function checkLength(condition, fieldValue, operator = "===") {
  if (!fieldValue || fieldValue.length === 0) return false
  switch (operator) {
    case "===":
      return fieldValue.length === parseInt(condition.value)
    case "!==":
      return fieldValue.length !== parseInt(condition.value)
    case ">":
      return fieldValue.length > parseInt(condition.value)
    case ">=":
      return fieldValue.length >= parseInt(condition.value)
    case "<":
      return fieldValue.length < parseInt(condition.value)
    case "<=":
      return fieldValue.length <= parseInt(condition.value)
  }
  return false
}

function textConditionMet(propertyCondition, value) {
  switch (propertyCondition.operator) {
    case "equals":
      return checkEquals(propertyCondition, value)
    case "does_not_equal":
      return !checkEquals(propertyCondition, value)
    case "contains":
      return checkContains(propertyCondition, value)
    case "does_not_contain":
      return !checkContains(propertyCondition, value)
    case "starts_with":
      return checkStartsWith(propertyCondition, value)
    case "ends_with":
      return checkendsWith(propertyCondition, value)
    case "is_empty":
      return checkIsEmpty(propertyCondition, value)
    case "is_not_empty":
      return !checkIsEmpty(propertyCondition, value)
    case "content_length_equals":
      return checkLength(propertyCondition, value, "===")
    case "content_length_does_not_equal":
      return checkLength(propertyCondition, value, "!==")
    case "content_length_greater_than":
      return checkLength(propertyCondition, value, ">")
    case "content_length_greater_than_or_equal_to":
      return checkLength(propertyCondition, value, ">=")
    case "content_length_less_than":
      return checkLength(propertyCondition, value, "<")
    case "content_length_less_than_or_equal_to":
      return checkLength(propertyCondition, value, "<=")
    case 'matches_regex':
      try {
        if (typeof propertyCondition.value !== 'string' || typeof value !== 'string') return false
        const regex = new RegExp(propertyCondition.value)
        return regex.test(value)
      } catch {
        return false
      }
    case 'does_not_match_regex':
      try {
        if (typeof propertyCondition.value !== 'string' || typeof value !== 'string') return true
        const regex2 = new RegExp(propertyCondition.value)
        return !regex2.test(value)
      } catch {
        return false
      }
  }
  return false
}

function numberConditionMet(propertyCondition, value) {
  switch (propertyCondition.operator) {
    case "equals":
      return checkEquals(propertyCondition, value)
    case "does_not_equal":
      return !checkEquals(propertyCondition, value)
    case "greater_than":
      return checkGreaterThan(propertyCondition, value)
    case "less_than":
      return checkLessThan(propertyCondition, value)
    case "greater_than_or_equal_to":
      return checkGreaterThanEqual(propertyCondition, value)
    case "less_than_or_equal_to":
      return checkLessThanEqual(propertyCondition, value)
    case "is_empty":
      return checkIsEmpty(propertyCondition, value)
    case "is_not_empty":
      return !checkIsEmpty(propertyCondition, value)
    case "content_length_equals":
      return checkLength(propertyCondition, value, "===")
    case "content_length_does_not_equal":
      return checkLength(propertyCondition, value, "!==")
    case "content_length_greater_than":
      return checkLength(propertyCondition, value, ">")
    case "content_length_greater_than_or_equal_to":
      return checkLength(propertyCondition, value, ">=")
    case "content_length_less_than":
      return checkLength(propertyCondition, value, "<")
    case "content_length_less_than_or_equal_to":
      return checkLength(propertyCondition, value, "<=")
  }
  return false
}

function checkboxConditionMet(propertyCondition, value) {
  switch (propertyCondition.operator) {
    case "is_checked":
      return value === true
    case "is_not_checked":
      return value === false
    // Legacy operators
    case "equals":
      return value === true
    case "does_not_equal":
      return value === false
  }
  return false
}

function selectConditionMet(propertyCondition, value) {
  switch (propertyCondition.operator) {
    case "equals":
      return checkEquals(propertyCondition, value)
    case "does_not_equal":
      return !checkEquals(propertyCondition, value)
    case "is_empty":
      return checkIsEmpty(propertyCondition, value)
    case "is_not_empty":
      return !checkIsEmpty(propertyCondition, value)
  }
  return false
}

function dateConditionMet(propertyCondition, value) {
  if (['equals', 'before', 'after', 'on_or_before', 'on_or_after'].includes(propertyCondition.operator)) {
    return compareDates(propertyCondition.operator, value, propertyCondition.value, propertyCondition.property_meta?.with_time ?? true)
  }
  switch (propertyCondition.operator) {
    case 'at_least_x_days_ago':
      return checkAtLeastXDaysAgo(propertyCondition, value)
    case 'at_least_x_days_from_now':
      return checkAtLeastXDaysFromNow(propertyCondition, value)
    case 'within_past_x_days':
      return checkWithinPastXDays(propertyCondition, value)
    case 'within_next_x_days':
      return checkWithinNextXDays(propertyCondition, value)
    case "is_empty":
      return checkIsEmpty(propertyCondition, value)
    case "past_week":
      return checkPastWeek(propertyCondition, value)
    case "past_month":
      return checkPastMonth(propertyCondition, value)
    case "past_year":
      return checkPastYear(propertyCondition, value)
    case "next_week":
      return checkNextWeek(propertyCondition, value)
    case "next_month":
      return checkNextMonth(propertyCondition, value)
    case "next_year":
      return checkNextYear(propertyCondition, value)
  }
  return false
}

function multiSelectConditionMet(propertyCondition, value) {
  switch (propertyCondition.operator) {
    case "contains":
      return checkListContains(propertyCondition, value)
    case "does_not_contain":
      return !checkListContains(propertyCondition, value)
    case "is_empty":
      return checkIsEmpty(propertyCondition, value)
    case "is_not_empty":
      return !checkIsEmpty(propertyCondition, value)
  }
  return false
}

function filesConditionMet(propertyCondition, value) {
  switch (propertyCondition.operator) {
    case "is_empty":
      return checkIsEmpty(propertyCondition, value)
    case "is_not_empty":
      return !checkIsEmpty(propertyCondition, value)
  }
  return false
}

function matrixConditionMet(propertyCondition, value) {
  switch (propertyCondition.operator) {
    case "equals":
      return checkObjectEquals(propertyCondition, value)
    case "does_not_equal":
      return !checkObjectEquals(propertyCondition, value)
    case "contains":
     return checkMatrixContains(propertyCondition, value)
    case "does_not_contain":
     return !checkMatrixContains(propertyCondition, value)
  }
  return false
}

function paymentConditionMet(propertyCondition, value) {
  switch (propertyCondition.operator) {
    case "paid":
      return checkPaid(propertyCondition, value)
    case "not_paid":
      return !checkPaid(propertyCondition, value)
  }
  return false
}

function checkPaid(propertyCondition, value) {
  return (value) ? value.startsWith('pi_') : false
}