@defra/forms-model 3.0.168 → 3.0.170

package/src/components/types.ts

@@ -1,34 +1,12 @@
-export type ComponentType =
-  | 'TextField'
-  | 'MultilineTextField'
-  | 'YesNoField'
-  | 'DateField'
-  | 'TimeField'
-  | 'DateTimeField'
-  | 'MonthYearField'
-  | 'DatePartsField'
-  | 'DateTimePartsField'
-  | 'SelectField'
-  | 'AutocompleteField'
-  | 'RadiosField'
-  | 'CheckboxesField'
-  | 'NumberField'
-  | 'UkAddressField'
-  | 'TelephoneNumberField'
-  | 'EmailAddressField'
-  | 'FileUploadField'
-  | 'Html'
-  | 'InsetText'
-  | 'Details'
-  | 'List'
-  | 'WebsiteField'
-
-export type ComponentSubType = 'field' | 'content'
+import {
+  type ComponentSubType,
+  type ComponentType
+} from '~/src/components/enums.js'
 
 export interface ConditionalComponent {
-  name: 'TextField' | 'NumberField'
+  name: string
   title: string
-  subType: 'field'
+  subType: ComponentSubType.Field
 }
 
 export interface ContentOptions {
@@ -39,8 +17,16 @@ export interface ContentOptions {
  * Types for Components JSON structure which are expected by engine and turned into actual form input/content/lists
  */
 interface TextFieldBase {
-  subType?: 'field'
-  type: string
+  type:
+    | ComponentType.EmailAddressField
+    | ComponentType.MultilineTextField
+    | ComponentType.NumberField
+    | ComponentType.TelephoneNumberField
+    | ComponentType.TextField
+    | ComponentType.UkAddressField
+    | ComponentType.WebsiteField
+    | ComponentType.YesNoField
+  subType?: ComponentSubType.Field
   name: string
   title: string
   hint?: string
@@ -58,13 +44,13 @@ interface TextFieldBase {
     min?: number
     length?: number
     regex?: string
-    error?: any // TODO: in same cases this is a function e.g. addressLine1 in ukaddress
+    error?: unknown
   }
 }
 
 interface NumberFieldBase {
-  subType?: 'field'
-  type: string
+  type: ComponentType
+  subType?: ComponentSubType.Field
   name: string
   title: string
   hint: string
@@ -81,8 +67,13 @@ interface NumberFieldBase {
 }
 
 interface ListFieldBase {
-  subType?: 'listField' | 'content'
-  type: string
+  type:
+    | ComponentType.AutocompleteField
+    | ComponentType.CheckboxesField
+    | ComponentType.List
+    | ComponentType.RadiosField
+    | ComponentType.SelectField
+  subType?: ComponentSubType.Content | ComponentSubType.ListField
   name: string
   title: string
   options: {
@@ -96,22 +87,28 @@ interface ListFieldBase {
     allowPrePopulation?: boolean
   }
   list: string
-  schema: {}
+  schema: object
 }
 
 interface ContentFieldBase {
-  subType?: 'content'
-  type: string
+  type: ComponentType.Details | ComponentType.Html | ComponentType.InsetText
+  subType?: ComponentSubType.Content
   name: string
   title: string
   content: string
   options: ContentOptions
-  schema: {}
+  schema?: object
 }
 
 interface DateFieldBase {
-  subType?: 'field'
-  type: string
+  type:
+    | ComponentType.DateField
+    | ComponentType.DatePartsField
+    | ComponentType.DateTimeField
+    | ComponentType.DateTimePartsField
+    | ComponentType.MonthYearField
+    | ComponentType.TimeField
+  subType?: ComponentSubType.Field
   name: string
   title: string
   hint: string
@@ -123,45 +120,45 @@ interface DateFieldBase {
     maxDaysInPast?: number
     exposeToContext?: boolean
   }
-  schema: {}
+  schema: object
 }
 
 // Text Fields
 export interface TextFieldComponent extends TextFieldBase {
-  type: 'TextField'
+  type: ComponentType.TextField
   options: TextFieldBase['options'] & {
     customValidationMessage?: string
   }
 }
 
 export interface EmailAddressFieldComponent extends TextFieldBase {
-  type: 'EmailAddressField'
+  type: ComponentType.EmailAddressField
 }
 
 export interface NumberFieldComponent extends NumberFieldBase {
-  type: 'NumberField'
+  type: ComponentType.NumberField
 }
 
 export interface WebsiteFieldComponent extends TextFieldBase {
-  type: 'WebsiteField'
+  type: ComponentType.WebsiteField
   options: TextFieldBase['options'] & {
     customValidationMessage?: string
   }
 }
 
 export interface TelephoneNumberFieldComponent extends TextFieldBase {
-  type: 'TelephoneNumberField'
+  type: ComponentType.TelephoneNumberField
   options: TextFieldBase['options'] & {
     customValidationMessage?: string
   }
 }
 
 export interface YesNoFieldComponent extends TextFieldBase {
-  type: 'YesNoField'
+  type: ComponentType.YesNoField
 }
 
 export interface MultilineTextFieldComponent extends TextFieldBase {
-  type: 'MultilineTextField'
+  type: ComponentType.MultilineTextField
   options: TextFieldBase['options'] & {
     customValidationMessage?: string
     rows?: number
@@ -174,8 +171,8 @@ export interface MultilineTextFieldComponent extends TextFieldBase {
 }
 
 export interface FileUploadFieldComponent {
-  subType?: 'field'
-  type: 'FileUploadField'
+  type: ComponentType.FileUploadField
+  subType?: ComponentSubType.Field
   name: string
   title: string
   hint: string
@@ -187,75 +184,75 @@ export interface FileUploadFieldComponent {
     exposeToContext?: boolean
     imageQualityPlayback?: boolean
   }
-  schema: {}
+  schema: object
 }
 
 export interface UkAddressFieldComponent extends TextFieldBase {
-  type: 'UkAddressField'
+  type: ComponentType.UkAddressField
 }
 
 // Date Fields
 export interface DateFieldComponent extends DateFieldBase {
-  type: 'DateField'
+  type: ComponentType.DateField
 }
 
 export interface DateTimeFieldComponent extends DateFieldBase {
-  type: 'DateTimeField'
+  type: ComponentType.DateTimeField
 }
 
 export interface DatePartsFieldFieldComponent extends DateFieldBase {
-  type: 'DatePartsField'
+  type: ComponentType.DatePartsField
 }
 
 export interface MonthYearFieldComponent extends DateFieldBase {
-  type: 'MonthYearField'
+  type: ComponentType.MonthYearField
 }
 
 export interface DateTimePartsFieldComponent extends DateFieldBase {
-  type: 'DateTimePartsField'
+  type: ComponentType.DateTimePartsField
 }
 
 export interface TimeFieldComponent extends DateFieldBase {
-  type: 'TimeField'
+  type: ComponentType.TimeField
 }
 
 // Content Fields
 export interface DetailsComponent extends ContentFieldBase {
-  type: 'Details'
+  type: ComponentType.Details
 }
 
 export interface HtmlComponent extends ContentFieldBase {
-  type: 'Html'
+  type: ComponentType.Html
 }
 
 export interface InsetTextComponent extends ContentFieldBase {
-  type: 'InsetText'
+  type: ComponentType.InsetText
 }
 
 // List Fields
 export interface ListComponent extends ListFieldBase {
-  type: 'List'
+  type: ComponentType.List
 }
 
 export interface AutocompleteFieldComponent extends ListFieldBase {
-  type: 'AutocompleteField'
-  subType?: 'listField'
+  type: ComponentType.AutocompleteField
+  subType?: ComponentSubType.ListField
 }
 
 export interface CheckboxesFieldComponent extends ListFieldBase {
-  type: 'CheckboxesField'
-  subType?: 'listField'
+  type: ComponentType.CheckboxesField
+  subType?: ComponentSubType.ListField
 }
 
 export interface RadiosFieldComponent extends ListFieldBase {
-  type: 'RadiosField'
-  subType?: 'listField'
+  type: ComponentType.RadiosField
+  subType?: ComponentSubType.ListField
 }
 
 export interface SelectFieldComponent extends ListFieldBase {
-  type: 'SelectField'
+  type: ComponentType.SelectField
+  subType?: ComponentSubType.ListField
   options: ListFieldBase['options'] & { autocomplete?: string }
-  subType?: 'listField'
 }
 
 export type ComponentDef =

package/src/conditions/condition-field.ts

@@ -1,5 +1,5 @@
 import { ComponentTypes } from '~/src/components/component-types.js'
-import { type ComponentType } from '~/src/components/types.js'
+import { type ComponentType } from '~/src/components/enums.js'
 
 export class ConditionField {
   name: string

package/src/conditions/condition-operators.ts

@@ -1,7 +1,5 @@
-import {
-  type ComponentType,
-  type ComponentDef
-} from '~/src/components/types.js'
+import { ComponentType } from '~/src/components/enums.js'
+import { type ComponentDef } from '~/src/components/types.js'
 import { type ConditionValueAbstract } from '~/src/conditions/condition-value-abstract.js'
 import {
   timeUnits,
@@ -44,44 +42,46 @@ const relativeTimeOperators = (units) => ({
 })
 
 export const customOperators = {
-  CheckboxesField: {
+  [ComponentType.CheckboxesField]: {
     contains: reverseInline('in'),
     'does not contain': not(reverseInline('in'))
   },
-  NumberField: withDefaults({
+  [ComponentType.NumberField]: withDefaults({
     'is at least': inline('>='),
     'is at most': inline('<='),
     'is less than': inline('<'),
     'is more than': inline('>')
   }),
-  DateField: Object.assign(
+  [ComponentType.DateField]: Object.assign(
     {},
     absoluteDateTimeOperators,
     relativeTimeOperators(dateUnits)
   ),
-  TimeField: Object.assign(
+  [ComponentType.TimeField]: Object.assign(
     {},
     absoluteDateTimeOperators,
     relativeTimeOperators(timeUnits)
   ),
-  DatePartsField: Object.assign(
+  [ComponentType.DatePartsField]: Object.assign(
     {},
     absoluteDateTimeOperators,
     relativeTimeOperators(dateUnits)
   ),
-  DateTimeField: Object.assign(
+  [ComponentType.DateTimeField]: Object.assign(
     {},
     absoluteDateTimeOperators,
     relativeTimeOperators(dateTimeUnits)
   ),
-  DateTimePartsField: Object.assign(
+  [ComponentType.DateTimePartsField]: Object.assign(
     {},
     absoluteDateTimeOperators,
     relativeTimeOperators(dateTimeUnits)
   ),
-  TextField: withDefaults(textBasedFieldCustomisations),
-  MultilineTextField: withDefaults(textBasedFieldCustomisations),
-  EmailAddressField: withDefaults(textBasedFieldCustomisations)
+  [ComponentType.TextField]: withDefaults(textBasedFieldCustomisations),
+  [ComponentType.MultilineTextField]: withDefaults(
+    textBasedFieldCustomisations
+  ),
+  [ComponentType.EmailAddressField]: withDefaults(textBasedFieldCustomisations)
 }
 
 export function getOperatorNames(fieldType) {
@@ -137,9 +137,13 @@ function not(operatorDefinition) {
 }
 
 function formatValue(fieldType: ComponentType, value) {
-  if (fieldType === 'NumberField' || fieldType === 'YesNoField') {
+  if (
+    fieldType === ComponentType.YesNoField ||
+    fieldType === ComponentType.NumberField
+  ) {
     return value
   }
+
   return `'${value}'`
 }
 

package/src/conditions/condition-ref.ts

@@ -13,11 +13,13 @@ export class ConditionRef extends ConditionAbstract {
     super(coordinator)
 
     if (typeof conditionName !== 'string') {
-      throw Error(`condition name ${conditionName} is not valid`)
+      throw new Error("ConditionRef param 'conditionName' must be a string")
     }
 
     if (typeof conditionDisplayName !== 'string') {
-      throw Error(`condition display name ${conditionDisplayName} is not valid`)
+      throw new Error(
+        "ConditionRef param 'conditionDisplayName' must be a string"
+      )
     }
 
     this.conditionName = conditionName

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

@@ -1,31 +1,19 @@
-import { Registration } from '~/src/conditions/condition-value-registration.js'
-
 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(): string {
+    throw new Error(
+      'Unsupported Operation. Method toPresentationString has not been implemented'
+    )
   }
 
-  toPresentationString() {
+  toExpression(): string {
     throw new Error(
-      'Unsupported Operation. Method toPresentationString have not been implemented'
+      'Unsupported Operation. Method toExpression has not been implemented'
     )
   }
 
-  toExpression() {
+  clone() {
     throw new Error(
-      'Unsupported Operation. Method toExpression have not been implemented'
+      'Unsupported Operation. Method clone has not been implemented'
     )
   }
 }

package/src/conditions/condition-values.ts

@@ -1,28 +1,32 @@
 import { ConditionValueAbstract } from '~/src/conditions/condition-value-abstract.js'
-import { Registration } from '~/src/conditions/condition-value-registration.js'
 import {
   type DateTimeUnitValues,
   type DateUnits,
   type TimeUnits
 } from '~/src/conditions/types.js'
 
-export class ConditionValue extends ConditionValueAbstract {
+export class ConditionValue
+  extends ConditionValueAbstract
+  implements ConditionValueFrom
+{
+  type: 'Value'
   value: string
   display: string
 
   constructor(value: string, display?: string) {
-    super(valueType)
-
     if (!value || typeof value !== 'string') {
-      throw Error(`value ${value} is not valid`)
+      throw new Error("ConditionValue param 'value' must be a string")
     }
 
     if (display && typeof display !== 'string') {
-      throw Error(`display ${display} is not valid`)
+      throw new Error("ConditionValue param 'display' must be a string")
     }
 
+    super()
+
+    this.type = 'Value'
     this.value = value
-    this.display = display || value
+    this.display = display ?? value
   }
 
   toPresentationString() {
@@ -33,7 +37,7 @@ export class ConditionValue extends ConditionValueAbstract {
     return this.value
   }
 
-  static from(obj: { value: string; display?: string }) {
+  static from(obj: ConditionValue | ConditionValueFrom) {
     return new ConditionValue(obj.value, obj.display)
   }
 
@@ -42,9 +46,10 @@ export class ConditionValue extends ConditionValueAbstract {
   }
 }
 
-const valueType = Registration.register('Value', (obj) =>
-  ConditionValue.from(obj)
-)
+export interface ConditionValueFrom {
+  value: string
+  display?: string
+}
 
 export enum DateDirections {
   FUTURE = 'in the future',
@@ -69,7 +74,11 @@ export const dateTimeUnits: DateUnits & TimeUnits = Object.assign(
   timeUnits
 )
 
-export class RelativeTimeValue extends ConditionValueAbstract {
+export class RelativeTimeValue
+  extends ConditionValueAbstract
+  implements RelativeTimeValueFrom
+{
+  type: 'RelativeTime'
   timePeriod: string
   timeUnit: DateTimeUnitValues
   direction: DateDirections
@@ -81,10 +90,8 @@ export class RelativeTimeValue extends ConditionValueAbstract {
     direction: DateDirections,
     timeOnly = false
   ) {
-    super(relativeTimeValueType)
-
     if (typeof timePeriod !== 'string') {
-      throw Error(`time period ${timePeriod} is not valid`)
+      throw new Error("RelativeTimeValue param 'timePeriod' must be a string")
     }
 
     if (
@@ -92,13 +99,20 @@ export class RelativeTimeValue extends ConditionValueAbstract {
         .map((unit) => unit.value)
         .includes(timeUnit)
     ) {
-      throw Error(`time unit ${timeUnit} is not valid`)
+      throw new Error(
+        "RelativeTimeValue param 'dateTimeUnits' must only include DateTimeUnitValues keys"
+      )
     }
 
     if (!Object.values(DateDirections).includes(direction)) {
-      throw Error(`direction ${direction} is not valid`)
+      throw new Error(
+        "RelativeTimeValue param 'direction' must be from enum DateDirections"
+      )
     }
 
+    super()
+
+    this.type = 'RelativeTime'
     this.timePeriod = timePeriod
     this.timeUnit = timeUnit
     this.direction = direction
@@ -119,7 +133,7 @@ export class RelativeTimeValue extends ConditionValueAbstract {
       : `dateForComparison(${timePeriod}, '${this.timeUnit}')`
   }
 
-  static from(obj) {
+  static from(obj: RelativeTimeValue | RelativeTimeValueFrom) {
     return new RelativeTimeValue(
       obj.timePeriod,
       obj.timeUnit,
@@ -133,18 +147,25 @@ export class RelativeTimeValue extends ConditionValueAbstract {
   }
 }
 
-export const relativeTimeValueType = Registration.register(
-  'RelativeTime',
-  (obj): RelativeTimeValue => RelativeTimeValue.from(obj)
-)
-
-type ConditionValueFrom =
-  | Pick<ConditionValue, 'type' | 'value' | 'display'>
-  | Pick<
-      RelativeTimeValue,
-      'type' | 'timePeriod' | 'timeUnit' | 'direction' | 'timeOnly'
-    >
+export interface RelativeTimeValueFrom {
+  timePeriod: string
+  timeUnit: DateTimeUnitValues
+  direction: DateDirections
+  timeOnly: boolean
+}
 
-export function conditionValueFrom(obj: ConditionValueFrom) {
-  return Registration.conditionValueFrom(obj)
+export function conditionValueFrom(
+  obj:
+    | ConditionValue
+    | RelativeTimeValue
+    | ({ type: 'Value' } & ConditionValueFrom)
+    | ({ type: 'RelativeTime' } & RelativeTimeValueFrom)
+) {
+  switch (obj.type) {
+    case 'Value':
+      return ConditionValue.from(obj)
+
+    case 'RelativeTime':
+      return RelativeTimeValue.from(obj)
+  }
 }

package/src/conditions/condition.ts

@@ -14,23 +14,25 @@ export class Condition extends ConditionAbstract {
   value: ConditionValue | RelativeTimeValue
 
   constructor(
-    field: ConditionField,
-    operator: string,
-    value: ConditionValue | RelativeTimeValue,
+    field?: ConditionField,
+    operator?: string,
+    value?: ConditionValue | RelativeTimeValue,
     coordinator?: Coordinator
   ) {
-    super(coordinator)
-
     if (!(field instanceof ConditionField)) {
-      throw Error(`field ${field} is not a valid ConditionField object`)
+      throw new Error("Condition param 'field' must be ConditionField instance")
     }
     if (typeof operator !== 'string') {
-      throw Error(`operator ${operator} is not a valid operator`)
+      throw new Error("Condition param 'operator' must be a string")
     }
     if (!(value instanceof ConditionValueAbstract)) {
-      throw Error(`value ${value} is not a valid value type`)
+      throw new Error(
+        "Condition param 'field' must be ConditionValueAbstract instance"
+      )
     }
 
+    super(coordinator)
+
     this.field = field
     this.operator = operator
     this.value = value

package/src/conditions/enums.ts

@@ -1,3 +1,8 @@
+export enum ConditionType {
+  Value = 'Value',
+  RelativeTime = 'RelativeTime'
+}
+
 export enum Coordinator {
   AND = 'and',
   OR = 'or'

package/src/conditions/index.ts

@@ -24,4 +24,4 @@ export { ConditionsModel } from '~/src/conditions/condition-model.js'
 export { ConditionGroupDef } from '~/src/conditions/condition-group-def.js'
 export { toExpression, toPresentationString } from '~/src/conditions/helpers.js'
 
-export { Coordinator } from '~/src/conditions/enums.js'
+export { ConditionType, Coordinator } from '~/src/conditions/enums.js'