@defra/forms-model 3.0.2

package/src/conditions/condition-model.ts

@@ -0,0 +1,314 @@
+import { ConditionField } from './condition-field'
+import { ConditionGroupDef } from './condition-group-def'
+import { Condition } from './condition'
+import { ConditionRef } from './condition-ref'
+import { ConditionGroup } from './condition-group'
+import { conditionValueFrom } from './condition-values'
+import { toPresentationString, toExpression } from './helpers'
+import { Coordinator, ConditionsArray } from './types'
+
+type ConditionRawObject =
+  | ConditionsModel
+  | {
+      name: string
+      conditions: Condition[]
+    }
+
+export class ConditionsModel {
+  #groupedConditions: ConditionsArray = []
+  #userGroupedConditions: ConditionsArray = []
+  #conditionName: string | undefined = undefined
+
+  constructor(_conditionsObject?: ConditionRawObject) {}
+
+  clone() {
+    const toReturn = new ConditionsModel()
+    toReturn.#groupedConditions = this.#groupedConditions.map((it) =>
+      it.clone()
+    )
+    toReturn.#userGroupedConditions = this.#userGroupedConditions.map((it) =>
+      it.clone()
+    )
+    toReturn.#conditionName = this.#conditionName
+    return toReturn
+  }
+
+  clear() {
+    this.#userGroupedConditions = []
+    this.#groupedConditions = []
+    this.#conditionName = undefined
+    return this
+  }
+
+  set name(name) {
+    this.#conditionName = name
+  }
+
+  get name() {
+    return this.#conditionName
+  }
+
+  add(condition: Condition) {
+    const coordinatorExpected = this.#userGroupedConditions.length !== 0
+
+    if (condition.getCoordinator() && !coordinatorExpected) {
+      throw Error('No coordinator allowed on the first condition')
+    } else if (!condition.getCoordinator() && coordinatorExpected) {
+      throw Error('Coordinator must be present on subsequent conditions')
+    }
+
+    this.#userGroupedConditions.push(condition)
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions)
+
+    return this
+  }
+
+  replace(index: number, condition: Condition) {
+    const coordinatorExpected = index !== 0
+
+    if (condition.getCoordinator() && !coordinatorExpected) {
+      throw Error('No coordinator allowed on the first condition')
+    } else if (!condition.getCoordinator() && coordinatorExpected) {
+      throw Error('Coordinator must be present on subsequent conditions')
+    } else if (index >= this.#userGroupedConditions.length) {
+      throw Error(
+        `Cannot replace condition ${index} as no such condition exists`
+      )
+    }
+
+    this.#userGroupedConditions.splice(index, 1, condition)
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions)
+
+    return this
+  }
+
+  remove(indexes: number[]) {
+    this.#userGroupedConditions = this.#userGroupedConditions
+      .filter((_condition, index) => !indexes.includes(index))
+      .map((condition, index) =>
+        index === 0 ? condition.asFirstCondition() : condition
+      )
+
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions)
+    return this
+  }
+
+  addGroups(groupDefs: ConditionGroupDef[]) {
+    this.#userGroupedConditions = this._group(
+      this.#userGroupedConditions,
+      groupDefs
+    )
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions)
+    return this
+  }
+
+  splitGroup(index: number) {
+    this.#userGroupedConditions = this._ungroup(
+      this.#userGroupedConditions,
+      index
+    )
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions)
+    return this
+  }
+
+  moveEarlier(index: number) {
+    if (index > 0 && index < this.#userGroupedConditions.length) {
+      this.#userGroupedConditions.splice(
+        index - 1,
+        0,
+        this.#userGroupedConditions.splice(index, 1)[0]
+      )
+      if (index === 1) {
+        this.switchCoordinators()
+      }
+      this.#groupedConditions = this._applyGroups(this.#userGroupedConditions)
+    }
+    return this
+  }
+
+  moveLater(index: number) {
+    if (index >= 0 && index < this.#userGroupedConditions.length - 1) {
+      this.#userGroupedConditions.splice(
+        index + 1,
+        0,
+        this.#userGroupedConditions.splice(index, 1)[0]
+      )
+      if (index === 0) {
+        this.switchCoordinators()
+      }
+      this.#groupedConditions = this._applyGroups(this.#userGroupedConditions)
+    }
+    return this
+  }
+
+  switchCoordinators() {
+    this.#userGroupedConditions[1].setCoordinator(
+      this.#userGroupedConditions[0].getCoordinator()
+    )
+    this.#userGroupedConditions[0].setCoordinator(undefined)
+  }
+
+  get asPerUserGroupings() {
+    return [...this.#userGroupedConditions]
+  }
+
+  get hasConditions() {
+    return this.#userGroupedConditions.length > 0
+  }
+
+  get lastIndex() {
+    return this.#userGroupedConditions.length - 1
+  }
+
+  toPresentationString() {
+    return this.#groupedConditions
+      .map((condition) => toPresentationString(condition))
+      .join(' ')
+  }
+
+  toExpression() {
+    return this.#groupedConditions
+      .map((condition) => toExpression(condition))
+      .join(' ')
+  }
+
+  _applyGroups(
+    userGroupedConditions: (Condition | ConditionGroup | ConditionRef)[]
+  ) {
+    const correctedUserGroups = userGroupedConditions.map((condition) =>
+      condition instanceof ConditionGroup && condition.conditions.length > 2
+        ? new ConditionGroup(
+            this._group(
+              condition.conditions,
+              this._autoGroupDefs(condition.conditions)
+            )
+          )
+        : condition
+    )
+
+    return this._group(
+      correctedUserGroups,
+      this._autoGroupDefs(correctedUserGroups)
+    )
+  }
+
+  _group(conditions: ConditionsArray, groupDefs: ConditionGroupDef[]) {
+    return conditions.reduce((groups, condition, index, conditions) => {
+      const groupDef = groupDefs.find((groupDef) => groupDef.contains(index))
+
+      if (groupDef) {
+        if (groupDef.startsWith(index)) {
+          const groupConditions = groupDef.applyTo(conditions)
+          groups.push(new ConditionGroup(groupConditions))
+        }
+      } else {
+        groups.push(condition)
+      }
+
+      return groups
+    }, [] as ConditionsArray)
+  }
+
+  _ungroup(conditions: ConditionsArray, splitIndex: number) {
+    if (conditions[splitIndex].isGroup()) {
+      const copy = [...conditions]
+      copy.splice(
+        splitIndex,
+        1,
+        ...conditions[splitIndex].getGroupedConditions()
+      )
+      return copy
+    }
+    return conditions
+  }
+
+  _autoGroupDefs(conditions: ConditionsArray) {
+    const orPositions: number[] = []
+
+    conditions.forEach((condition, index) => {
+      if (condition.getCoordinator() === Coordinator.OR) {
+        orPositions.push(index)
+      }
+    })
+
+    const hasOr = orPositions.length > 0
+    const hasAnd = !!conditions.find(
+      (condition) => condition.getCoordinator() === Coordinator.AND
+    )
+
+    if (hasAnd && hasOr) {
+      let start = 0
+      const groupDefs: ConditionGroupDef[] = []
+      orPositions.forEach((position, index) => {
+        if (start < position - 1) {
+          groupDefs.push(new ConditionGroupDef(start, position - 1))
+        }
+        const thisIsTheLastOr = orPositions.length === index + 1
+        const thereAreMoreConditions = conditions.length - 1 > position
+        if (thisIsTheLastOr && thereAreMoreConditions) {
+          groupDefs.push(new ConditionGroupDef(position, conditions.length - 1))
+        }
+        start = position
+      })
+      return groupDefs
+    }
+
+    return []
+  }
+
+  toJSON() {
+    const name = this.#conditionName
+    const conditions = this.#userGroupedConditions
+    return {
+      name,
+      conditions: conditions.map((it) => it.clone())
+    }
+  }
+
+  // TODO:- why is this not a constructor?
+  static from(obj: ConditionRawObject | ConditionsModel) {
+    if (obj instanceof ConditionsModel) {
+      return obj
+    }
+    const toReturn = new ConditionsModel()
+    toReturn.#conditionName = obj.name
+    toReturn.#userGroupedConditions = obj.conditions.map((condition) =>
+      conditionFrom(condition)
+    )
+    toReturn.#groupedConditions = toReturn._applyGroups(
+      toReturn.#userGroupedConditions
+    )
+    return toReturn
+  }
+}
+
+interface ConditionFrom {
+  (
+    it: Condition | ConditionRef | ConditionGroup
+  ): Condition | ConditionRef | ConditionGroup
+}
+
+const conditionFrom: ConditionFrom = function (it) {
+  if ('conditions' in it) {
+    return new ConditionGroup(
+      (it as ConditionGroup).conditions.map((condition) =>
+        conditionFrom(condition)
+      )
+    )
+  }
+
+  if ('conditionName' in it) {
+    return new ConditionRef(
+      it.conditionName,
+      it.conditionDisplayName,
+      it.coordinator
+    )
+  }
+
+  return new Condition(
+    ConditionField.from(it.field),
+    it.operator,
+    conditionValueFrom(it.value),
+    it.coordinator
+  )
+}

package/src/conditions/condition-operators.ts

@@ -0,0 +1,176 @@
+import { ComponentType, ComponentDef } from '../components'
+import { ConditionValueAbstract } from './condition-value-abstract'
+
+import {
+  timeUnits,
+  dateUnits,
+  dateTimeUnits,
+  ConditionValue,
+  DateDirections,
+  RelativeTimeValue
+} from './condition-values'
+
+type Operator = '==' | '!=' | '>=' | '<=' | '<' | '>'
+
+const defaultOperators = {
+  is: inline('=='),
+  'is not': inline('!=')
+}
+
+function withDefaults<T>(param: T) {
+  return Object.assign({}, param, defaultOperators)
+}
+
+const textBasedFieldCustomisations = {
+  'is longer than': lengthIs('>'),
+  'is shorter than': lengthIs('<'),
+  'has length': lengthIs('==')
+}
+
+const absoluteDateTimeOperators = {
+  is: absoluteDateTime('=='),
+  'is not': absoluteDateTime('!='),
+  'is before': absoluteDateTime('<'),
+  'is after': absoluteDateTime('>')
+}
+
+const relativeTimeOperators = (units) => ({
+  'is at least': relativeTime('<=', '>=', units),
+  'is at most': relativeTime('>=', '<=', units),
+  'is less than': relativeTime('>', '<', units),
+  'is more than': relativeTime('<', '>', units)
+})
+
+export const customOperators = {
+  CheckboxesField: {
+    contains: reverseInline('in'),
+    'does not contain': not(reverseInline('in'))
+  },
+  NumberField: withDefaults({
+    'is at least': inline('>='),
+    'is at most': inline('<='),
+    'is less than': inline('<'),
+    'is more than': inline('>')
+  }),
+  DateField: Object.assign(
+    {},
+    absoluteDateTimeOperators,
+    relativeTimeOperators(dateUnits)
+  ),
+  TimeField: Object.assign(
+    {},
+    absoluteDateTimeOperators,
+    relativeTimeOperators(timeUnits)
+  ),
+  DatePartsField: Object.assign(
+    {},
+    absoluteDateTimeOperators,
+    relativeTimeOperators(dateUnits)
+  ),
+  DateTimeField: Object.assign(
+    {},
+    absoluteDateTimeOperators,
+    relativeTimeOperators(dateTimeUnits)
+  ),
+  DateTimePartsField: Object.assign(
+    {},
+    absoluteDateTimeOperators,
+    relativeTimeOperators(dateTimeUnits)
+  ),
+  TextField: withDefaults(textBasedFieldCustomisations),
+  MultilineTextField: withDefaults(textBasedFieldCustomisations),
+  EmailAddressField: withDefaults(textBasedFieldCustomisations)
+}
+
+export function getOperatorNames(fieldType) {
+  return Object.keys(getConditionals(fieldType)).sort()
+}
+
+export function getExpression(
+  fieldType: ComponentType,
+  fieldName: string,
+  operator: string,
+  value: ConditionValueAbstract
+) {
+  return getConditionals(fieldType)[operator].expression(
+    { type: fieldType, name: fieldName },
+    value
+  )
+}
+
+export function getOperatorConfig(fieldType: ComponentType, operator) {
+  return getConditionals(fieldType)[operator]
+}
+
+function getConditionals(fieldType: ComponentType) {
+  return customOperators[fieldType] || defaultOperators
+}
+
+function inline(operator: Operator) {
+  return {
+    expression: (field: ComponentDef, value) =>
+      `${field.name} ${operator} ${formatValue(field.type, value.value)}`
+  }
+}
+
+function lengthIs(operator: Operator) {
+  return {
+    expression: (field: ComponentDef, value) =>
+      `length(${field.name}) ${operator} ${value.value}`
+  }
+}
+
+function reverseInline(operator: 'in') {
+  return {
+    expression: (field: ComponentDef, value) =>
+      `${formatValue(field.type, value.value)} ${operator} ${field.name}`
+  }
+}
+
+function not(operatorDefinition) {
+  return {
+    expression: (field: ComponentDef, value) =>
+      `not (${operatorDefinition.expression(field, value)})`
+  }
+}
+
+function formatValue(fieldType: ComponentType, value) {
+  if (fieldType === 'NumberField' || fieldType === 'YesNoField') {
+    return value
+  }
+  return `'${value}'`
+}
+
+export const absoluteDateOrTimeOperatorNames = Object.keys(
+  absoluteDateTimeOperators
+)
+export const relativeDateOrTimeOperatorNames = Object.keys(
+  relativeTimeOperators(dateTimeUnits)
+)
+
+function absoluteDateTime(operator: Operator) {
+  return {
+    expression: (field: ComponentDef, value) => {
+      if (value instanceof ConditionValue) {
+        return `${field.name} ${operator} '${value.toExpression()}'`
+      }
+      throw Error('only Value types are supported')
+    }
+  }
+}
+
+function relativeTime(pastOperator, futureOperator, units) {
+  return {
+    units,
+    expression: (field: ComponentDef, value) => {
+      if (value instanceof RelativeTimeValue) {
+        const operator =
+          value.direction === DateDirections.PAST
+            ? pastOperator
+            : futureOperator
+        return `${field.name} ${operator} ${value.toExpression()}`
+      }
+      throw Error('time shift requires a TimeShiftValue')
+    }
+  }
+}

package/src/conditions/condition-ref.ts

@@ -0,0 +1,47 @@
+import { ConditionAbstract } from './condition-abstract'
+import { Coordinator } from './types'
+
+export class ConditionRef extends ConditionAbstract {
+  conditionName: string
+  conditionDisplayName: string
+
+  constructor(
+    conditionName: string,
+    conditionDisplayName: string,
+    coordinator: Coordinator | undefined
+  ) {
+    super(coordinator)
+
+    if (typeof conditionName !== 'string') {
+      throw Error(`condition name ${conditionName} is not valid`)
+    }
+
+    if (typeof conditionDisplayName !== 'string') {
+      throw Error(`condition display name ${conditionDisplayName} is not valid`)
+    }
+
+    this.conditionName = conditionName
+    this.conditionDisplayName = conditionDisplayName
+  }
+
+  asFirstCondition() {
+    this._asFirstCondition()
+    return this
+  }
+
+  conditionString() {
+    return `'${this.conditionDisplayName}'`
+  }
+
+  conditionExpression() {
+    return this.conditionName
+  }
+
+  clone() {
+    return new ConditionRef(
+      this.conditionName,
+      this.conditionDisplayName,
+      this.coordinator
+    )
+  }
+}

package/src/conditions/condition-value-abstract.ts

@@ -0,0 +1,31 @@
+import { Registration } from './condition-value-registration'
+
+export class ConditionValueAbstract {
+  type: string
+
+  constructor(registration: Registration) {
+    if (new.target === ConditionValueAbstract) {
+      throw new TypeError('Cannot construct ConditionValue instances directly')
+    }
+
+    if (!(registration instanceof Registration)) {
+      throw new TypeError(
+        'You must register your value type! Call registerValueType!'
+      )
+    }
+
+    this.type = registration.type
+  }
+
+  toPresentationString() {
+    throw new Error(
+      'Unsupported Operation. Method toPresentationString have not been implemented'
+    )
+  }
+
+  toExpression() {
+    throw new Error(
+      'Unsupported Operation. Method toExpression have not been implemented'
+    )
+  }
+}

package/src/conditions/condition-value-registration.ts

@@ -0,0 +1,18 @@
+const conditionValueFactories = {}
+
+export class Registration {
+  type: string
+
+  constructor(type: string, factory: (obj: any) => Registration) {
+    conditionValueFactories[type] = factory
+    this.type = type
+  }
+
+  static register(type: string, factory: (obj: any) => Registration) {
+    return new Registration(type, factory)
+  }
+
+  static conditionValueFrom(obj: { type: string; [prop: string]: any }) {
+    return conditionValueFactories[obj.type](obj)
+  }
+}