@defra/forms-engine-plugin 5.0.0-alpha.2 → 5.0.0-alpha.21

package/src/server/plugins/engine/pageControllers/FileUploadPageController.ts

@@ -42,6 +42,7 @@ import {
   type FormRequestPayload,
   type FormResponseToolkit
 } from '../../../routes/types.js'
+import { joinWithOr } from '../../../utils/utils.js'
 
 const MAX_UPLOADS = 25
 const CDP_UPLOAD_TIMEOUT_MS = 60000 // 1 minute
@@ -188,17 +189,19 @@ export class FileUploadPageController extends QuestionPageController {
 
       const { filename } = fileToRemove.status.form.file
 
-      const { t } = this.getTranslator(request)
+      const translator = this.getTranslator(request)
+      const { t } = translator
 
       return h.view(this.fileDeleteViewName, {
         ...viewModel,
         context,
         backLink: this.getBackLink(request, context, t),
-        pageTitle: `Are you sure you want to remove this file?`,
+        pageTitle: t('pages.fileUpload.removeFileTitle'),
         itemTitle: filename,
-        confirmation: { text: 'You cannot recover removed files.' },
-        buttonConfirm: { text: 'Remove file' },
-        buttonCancel: { text: 'Cancel' }
+        confirmation: { text: t('pages.fileUpload.removeFileBody') },
+        buttonConfirm: { text: t('pages.fileUpload.removeFileButton') },
+        buttonCancel: { text: t('pages.fileUpload.cancel') },
+        t
       } satisfies ItemDeletePageViewModel)
     }
   }
@@ -224,7 +227,7 @@ export class FileUploadPageController extends QuestionPageController {
     }
   }
 
-  getErrors(details?: ValidationErrorItem[]) {
+  getErrors(details?: ValidationErrorItem[], language?: string) {
     const { fileUpload } = this
 
     if (details) {
@@ -237,7 +240,7 @@ export class FileUploadPageController extends QuestionPageController {
         if (!isUploadError || isUploadRootError) {
           // The error is for the root of the upload or another
           // field on the page so defer to the getError helper
-          errors.push(getError(error))
+          errors.push(getError(language, error))
         } else {
           const { context, path, type } = error
 
@@ -266,6 +269,7 @@ export class FileUploadPageController extends QuestionPageController {
   ): FeaturedFormPageViewModel {
     const { fileUpload } = this
     const { state } = context
+    const { t } = translator
 
     const upload = this.getUploadFromState(state)
 
@@ -277,6 +281,19 @@ export class FileUploadPageController extends QuestionPageController {
       ({ model }) => model.id === fileUpload.name
     )
 
+    formComponent.model.upload = {
+      count: formComponent.model.upload?.count ?? 0,
+      summaryList: formComponent.model.upload?.summaryList ?? { rows: [] },
+      uploadingLabel: t('components.fileUploadField.uploading')
+    }
+    formComponent.model = {
+      ...formComponent.model,
+      javascript: true,
+      chooseFilesButtonText: t('components.fileUploadField.chooseFile'),
+      dropInstructionText: t('components.fileUploadField.dropFile'),
+      noFileChosenText: t('components.fileUploadField.noFileChosen')
+    }
+
     const index = components.indexOf(formComponent)
 
     const proxyUrl = getProxyUrlForLocalDevelopment(upload?.uploadUrl)
@@ -290,7 +307,8 @@ export class FileUploadPageController extends QuestionPageController {
       // Split out components before/after
       componentsBefore: components.slice(0, index),
       components: components.slice(index),
-      proxyUrl
+      proxyUrl,
+      t
     }
   }
 
@@ -441,6 +459,9 @@ export class FileUploadPageController extends QuestionPageController {
 
     const allErrors: FormSubmissionError[] = []
 
+    const translator = this.getTranslator(request)
+    const { t } = translator
+
     for (const file of uploadedFiles) {
       if (file.fileStatus === FileStatus.complete) {
         const perFileState: FileState = {
@@ -455,7 +476,14 @@ export class FileUploadPageController extends QuestionPageController {
         // Collect the error for rejected/pending files.
         const { fileUpload } = this
         const name = fileUpload.name
-        const text = file.errorMessage ?? 'Unknown error'
+        const errorParams = this.expandErrorParams(
+          file.errorParams,
+          t('common.or')
+        )
+        const text = t(
+          `pages.fileUpload.${file.errorCode ?? 'FILE_ERROR_UNKNOWN'}`,
+          errorParams
+        )
         allErrors.push({ path: [name], href: `#${name}`, name, text })
       }
     }
@@ -472,6 +500,29 @@ export class FileUploadPageController extends QuestionPageController {
     }
   }
 
+  /**
+   * Process the error parameters so any arrays get expanded (joined), ready to be passed into the error message
+   * @param errorParams - received from the file upload (may be a number, a string, or a string array)
+   * @param finalSeparator - 'or' in English, and 'neu' in Welsh
+   */
+  private expandErrorParams(
+    errorParams: Record<string, number | string | string[]> | undefined,
+    finalSeparator: string
+  ) {
+    if (!errorParams) {
+      return {}
+    }
+    const expanded = {} as Record<string, number | string>
+    for (const [key, value] of Object.entries(errorParams)) {
+      if (Array.isArray(value)) {
+        expanded[key] = joinWithOr(value, finalSeparator)
+      } else {
+        expanded[key] = value
+      }
+    }
+    return expanded
+  }
+
   /**
    * Checks the payload for a file getting removed
    * and removes it from the upload files if found

package/src/server/plugins/engine/pageControllers/QuestionPageController.ts

@@ -174,9 +174,14 @@ export class QuestionPageController extends PageController {
           if (!pageTitle) {
             pageTitle = labelOrLegend.text
           }
-          labelOrLegend.text = isOptional
-            ? `${pageTitle} ${t('common.optional')}`
-            : pageTitle
+
+          // The question text may have already appended 'optional' in the relevant language
+          const optionalWord = t('common.optional')
+          const optionalAlreadyAppended = pageTitle.endsWith(` ${optionalWord}`)
+          labelOrLegend.text =
+            isOptional && !optionalAlreadyAppended
+              ? `${pageTitle} ${optionalWord}`
+              : pageTitle
         }
 
         // Fallback if still no pageTitle set
@@ -359,8 +364,8 @@ export class QuestionPageController extends PageController {
     return this.collection.getStateFromValidForm(payload)
   }
 
-  getErrors(details?: ValidationErrorItem[]) {
-    return getErrors(details)
+  getErrors(details?: ValidationErrorItem[], language?: string) {
+    return getErrors(language, details)
   }
 
   async getState(request: AnyFormRequest) {

package/src/server/plugins/engine/pageControllers/RepeatPageController.ts

@@ -406,9 +406,9 @@ export class RepeatPageController extends QuestionPageController {
     const { query } = request
     const { isForceAccess, errors } = context
 
-    const { t } = translator
+    const { t, tPage } = translator
 
-    const { title } = repeat.options
+    const title = tPage(this.pageDef, 'repeatTitle') || repeat.options.title
 
     const summaryList: SummaryList = {
       classes: 'govuk-summary-list--long-actions',

package/src/server/plugins/engine/pageControllers/SummaryPageController.ts

@@ -114,7 +114,7 @@ export class SummaryPageController extends QuestionPageController {
         viewModel.paymentDetails = this.buildPaymentDetails(
           paymentField,
           paymentState,
-          t
+          translator
         )
       }
 
@@ -151,8 +151,9 @@ export class SummaryPageController extends QuestionPageController {
     paymentState: NonNullable<
       ReturnType<PaymentField['getPaymentStateFromState']>
     >,
-    t: (key: string, opts?: Record<string, unknown>) => string
+    translator: Translator
   ) {
+    const { t } = translator
     const rows = [
       {
         key: { text: t('pages.summary.paymentFor') },
@@ -171,7 +172,12 @@ export class SummaryPageController extends QuestionPageController {
     if (paymentState.preAuth?.createdAt) {
       rows.push({
         key: { text: t('pages.summary.dateOfPayment') },
-        value: { text: formatPaymentDate(paymentState.preAuth.createdAt) }
+        value: {
+          text: formatPaymentDate(
+            paymentState.preAuth.createdAt,
+            translator.language
+          )
+        }
       })
     }
 
@@ -557,7 +563,12 @@ function submitData(
     retrievalKey,
     referenceNumber,
     main: buildMainRecords(items, translator),
-    repeaters: buildRepeaterRecords(items, translator)
+    repeaters: buildRepeaterRecords(items, translator),
+    // Only populate the language property if the form is multi-language enabled
+    // @ts-expect-error - dynamic language property
+    language: model.def.metadata?.translations?.cy
+      ? translator.language
+      : undefined
   }
   return submit(payload)
 }

package/src/server/plugins/engine/pageControllers/helpers/pages.ts

@@ -4,6 +4,7 @@ import {
   type Page
 } from '@defra/forms-model'
 
+import { UnknownPageControllerError } from '../../errors.js'
 import { type FormModel } from '../../models/index.js'
 import * as PageControllers from '../index.js'
 
@@ -66,7 +67,7 @@ export function createPage(model: FormModel, pageDef: Page) {
   }
 
   if (typeof controller === 'undefined') {
-    throw new Error(`Page controller ${pageDef.controller} does not exist`)
+    throw new UnknownPageControllerError(pageDef.controller)
   }
 
   return controller

package/src/server/plugins/engine/pageControllers/helpers/submission.ts

@@ -1,13 +1,27 @@
-import { type SubmitPayload } from '@defra/forms-model'
+import {
+  isConditionWrapperV2,
+  type ConditionDataV2,
+  type ConditionRefDataV2,
+  type ConditionWrapperV2,
+  type SubmitConditionEvaluation,
+  type SubmitConditionReference,
+  type SubmitPayload
+} from '@defra/forms-model'
 
 import { GeospatialField } from '../../components/GeospatialField.js'
 import { PaymentField } from '../../components/PaymentField.js'
 import { getAnswer } from '../../components/helpers/components.js'
 import { type Translator } from '../../i18n/types.js'
+import { type FormModel } from '../../models/FormModel.js'
 import {
   type DetailItem,
   type DetailItemField
 } from '../../models/types.js'
+import {
+  type FormContext,
+  type FormState,
+  type FormStateValue
+} from '../../types.js'
 import {
   formatCurrency,
   formatPaymentDate
@@ -36,7 +50,7 @@ export function buildMainRecords(
 
   for (const item of fieldItems) {
     if (item.field instanceof PaymentField) {
-      records.push(...buildPaymentRecords(item))
+      records.push(...buildPaymentRecords(item, translator))
     } else if (item.field instanceof GeospatialField) {
       // Stringify of GeoJSON is done here rather than inside `getContextValueFromState`
       // so we don't incur the overhead of JSON.stringify on every request when building context
@@ -67,7 +81,10 @@ export function buildMainRecords(
  *
  * Returns an empty array if no payment state exists.
  */
-export function buildPaymentRecords(item: DetailItemField): SubmitRecord[] {
+export function buildPaymentRecords(
+  item: DetailItemField,
+  translator: Translator
+): SubmitRecord[] {
   const paymentState = (item.field as PaymentField).getPaymentStateFromState(
     item.state
   )
@@ -96,7 +113,7 @@ export function buildPaymentRecords(item: DetailItemField): SubmitRecord[] {
       name: `${item.name}_paymentDate`,
       title: 'Payment date',
       value: paymentState.preAuth?.createdAt
-        ? formatPaymentDate(paymentState.preAuth.createdAt)
+        ? formatPaymentDate(paymentState.preAuth.createdAt, translator.language)
         : ''
     }
   ]
@@ -138,3 +155,125 @@ export function buildRepeaterRecords(
       )
     }))
 }
+
+/**
+ * Records the outcome of every condition in the form definition, evaluated
+ * against the answers as they stand at the point of submission.
+ *
+ * Evaluated here rather than by the consumer because only the engine holds
+ * the context to evaluate against: `evaluationState` is built by walking the
+ * form from its start page along the path taken, applying page conditions as
+ * it goes. A consumer receives the flat submitted answers, not that walked
+ * state, and reproducing the walk in a second codebase would leave two
+ * implementations of the same logic free to diverge.
+ *
+ * Each record carries the components the condition depends on and whether each
+ * was answered. An unanswered question still yields a boolean - negative
+ * operators such as "is not" return `true` against the seeded `null` - so the
+ * outcome alone cannot be read as evidence that the user gave that answer.
+ *
+ * V2 definitions only. `conditionId` is the V2 condition id, and the
+ * references are resolved from the component ids V2 conditions carry - V1
+ * conditions reference components by name, and V1 components need not have
+ * an id at all.
+ */
+export function buildConditionEvaluations(
+  model: FormModel,
+  context: FormContext
+): SubmitConditionEvaluation[] {
+  const { evaluationState } = context
+
+  return model.def.conditions
+    .filter(isConditionWrapperV2)
+    .flatMap((conditionDef) => {
+      const condition = model.conditions[conditionDef.id]
+
+      if (!condition) {
+        return []
+      }
+
+      const { outcome } = condition.evaluate(evaluationState)
+
+      const references = collectReferences(model, conditionDef, evaluationState)
+
+      return {
+        conditionId: conditionDef.id,
+        outcome,
+        references: [...references.values()]
+      }
+    })
+}
+
+/**
+ * Whether a component held an answer at the point a condition was evaluated.
+ *
+ * The engine seeds every component in `evaluationState` with `null` before the
+ * page walk begins, so an unanswered question is present but empty rather than
+ * absent.
+ * @see {@link FormModel.initialiseContext}
+ */
+export function isAnswered(value: FormStateValue | undefined) {
+  if (value === undefined || value === null) {
+    return false
+  }
+
+  if (Array.isArray(value)) {
+    return value.length > 0
+  }
+
+  return value !== ''
+}
+
+function isConditionDataV2(
+  item: ConditionDataV2 | ConditionRefDataV2
+): item is ConditionDataV2 {
+  return 'componentId' in item
+}
+
+/**
+ * Recursive function that collects every component a condition depends on, following nested condition
+ * references. Results are keyed by component id so a component referenced more
+ * than once is reported once.
+ */
+function collectReferences(
+  model: FormModel,
+  conditionDef: ConditionWrapperV2,
+  evaluationState: FormState,
+  references: Map<string, SubmitConditionReference> = new Map<
+    string,
+    SubmitConditionReference
+  >(),
+  visited: Set<string> = new Set<string>()
+) {
+  if (visited.has(conditionDef.id)) {
+    return references
+  }
+
+  visited.add(conditionDef.id)
+
+  for (const item of conditionDef.items) {
+    if (isConditionDataV2(item)) {
+      const component = model.getComponentById(item.componentId)
+
+      // A condition referencing a component that no longer exists cannot be
+      // resolved to a name, so there is nothing meaningful to report for it
+      if (component) {
+        references.set(item.componentId, {
+          componentId: item.componentId,
+          componentName: component.name,
+          answered: isAnswered(evaluationState[component.name])
+        })
+      }
+
+      continue
+    }
+
+    const referenced = model.getConditionById(item.conditionId)
+
+    if (referenced) {
+      collectReferences(model, referenced, evaluationState, references, visited)
+    }
+  }
+
+  return references
+}

package/src/server/plugins/engine/pageControllers/validationOptions.ts

@@ -26,7 +26,7 @@ export const opts = {
  * import messageTemplate directly and get the English version.
  */
 export const messageTemplate: ValidationMessages = buildValidationMessages(
-  (key) => t(key, 'en-GB')
+  (key, options) => t(key, 'en-GB', options)
 )
 
 export const messages: LanguageMessagesExt = {
@@ -58,14 +58,28 @@ export const messages: LanguageMessagesExt = {
   'date.min': messageTemplate.dateMin,
   'date.max': messageTemplate.dateMax,
 
-  'object.invalidjson': messageTemplate.format
+  'array.min': messageTemplate.arrayMin,
+  'array.max': messageTemplate.arrayMax,
+  'array.length': messageTemplate.arrayLength,
+
+  'features.min': messageTemplate.featuresMin,
+  'features.max': messageTemplate.featuresMax,
+  'features.length': messageTemplate.featuresLength,
+
+  'files.min': messageTemplate.filesMin,
+  'files.max': messageTemplate.filesMax,
+  'filees.length': messageTemplate.filesLength,
+
+  'object.invalidjson': messageTemplate.format,
+
+  'phoneNumber.invalid': messageTemplate.format
 }
 
 export const messagesPre: LanguageMessages =
   messages as unknown as LanguageMessages
 
 export function buildLanguageMessages(
-  t: (key: string) => string
+  t: (key: string, options?: Record<string, unknown>) => string
 ): LanguageMessages {
   const vm = buildValidationMessages(t)
   return {
@@ -76,6 +90,7 @@ export function buildLanguageMessages(
     'string.email': vm.format,
     'string.pattern.base': vm.pattern,
     'string.maxWords': vm.maxWords,
+    'string.unicode': vm.unicode,
     'number.base': vm.number,
     'number.precision': vm.numberPrecision,
     'number.integer': vm.numberInteger,
@@ -91,7 +106,17 @@ export function buildLanguageMessages(
     'date.format': vm.dateFormat,
     'date.min': vm.dateMin,
     'date.max': vm.dateMax,
-    'object.invalidjson': vm.format
+    'array.min': vm.arrayMin,
+    'array.max': vm.arrayMax,
+    'array.length': vm.arrayLength,
+    'features.min': vm.featuresMin,
+    'features.max': vm.featuresMax,
+    'features.length': vm.featuresLength,
+    'files.min': vm.filesMin,
+    'files.max': vm.filesMax,
+    'files.length': vm.filesLength,
+    'object.invalidjson': vm.format,
+    'phoneNumber.invalid': vm.format
   } as unknown as LanguageMessages
 }
 

package/src/server/plugins/engine/types/enums.ts

@@ -10,6 +10,7 @@ export enum FileStatus {
   pending = 'pending'
 }
 
-export enum FormAdapterSubmissionSchemaVersion {
-  V1 = 1
-}
+// Changed from an enum to enforce numeric values
+export const FormAdapterSubmissionSchemaVersion = {
+  V1: 1
+} as const satisfies Record<string, number>

package/src/server/plugins/engine/types/schema.ts

@@ -1,5 +1,6 @@
 import {
   FormStatus,
+  formSubmitConditionEvaluationSchema,
   formVersionMetadataSchema,
   idSchema,
   notificationEmailAddressSchema,
@@ -18,9 +19,9 @@ import {
 
 export const formAdapterSubmissionMessageMetaSchema =
   Joi.object<FormAdapterSubmissionMessageMeta>().keys({
-    schemaVersion: Joi.string().valid(
-      ...Object.values(FormAdapterSubmissionSchemaVersion)
-    ),
+    schemaVersion: Joi.number()
+      .valid(...Object.values(FormAdapterSubmissionSchemaVersion))
+      .required(),
     timestamp: Joi.date().required(),
     referenceNumber: Joi.string().required(),
     formName: titleSchema,
@@ -50,6 +51,7 @@ export const formAdapterSubmissionMessageDataSchema =
         reference: Joi.string().required(),
         amount: Joi.number().required(),
         description: Joi.string().required(),
+        descriptionInEng: Joi.string().optional(),
         createdAt: Joi.string().required()
       })
       .optional(),
@@ -79,5 +81,16 @@ export const formAdapterSubmissionMessagePayloadSchema =
   Joi.object<FormAdapterSubmissionMessagePayload>().keys({
     meta: formAdapterSubmissionMessageMetaSchema.required(),
     data: formAdapterSubmissionMessageDataSchema.required(),
-    result: formAdapterSubmissionMessageResultSchema.required()
+    result: formAdapterSubmissionMessageResultSchema.required(),
+    // Optional so that messages published before this existed - which may
+    // still be in flight or sitting on a dead-letter queue - continue to
+    // validate. Consumers treat its absence as "resolve the recipients from
+    // the form definition yourself"
+    // This should be required at a later point in time.
+    conditionEvaluations: Joi.array()
+      .items(formSubmitConditionEvaluationSchema)
+      .optional()
+      .description(
+        'Outcome of every condition in the form definition, evaluated against the final answers at submission'
+      )
   })

package/src/server/plugins/engine/types.ts

@@ -6,6 +6,7 @@ import {
   type List,
   type Page,
   type PaymentFieldComponent,
+  type SubmitConditionEvaluation,
   type UkAddressFieldComponent
 } from '@defra/forms-model'
 import {
@@ -245,11 +246,15 @@ export type FileUpload = {
 } & (
   | {
       fileStatus: FileStatus.complete | FileStatus.rejected | FileStatus.pending
+      errorCode?: string
       errorMessage?: string
+      errorParams?: Record<string, number | string | string[]>
     }
   | {
       fileStatus: FileStatus.complete
+      errorCode?: string
       errorMessage?: undefined
+      errorParams?: Record<string, number | string | string[]>
     }
 )
 
@@ -525,7 +530,7 @@ export interface PluginOptions {
 }
 
 export interface FormAdapterSubmissionMessageMeta {
-  schemaVersion: FormAdapterSubmissionSchemaVersion
+  schemaVersion: (typeof FormAdapterSubmissionSchemaVersion)[keyof typeof FormAdapterSubmissionSchemaVersion]
   timestamp: Date
   referenceNumber: string
   formName: string
@@ -558,6 +563,7 @@ export interface FormAdapterPayment {
   reference: string
   amount: number
   description: string
+  descriptionInEng?: string
   createdAt: string
 }
 
@@ -602,6 +608,18 @@ export interface FormAdapterSubmissionMessagePayload {
   meta: FormAdapterSubmissionMessageMeta
   data: FormAdapterSubmissionMessageData
   result: FormAdapterSubmissionMessageResult
+
+  /**
+   * The outcome of every condition in the form definition, evaluated against
+   * the final answers at the point of submission.
+   *
+   * Always emitted, empty when there is nothing to report - a V1-engine form
+   * has no stable condition ids to record against. Optional only for
+   * backwards compatibility: a message published before this existed carries
+   * no evaluations at all, and consumers fall back to resolving the recipients
+   * from the form definition themselves.
+   */
+  conditionEvaluations?: SubmitConditionEvaluation[]
 }
 
 export interface FormAdapterSubmissionMessage extends FormAdapterSubmissionMessagePayload {

package/src/server/plugins/engine/unavailable-response.ts

@@ -2,6 +2,8 @@ import { type Request, type ResponseToolkit, type Server } from '@hapi/hapi'
 
 import { isOfflineBoom } from './form-availability.js'
 import { unavailableViewModel } from './models/unavailable-view-model.js'
+import { type AnyFormRequest } from './types.js'
+import { resolveLanguage } from '../../utils/utils.js'
 
 /**
  * Registers a server-wide onPreResponse extension that intercepts the offline
@@ -17,10 +19,12 @@ export function registerUnavailableResponse(server: Server) {
       return h.continue
     }
 
-    const { metadata } = response.data
+    const { metadata, definition } = response.data
+
+    const language = resolveLanguage(request as unknown as AnyFormRequest)
 
     return h
-      .view('unavailable', unavailableViewModel(metadata))
+      .view('unavailable', unavailableViewModel(metadata, definition, language))
       .header('Cache-Control', 'no-store, no-cache, must-revalidate')
       .header('X-Robots-Tag', 'noindex, nofollow')
       .code(200)

package/src/server/plugins/engine/views/components/_location-field-base.html

@@ -61,7 +61,7 @@
   {% set detailsHtml %}
     {% if component.model.instructionText %}
       {{ govukDetails({
-        summaryText: t('components.locationFieldBase.howToFind'),
+        summaryText: component.model.instructionSummary,
         html: component.model.instructionText | markdown | safe,
         classes: "govuk-!-margin-top-3"
       }) }}
@@ -70,8 +70,10 @@
 
   {% set hasErrors = showFieldsetError and component.model.errorMessage %}
 
-  <div class="govuk-form-group app-location-field {{ "govuk-form-group--error" if hasErrors }}"
+  <div id="{{component.model.name}}" class="govuk-form-group app-location-field {{ "govuk-form-group--error" if hasErrors }}"
     data-locationtype="{{component.type | lower}}"
+    data-country="{{component.model.country}}"
+    data-lang="{{component.model.lang}}"
     data-maplayers="{{component.model.mapLayers}}">
     {{ govukFieldset({
       legend: {

package/src/server/plugins/engine/views/components/fileuploadfield.html

@@ -3,7 +3,7 @@
 {% macro FileUploadField(component) %}
   {% set upload = component.model.upload %}
 
-  <div id="uploadedFilesContainer">
+  <div id="uploadedFilesContainer" data-uploadinglabel="{{ upload.uploadingLabel }}">
     <h2 class="govuk-heading-m">{{ t('components.fileUploadField.uploadedFilesHeading') }}</h2>
     {% if upload.count %}
       <p class="govuk-body" role="alert">{{ t('components.fileUploadField.filesCount', { count: upload.count }) }}</p>

package/src/server/plugins/engine/views/components/geospatialfield.html

@@ -2,6 +2,7 @@
 
 {% macro GeospatialField(component) %}
   <div class="app-geospatial-field"
+    data-lang="{{component.model.lang}}"
     data-country="{{component.model.country}}"
     data-geometryTypes="{{component.model.geometryTypes}}"
     data-maplayers="{{component.model.mapLayers}}">