@defra/forms-model 3.0.685 → 3.0.687

package/src/conditions/migration.ts

@@ -1,12 +1,15 @@
 import { ComponentType } from '~/src/components/enums.js'
+import { isConditionalType } from '~/src/components/helpers.js'
+import { type ComponentDef } from '~/src/components/types.js'
 import {
-  type ComponentDef,
-  type ConditionalComponentType
-} from '~/src/components/types.js'
-import { ConditionType, type Coordinator } from '~/src/conditions/enums.js'
+  ConditionType,
+  Coordinator,
+  OperatorName
+} from '~/src/conditions/enums.js'
 import {
   type ConditionData,
   type ConditionDataV2,
+  type ConditionGroupData,
   type ConditionListItemRefValueDataV2,
   type ConditionRefData,
   type ConditionRefDataV2,
@@ -14,6 +17,7 @@ import {
   type RelativeDateValueData,
   type RelativeDateValueDataV2
 } from '~/src/conditions/types.js'
+import { getConditionListItemIds } from '~/src/form/form-definition/helpers.js'
 import {
   type ConditionWrapper,
   type ConditionWrapperV2,
@@ -57,29 +61,97 @@ function getListItem(model: RuntimeFormModel, listId: string, itemId: string) {
   const foundList = model.getListById(listId)
 
   if (!foundList) {
-    throw Error(`List ${listId} not found`)
+    throw new Error(`List ${listId} not found`)
   }
 
   const item = foundList.items.find((item) => item.id === itemId)
 
   if (!item) {
-    throw Error(`List item ${itemId} not found`)
+    throw new Error(`List item ${itemId} not found`)
   }
 
   return item
 }
 
-function createConditionValueDataFromListItemRefV2(
+function createConditionValueDataListFromListItemRefV2(
   condition: ConditionDataV2,
   model: RuntimeFormModel
-): ConditionValueData {
+): ConditionValueData[] {
   const value = condition.value as ConditionListItemRefValueDataV2
-  const refValue = getListItem(model, value.listId, value.itemId)
+  const itemIds = getConditionListItemIds(value)
+
+  return itemIds.map((itemId) => {
+    const refValue = getListItem(model, value.listId, itemId)
+
+    return {
+      display: refValue.text,
+      type: ConditionType.Value,
+      value: refValue.value.toString()
+    }
+  })
+}
+
+/**
+ * Determine how multiple selected list items are combined within a single
+ * V2 condition once expanded into individual V1 conditions.
+ * - Checkbox questions use the author-chosen coordinator (default OR).
+ * - Single-answer questions (radio/autocomplete/select) combine with OR for a
+ *   positive match and AND for a negative ("is not any of these") match.
+ */
+function getListItemsInnerCoordinator(
+  componentType: ComponentDef['type'],
+  operator: OperatorName,
+  itemsCoordinator: Coordinator | undefined
+): Coordinator {
+  if (componentType === ComponentType.CheckboxesField) {
+    return itemsCoordinator ?? Coordinator.OR
+  }
+
+  return operator === OperatorName.IsNot ? Coordinator.AND : Coordinator.OR
+}
+
+/**
+ * Convert a V2 list item ref condition to V1. A single selected item produces
+ * a single condition (unchanged from legacy behaviour); multiple selected
+ * items produce a nested condition group so they are correctly parenthesised
+ * relative to sibling conditions.
+ */
+function convertListItemRefConditionV2(
+  model: RuntimeFormModel,
+  condition: ConditionDataV2,
+  component: ComponentDef,
+  field: ConditionData['field'],
+  coordinator: Coordinator | undefined
+): ConditionData | ConditionGroupData {
+  const value = condition.value as ConditionListItemRefValueDataV2
+  const values = createConditionValueDataListFromListItemRefV2(condition, model)
+
+  if (!values.length) {
+    throw new Error('List item ref condition has no selected items')
+  }
+
+  if (values.length === 1) {
+    return {
+      field,
+      operator: condition.operator,
+      value: values[0],
+      coordinator
+    }
+  }
+
+  const innerCoordinator = getListItemsInnerCoordinator(
+    component.type,
+    condition.operator,
+    value.itemsCoordinator
+  )
 
   return {
-    display: refValue.text,
-    type: ConditionType.Value,
-    value: refValue.value.toString()
+    conditions: values.map((itemValue, index) => ({
+      field,
+      operator: condition.operator,
+      value: itemValue,
+      coordinator: index === 0 ? coordinator : innerCoordinator
+    }))
   }
 }
 
@@ -157,17 +229,35 @@ function convertConditionDataV2(
   model: RuntimeFormModel,
   condition: ConditionDataV2,
   coordinator: Coordinator | undefined
-): ConditionData {
+): ConditionData | ConditionGroupData {
   const component = model.getComponentById(condition.componentId)
 
   if (!component) {
-    throw Error('Component not found')
+    throw new Error('Component not found')
+  }
+
+  if (!isConditionalType(component.type)) {
+    throw new Error(`Component ${component.name} does not support conditions`)
+  }
+
+  const field = {
+    name: component.name,
+    type: component.type,
+    display: component.title
   }
 
-  let newValue
   if (isConditionListItemRefValueDataV2(condition)) {
-    newValue = createConditionValueDataFromListItemRefV2(condition, model)
-  } else if (isConditionStringValueDataV2(condition)) {
+    return convertListItemRefConditionV2(
+      model,
+      condition,
+      component,
+      field,
+      coordinator
+    )
+  }
+
+  let newValue
+  if (isConditionStringValueDataV2(condition)) {
     newValue = createConditionValueDataFromStringValueDataV2(condition)
   } else if (isConditionBooleanValueDataV2(condition)) {
     newValue =
@@ -181,15 +271,11 @@ function convertConditionDataV2(
   } else if (isConditionRelativeDateValueDataV2(condition)) {
     newValue = createConditionValueDataFromRelativeDateValueDataV2(condition)
   } else {
-    throw Error('Unsupported condition type')
+    throw new Error('Unsupported condition type')
   }
 
   return {
-    field: {
-      name: component.name,
-      type: component.type as ConditionalComponentType /** @todo fix this */,
-      display: component.title
-    },
+    field,
     operator: condition.operator,
     value: newValue,
     coordinator
@@ -204,7 +290,7 @@ function convertConditionRefDataFromV2(
   const refCondition = model.getConditionById(condition.conditionId)
 
   if (!refCondition) {
-    throw Error('Component not found')
+    throw new Error('Component not found')
   }
 
   return {
@@ -244,7 +330,7 @@ export function convertConditionWrapperFromV2(
     value: {
       name: conditionWrapper.id,
       conditions: conditionWrapper.items.map((condition, index) => {
-        let newCondition: ConditionData | ConditionRefData
+        let newCondition: ConditionData | ConditionRefData | ConditionGroupData
 
         if (isConditionDataV2(condition)) {
           newCondition = convertConditionDataV2(

package/src/conditions/types.ts

@@ -26,7 +26,19 @@ export interface RelativeDateValueData {
 
 export interface ConditionListItemRefValueDataV2 {
   listId: string
-  itemId: string
+  /**
+   * One or more referenced list item ids (radio, checkbox, autocomplete,
+   * select). New conditions are always written as an array, even for a single
+   * selection. A bare `string` is only retained for backwards compatibility so
+   * conditions saved before multi-select support continue to load, display and
+   * evaluate.
+   */
+  itemId: string[] | string
+  /**
+   * How multiple checkbox selections are combined (AND/OR). Only set for
+   * checkbox questions; radio/autocomplete/select combine implicitly.
+   */
+  itemsCoordinator?: Coordinator
 }
 
 export interface RelativeDateValueDataV2 {

package/src/form/form-definition/helpers.ts

@@ -44,6 +44,23 @@ export function isConditionListItemRefValueData(
   )
 }
 
+/**
+ * Normalises a list item ref condition value to an array of item ids. `itemId`
+ * is normally an array, but may be a bare string for legacy conditions saved
+ * before multi-select support.
+ * @param { ConditionListItemRefValueDataV2 | undefined } value
+ * @returns { string[] }
+ */
+export function getConditionListItemIds(
+  value: ConditionListItemRefValueDataV2 | undefined
+): string[] {
+  if (!value?.itemId) {
+    return []
+  }
+
+  return Array.isArray(value.itemId) ? value.itemId : [value.itemId]
+}
+
 /**
  * Returns an array of all hidden fields in a form
  * @param definition - form definition

package/src/form/form-definition/index.ts

@@ -15,7 +15,11 @@ import {
   type ContentComponentsDef,
   type FileUploadFieldComponent
 } from '~/src/components/types.js'
-import { ConditionType, OperatorName } from '~/src/conditions/enums.js'
+import {
+  ConditionType,
+  Coordinator,
+  OperatorName
+} from '~/src/conditions/enums.js'
 import {
   type ConditionData,
   type ConditionDataV2,
@@ -112,7 +116,12 @@ export const listItemIdValidator = (
     return value
   }
 
-  const conditionValue = helpers.state.ancestors[0]
+  // `itemId` is normally an array, so the condition value is one level up from
+  // each entry being validated. For a legacy bare-string `itemId` it is the
+  // nearest ancestor instead, so locate it by shape rather than fixed position.
+  const conditionValue = helpers.state.ancestors.find(
+    isConditionListItemRefValueData
+  )
 
   if (!isConditionListItemRefValueData(conditionValue)) {
     return value
@@ -254,11 +263,17 @@ const conditionListItemRefDataSchemaV2 =
         })
         .description('The id of the list')
         .error(checkErrors(FormDefinitionError.RefConditionListId)),
-      itemId: Joi.string()
-        .trim()
+      itemId: Joi.array()
+        .single()
+        .items(Joi.string().trim().custom(listItemIdValidator))
+        .min(1)
         .required()
-        .description('The id of the list item')
-        .custom(listItemIdValidator)
+        .description('The ids of the selected list items.'),
+      itemsCoordinator: Joi.string()
+        .trim()
+        .valid(...Object.values(Coordinator))
+        .optional()
+        .description('How multiple checkbox selections are combined (and/or)')
     })
 
 const relativeDateValueDataSchemaV2 = Joi.object<RelativeDateValueDataV2>()
@@ -665,6 +680,25 @@ export const componentSchema = Joi.object<ComponentDef>()
             'Geometry types for geospatial data - for GeospatialField only'
           )
       }).description('Geometry types - for GeospatialField only'),
+      mapLayers: Joi.when('type', {
+        is: Joi.string()
+          .trim()
+          .valid(
+            ComponentType.GeospatialField,
+            ComponentType.EastingNorthingField,
+            ComponentType.LatLongField,
+            ComponentType.OsGridRefField
+          )
+          .required(),
+        then: Joi.object()
+          .keys({
+            sssi: Joi.boolean()
+              .optional()
+              .description('Sites of Special Scientific Interest layer')
+          })
+          .optional()
+          .description('Supported map layers')
+      }).description('Map layers'),
       format: Joi.when('type', {
         is: Joi.string()
           .trim()

package/src/form/form-editor/index.ts

@@ -471,6 +471,11 @@ export const countriesSchema = Joi.array()
   .single()
   .description('The country to be included in a geospatial field')
 
+export const mapLayersSchema = Joi.array()
+  .items(Joi.string().valid('sssi'))
+  .single()
+  .description('The map layers to be displayed')
+
 export const exactFeaturesSchema = Joi.number()
   .empty('')
   .integer()
@@ -693,6 +698,7 @@ export const questionDetailsFullSchema = {
   maxChecksSchema,
   exactChecksSchema,
   countriesSchema,
+  mapLayersSchema,
   minFeaturesSchema,
   maxFeaturesSchema,
   exactFeaturesSchema,

package/src/form/form-editor/types.ts

@@ -423,6 +423,11 @@ export interface FormEditor {
    */
   geometryTypes?: GeospatialFieldGeometryTypesEnum[]
 
+  /**
+   * The layers to include for map-based geospatial questions
+   */
+  mapLayers?: string[]
+
   /**
    * The format restriction for telephone number questions
    */
@@ -519,6 +524,7 @@ export type FormEditorInputQuestion = Pick<
   | 'minFeatures'
   | 'maxFeatures'
   | 'telephoneNumberFormat'
+  | 'mapLayers'
 >
 
 export type FormEditorInputPageSettings = Pick<