@iapps/ng-dhis2-ui 1.2.129 → 1.2.132

package/fesm2022/iapps-ng-dhis2-ui.mjs

@@ -23,7 +23,7 @@ import { Divider } from '@dhis2-ui/divider';
 import { Layer } from '@dhis2-ui/layer';
 import { CircularLoader } from '@dhis2-ui/loader';
 import { MenuItem, MenuDivider } from '@dhis2-ui/menu';
-import { Button as Button$1, IconDimensionOrgUnit16, IconClock16, IconDimensionData16, spacers as spacers$1, colors as colors$1, IconEdit16, theme as theme$1, Tooltip, IconChevronRight16, SingleSelectField, SingleSelectOption, InputField as InputField$1, TabBar, Tab, Transfer, Modal as Modal$1, ModalTitle as ModalTitle$1, ModalContent as ModalContent$1, ModalActions as ModalActions$1, ButtonStrip as ButtonStrip$1, Checkbox, OrganisationUnitTree, MultiSelect, MultiSelectOption, IconWarningFilled16, CircularLoader as CircularLoader$1, Chip, DataTableToolbar, DropdownButton, FlyoutMenu, CalendarInput, TableHead, DataTableRow, DataTableColumnHeader, Layer as Layer$1, Popper, MenuItem as MenuItem$1, IconMore24, DataTableCell, TableBody as TableBody$1, Pagination as Pagination$1, TableFoot, DataTable, FileInputField, FileListItem, MultiSelectField, TextAreaField } from '@dhis2/ui';
+import { Button as Button$1, IconDimensionOrgUnit16, IconClock16, IconDimensionData16, spacers as spacers$1, colors as colors$1, IconEdit16, theme as theme$1, Tooltip, IconChevronRight16, SingleSelectField, SingleSelectOption, InputField as InputField$1, TabBar, Tab, Transfer, Modal as Modal$1, ModalTitle as ModalTitle$1, ModalContent as ModalContent$1, ModalActions as ModalActions$1, ButtonStrip as ButtonStrip$1, Checkbox, OrganisationUnitTree, MultiSelect, MultiSelectOption, IconWarningFilled16, CircularLoader as CircularLoader$1, Chip, DataTableToolbar, DropdownButton, FlyoutMenu, CalendarInput, TableHead, DataTableRow, DataTableColumnHeader, Layer as Layer$1, Popper, MenuItem as MenuItem$1, IconMore24, DataTableCell, TableBody as TableBody$1, Pagination as Pagination$1, TableFoot, DataTable, FileInputField, FileListItem, Field, Help, MultiSelectField, TextAreaField, NoticeBox } from '@dhis2/ui';
 import { isObject, isString, debounce, isUndefined, find, sortBy, camelCase, flatten, isArray, isEmpty } from 'lodash';
 import cx from 'classnames';
 import { getNowInCalendar, generateFixedPeriods } from '@dhis2/multi-calendar-dates';
@@ -34,6 +34,7 @@ import * as XLSX from 'xlsx';
 import * as i1$1 from '@angular/forms';
 import { FormControl, Validators, UntypedFormControl, UntypedFormGroup, FormGroup, ReactiveFormsModule } from '@angular/forms';
 import { toObservable } from '@angular/core/rxjs-interop';
+import { useMapEvents, useMap, MapContainer, TileLayer, Marker } from 'react-leaflet';
 import moment from 'moment';
 
 class SharedDhis2UiModule {
@@ -6268,6 +6269,273 @@ class FieldConfig {
     }
 }
 
+// Default focus: Zanzibar (Unguja) and nearby coastline
+const DEFAULT_CENTER = [-6.1659, 39.2026];
+const DEFAULT_ZOOM = 8;
+function normalizeCoordinate(lat, lng) {
+    if (Number.isNaN(lat) || Number.isNaN(lng))
+        return null;
+    if (lat < -90 || lat > 90 || lng < -180 || lng > 180)
+        return null;
+    // Treat Null Island as "no coordinate"
+    if (lat === 0 && lng === 0)
+        return null;
+    return { lat, lng };
+}
+/**
+ * Accepts either:
+ *  - "[lon,lat]" (JSON-style array)
+ *  - "lat, lon" (string)
+ */
+function parseCoordinate(value) {
+    if (!value || typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    let lat;
+    let lng;
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        try {
+            const arr = JSON.parse(trimmed);
+            if (!Array.isArray(arr) || arr.length < 2)
+                return null;
+            lng = Number(arr[0]);
+            lat = Number(arr[1]);
+        }
+        catch {
+            return null;
+        }
+    }
+    else {
+        const parts = trimmed.split(',').map((part) => part.trim());
+        if (parts.length !== 2)
+            return null;
+        lat = Number(parts[0]);
+        lng = Number(parts[1]);
+    }
+    return normalizeCoordinate(lat, lng);
+}
+function formatCoordinate(coordinate) {
+    if (!coordinate)
+        return null;
+    return `[${coordinate.lng.toFixed(6)},${coordinate.lat.toFixed(6)}]`;
+}
+const MapClickListener = ({ disabled, onCoordinateSelected, }) => {
+    useMapEvents({
+        click(event) {
+            if (disabled)
+                return;
+            const { lat, lng } = event.latlng;
+            onCoordinateSelected({ lat, lng });
+        },
+    });
+    return null;
+};
+const RecenterOnCoordinate = ({ coordinate }) => {
+    const map = useMap();
+    React__default.useEffect(() => {
+        if (coordinate) {
+            map.flyTo([coordinate.lat, coordinate.lng], map.getZoom(), {
+                duration: 0.4,
+            });
+        }
+    }, [coordinate, map]);
+    return null;
+};
+// DHIS2 / react-leaflet typing workaround
+const CoordinateMapContainer = MapContainer;
+const CoordinatePickerField = ({ label, name, value, required, disabled, error, validationText, onChange, onBlur, }) => {
+    const parsedCoordinate = React__default.useMemo(() => parseCoordinate(value), [value]);
+    const [latitudeInput, setLatitudeInput] = React__default.useState(parsedCoordinate ? String(parsedCoordinate.lat) : '');
+    const [longitudeInput, setLongitudeInput] = React__default.useState(parsedCoordinate ? String(parsedCoordinate.lng) : '');
+    const [validationMessage, setValidationMessage] = React__default.useState(null);
+    const [isMapDialogOpen, setIsMapDialogOpen] = React__default.useState(false);
+    const [pendingCoordinate, setPendingCoordinate] = React__default.useState(parsedCoordinate ?? null);
+    const [mapCenterPosition, setMapCenterPosition] = React__default.useState(parsedCoordinate
+        ? [parsedCoordinate.lat, parsedCoordinate.lng]
+        : DEFAULT_CENTER);
+    React__default.useEffect(() => {
+        const updatedCoordinate = parseCoordinate(value);
+        if (updatedCoordinate) {
+            setLatitudeInput(String(updatedCoordinate.lat));
+            setLongitudeInput(String(updatedCoordinate.lng));
+            setPendingCoordinate(updatedCoordinate);
+            setMapCenterPosition([updatedCoordinate.lat, updatedCoordinate.lng]);
+        }
+        else {
+            setLatitudeInput('');
+            setLongitudeInput('');
+            setPendingCoordinate(null);
+            setMapCenterPosition(DEFAULT_CENTER);
+        }
+    }, [value]);
+    const currentCoordinate = React__default.useMemo(() => {
+        const lat = Number(latitudeInput);
+        const lng = Number(longitudeInput);
+        return normalizeCoordinate(lat, lng);
+    }, [latitudeInput, longitudeInput]);
+    const applyCoordinateChange = React__default.useCallback((coordinate) => {
+        if (!coordinate) {
+            setLatitudeInput('');
+            setLongitudeInput('');
+            setValidationMessage(null);
+            onChange(null);
+            return;
+        }
+        const normalized = normalizeCoordinate(coordinate.lat, coordinate.lng);
+        if (!normalized) {
+            setValidationMessage('Please enter a valid coordinate within the allowed range.');
+            onChange(null);
+            return;
+        }
+        setLatitudeInput(String(normalized.lat));
+        setLongitudeInput(String(normalized.lng));
+        setValidationMessage(null);
+        const formattedValue = formatCoordinate(normalized);
+        onChange(formattedValue);
+    }, [onChange]);
+    const handleLatitudeChange = (event) => {
+        const rawValue = event.value;
+        setLatitudeInput(rawValue);
+        const numericLatitude = Number(rawValue);
+        if (rawValue !== '' &&
+            (Number.isNaN(numericLatitude) ||
+                numericLatitude < -90 ||
+                numericLatitude > 90)) {
+            setValidationMessage('Latitude must be between -90 and 90.');
+            return;
+        }
+        if (rawValue === '' || longitudeInput === '') {
+            applyCoordinateChange(null);
+            return;
+        }
+        const numericLongitude = Number(longitudeInput);
+        if (Number.isNaN(numericLongitude) ||
+            numericLongitude < -180 ||
+            numericLongitude > 180) {
+            setValidationMessage('Longitude must be between -180 and 180.');
+            return;
+        }
+        const updatedCoordinate = {
+            lat: numericLatitude,
+            lng: numericLongitude,
+        };
+        setPendingCoordinate(updatedCoordinate);
+        applyCoordinateChange(updatedCoordinate);
+    };
+    const handleLongitudeChange = (event) => {
+        const rawValue = event.value;
+        setLongitudeInput(rawValue);
+        const numericLongitude = Number(rawValue);
+        if (rawValue !== '' &&
+            (Number.isNaN(numericLongitude) ||
+                numericLongitude < -180 ||
+                numericLongitude > 180)) {
+            setValidationMessage('Longitude must be between -180 and 180.');
+            return;
+        }
+        if (latitudeInput === '' || rawValue === '') {
+            applyCoordinateChange(null);
+            return;
+        }
+        const numericLatitude = Number(latitudeInput);
+        if (Number.isNaN(numericLatitude) ||
+            numericLatitude < -90 ||
+            numericLatitude > 90) {
+            setValidationMessage('Latitude must be between -90 and 90.');
+            return;
+        }
+        const updatedCoordinate = {
+            lat: numericLatitude,
+            lng: numericLongitude,
+        };
+        setPendingCoordinate(updatedCoordinate);
+        applyCoordinateChange(updatedCoordinate);
+    };
+    const handleOpenMapDialog = () => {
+        if (disabled)
+            return;
+        const baseCoordinate = currentCoordinate ?? pendingCoordinate ?? null;
+        if (baseCoordinate) {
+            setPendingCoordinate(baseCoordinate);
+            setMapCenterPosition([baseCoordinate.lat, baseCoordinate.lng]);
+        }
+        else {
+            setMapCenterPosition(DEFAULT_CENTER);
+        }
+        setIsMapDialogOpen(true);
+        if (!baseCoordinate && navigator.geolocation) {
+            navigator.geolocation.getCurrentPosition((position) => {
+                const coordinate = normalizeCoordinate(position.coords.latitude, position.coords.longitude);
+                if (coordinate) {
+                    setPendingCoordinate(coordinate);
+                    setMapCenterPosition([coordinate.lat, coordinate.lng]);
+                }
+                else {
+                    setMapCenterPosition(DEFAULT_CENTER);
+                }
+            }, () => {
+                setValidationMessage((previous) => previous ??
+                    'We could not detect your location. Please move the map and click on the correct place.');
+            });
+        }
+    };
+    const handleCloseMapDialog = () => {
+        setIsMapDialogOpen(false);
+    };
+    const handleMapClick = (coordinate) => {
+        const normalized = normalizeCoordinate(coordinate.lat, coordinate.lng);
+        if (!normalized)
+            return;
+        setPendingCoordinate(normalized);
+        setMapCenterPosition([normalized.lat, normalized.lng]);
+    };
+    const handleConfirmFromMap = () => {
+        if (!pendingCoordinate)
+            return;
+        applyCoordinateChange(pendingCoordinate);
+        setIsMapDialogOpen(false);
+    };
+    const combinedErrorMessage = validationMessage || (error ? validationText : null);
+    const markerCoordinate = pendingCoordinate || currentCoordinate || null;
+    const selectedLocationText = markerCoordinate
+        ? `Selected location: Lat ${markerCoordinate.lat.toFixed(5)}, Lon ${markerCoordinate.lng.toFixed(5)}`
+        : 'No location selected yet. Click on the street map to drop a marker.';
+    return (React__default.createElement(React__default.Fragment, null,
+        React__default.createElement(Field, { label: label, name: name, required: required, error: Boolean(combinedErrorMessage), validationText: combinedErrorMessage ?? undefined },
+            React__default.createElement("div", { style: {
+                    display: 'grid',
+                    gridTemplateColumns: 'minmax(0, 1.2fr) minmax(0, 1fr) minmax(0, 1fr)',
+                    gap: 8,
+                    alignItems: 'flex-end',
+                } },
+                React__default.createElement("div", { style: { display: 'flex', flexDirection: 'column', gap: 4 } },
+                    React__default.createElement(Button$1, { name: `${name}-open-map`, disabled: disabled, onClick: handleOpenMapDialog, secondary: true }, currentCoordinate
+                        ? 'Update location on map'
+                        : 'Pick location on map')),
+                React__default.createElement(InputField$1, { label: "Latitude (\u00B0)", name: `${name}-lat`, type: "number", step: "0.000001", disabled: disabled, value: latitudeInput, onChange: handleLatitudeChange, onBlur: onBlur, placeholder: "-6.814527" }),
+                React__default.createElement(InputField$1, { label: "Longitude (\u00B0)", name: `${name}-lng`, type: "number", step: "0.000001", disabled: disabled, value: longitudeInput, onChange: handleLongitudeChange, onBlur: onBlur, placeholder: "39.279557" }))),
+        isMapDialogOpen && (React__default.createElement(Modal$1, { onClose: handleCloseMapDialog, position: "middle", className: "coordinate-modal" },
+            React__default.createElement(ModalTitle$1, null, "Select location on street map"),
+            React__default.createElement(ModalContent$1, null,
+                React__default.createElement("div", { style: {
+                        width: '80vw',
+                        height: '70vh',
+                        maxWidth: '100%',
+                        maxHeight: '80vh',
+                    } },
+                    React__default.createElement(CoordinateMapContainer, { center: mapCenterPosition, zoom: markerCoordinate ? 12 : DEFAULT_ZOOM, style: { width: '100%', height: '100%', borderRadius: 8 }, scrollWheelZoom: !disabled },
+                        React__default.createElement(TileLayer, { attribution: "\u00A9 OpenStreetMap contributors", url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png" }),
+                        React__default.createElement(RecenterOnCoordinate, { coordinate: markerCoordinate }),
+                        markerCoordinate && (React__default.createElement(Marker, { position: [markerCoordinate.lat, markerCoordinate.lng] })),
+                        React__default.createElement(MapClickListener, { disabled: disabled, onCoordinateSelected: handleMapClick }))),
+                React__default.createElement("p", { style: { marginTop: 8, fontSize: 13 } }, selectedLocationText),
+                React__default.createElement(Help, null, "Use the street map to find the correct facility, building or area. Pan (drag), zoom in/out, then click once to place or move the marker. Click Use Selected Location to save the coordinates.")),
+            React__default.createElement(ModalActions$1, null,
+                React__default.createElement("div", { style: { display: 'flex', gap: 12 } },
+                    React__default.createElement(Button$1, { onClick: handleCloseMapDialog, secondary: true }, "Cancel"),
+                    React__default.createElement(Button$1, { primary: true, onClick: handleConfirmFromMap, disabled: !pendingCoordinate }, "Use Selected Location")))))));
+};
+
 // Copyright 2024 UDSM DHIS2 Lab. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
@@ -6416,6 +6684,26 @@ class BaseFormFieldComponent extends ReactWrapperModule {
             };
             const formFieldContent = () => {
                 switch (this.field().controlType) {
+                    case 'coordinate':
+                        return (React__default.createElement("div", { style: { display: 'flex', flexDirection: 'column', gap: 12 } },
+                            React__default.createElement(NoticeBox, { title: "Location capture required" },
+                                React__default.createElement("p", { style: { margin: 0 } }, "This field requires selecting the exact geographic location on the map."),
+                                React__default.createElement("ul", { style: { margin: '6px 0 0 18px', padding: 0, fontSize: 13 } },
+                                    React__default.createElement("li", null,
+                                        "Click ",
+                                        React__default.createElement("strong", null, "\u201CPick location on map\u201D"),
+                                        " to open the street map."),
+                                    React__default.createElement("li", null, "Pan and zoom until you locate the correct facility, building, house or area."),
+                                    React__default.createElement("li", null, "Click once on the map to place or move the marker accurately."),
+                                    React__default.createElement("li", null,
+                                        "Click ",
+                                        React__default.createElement("strong", null, "\u201CUse Selected Location\u201D"),
+                                        " to save the coordinates."))),
+                            React__default.createElement(CoordinatePickerField, { error: hasError, validationText: validationError, required: this.field().required, name: this.field().id, disabled: disabled, label: this.label(), value: value, onChange: (newValue) => {
+                                    onValueChange(newValue);
+                                }, onBlur: () => {
+                                    checkValueUniqueness();
+                                } })));
                     case 'textarea':
                         return (React__default.createElement(TextAreaField, { error: hasError, validationText: validationError, inputWidth: this.fieldConfig()?.inputWidth, required: this.field().required, name: this.field().id, disabled: disabled, label: this.label(), rows: 5, placeholder: this.placeholder(), value: value, onChange: (event) => {
                                 onValueChange(event.value);
@@ -6456,13 +6744,57 @@ class BaseFormFieldComponent extends ReactWrapperModule {
                             }, onBlur: () => {
                                 checkValueUniqueness();
                             }, selected: arrayValue }, (this.field().options || []).map((option) => (React__default.createElement(MultiSelectOption, { key: generateUUID(), label: option.label, value: option.value })))));
+                    // case 'date':
+                    // case 'date-time':
+                    //   return (
+                    //     <InputField
+                    //       error={hasError}
+                    //       validationText={validationError}
+                    //       type={this.field().type as any}
+                    //       inputWidth={inputWidth}
+                    //       required={this.field().required}
+                    //       name={this.field().id}
+                    //       label={this.label()}
+                    //       min={this.field().min?.toString()}
+                    //       max={this.field().max?.toString()}
+                    //       placeholder={this.placeholder()}
+                    //       value={value}
+                    //       readOnly={disabled}
+                    //       onChange={(event: any) => {
+                    //         onValueChange(event.value);
+                    //       }}
+                    //       onBlur={() => {
+                    //         checkValueUniqueness();
+                    //       }}
+                    //     />
+                    //   );
                     case 'date':
-                    case 'date-time':
-                        return (React__default.createElement(InputField$1, { error: hasError, validationText: validationError, type: this.field().type, inputWidth: inputWidth, required: this.field().required, name: this.field().id, label: this.label(), min: this.field().min?.toString(), max: this.field().max?.toString(), placeholder: this.placeholder(), value: value, readOnly: disabled, onChange: (event) => {
-                                onValueChange(event.value);
+                    case 'date-time': {
+                        const field = this.field();
+                        const isDateTimeField = field.type === 'date-time';
+                        const inputType = isDateTimeField
+                            ? 'datetime-local'
+                            : 'date';
+                        // Value coming from DHIS2 store
+                        const htmlValue = this.formatValueForHtmlInputFromDhis(value, isDateTimeField);
+                        const htmlMin = field.min
+                            ? this.formatValueForHtmlInputFromDhis(String(field.min), isDateTimeField)
+                            : undefined;
+                        // Max defined in metadata (if any)
+                        const metadataMax = field.max
+                            ? this.formatValueForHtmlInputFromDhis(String(field.max), isDateTimeField)
+                            : undefined;
+                        // System max = “now” (no future allowed)
+                        const systemMax = this.getNowForHtmlDateInput(isDateTimeField);
+                        // Effective max = earliest of metadataMax and systemMax
+                        const htmlMax = this.pickEarlierDateLimit(metadataMax, systemMax);
+                        return (React__default.createElement(InputField$1, { error: hasError, validationText: validationError, type: inputType, inputWidth: inputWidth, required: field.required, name: field.id, label: this.label(), min: htmlMin, max: htmlMax, placeholder: this.placeholder(), value: htmlValue, readOnly: disabled, onChange: ({ value: newValue }) => {
+                                const normalized = this.normalizeDateValueFromHtmlInput(newValue, isDateTimeField, true);
+                                onValueChange(normalized);
                             }, onBlur: () => {
                                 checkValueUniqueness();
                             } }));
+                    }
                     case 'file':
                         return (React__default.createElement(React__default.Fragment, null,
                             React__default.createElement(FileUploadField, { label: this.label(), id: this.field().id, hasError: hasError, required: this.field().required, validationText: validationError, performUpload: true, uploadUrl: 'fileResources', onUploadSuccess: (fileId) => {
@@ -6495,6 +6827,132 @@ class BaseFormFieldComponent extends ReactWrapperModule {
     onChange(event) {
         this.value.set(event);
     }
+    formatValueForHtmlDateInput(rawValue, isDateTimeField) {
+        if (!rawValue)
+            return '';
+        const trimmed = rawValue.trim();
+        if (!trimmed)
+            return '';
+        if (!isDateTimeField) {
+            const datePart = trimmed.split('T')[0].split(' ')[0];
+            return /^\d{4}-\d{2}-\d{2}$/.test(datePart) ? datePart : '';
+        }
+        if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(trimmed)) {
+            return trimmed;
+        }
+        const date = new Date(trimmed);
+        if (Number.isNaN(date.getTime())) {
+            return '';
+        }
+        const pad = (n) => String(n).padStart(2, '0');
+        return (`${date.getFullYear()}-` +
+            `${pad(date.getMonth() + 1)}-` +
+            `${pad(date.getDate())}T` +
+            `${pad(date.getHours())}:` +
+            `${pad(date.getMinutes())}`);
+    }
+    formatValueForHtmlInputFromDhis(rawValue, isDateTimeField) {
+        if (!rawValue)
+            return '';
+        const trimmed = rawValue.trim();
+        if (!trimmed)
+            return '';
+        const pad = (n) => String(n).padStart(2, '0');
+        if (!isDateTimeField) {
+            if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+                return trimmed;
+            }
+            const date = new Date(trimmed);
+            if (Number.isNaN(date.getTime())) {
+                return '';
+            }
+            return (`${date.getFullYear()}-` +
+                `${pad(date.getMonth() + 1)}-` +
+                `${pad(date.getDate())}`);
+        }
+        const parsedDate = new Date(trimmed);
+        if (Number.isNaN(parsedDate.getTime())) {
+            return '';
+        }
+        const year = parsedDate.getFullYear();
+        const month = pad(parsedDate.getMonth() + 1);
+        const day = pad(parsedDate.getDate());
+        const hours = pad(parsedDate.getHours());
+        const minutes = pad(parsedDate.getMinutes());
+        return `${year}-${month}-${day}T${hours}:${minutes}`;
+    }
+    getNowForHtmlDateInput(isDateTimeField) {
+        const now = new Date();
+        const pad = (n) => String(n).padStart(2, '0');
+        const datePart = `${now.getFullYear()}-` +
+            `${pad(now.getMonth() + 1)}-` +
+            `${pad(now.getDate())}`;
+        if (!isDateTimeField) {
+            return datePart;
+        }
+        const timePart = `${pad(now.getHours())}:` + `${pad(now.getMinutes())}`;
+        return `${datePart}T${timePart}`;
+    }
+    pickEarlierDateLimit(metadataMax, systemMax) {
+        if (!metadataMax && !systemMax)
+            return undefined;
+        if (!metadataMax)
+            return systemMax;
+        if (!systemMax)
+            return metadataMax;
+        return metadataMax < systemMax ? metadataMax : systemMax;
+    }
+    /**
+     * Normalizes value from the HTML input into DHIS storage format.
+     *
+     * For date:
+     *   - Input: "YYYY-MM-DD"
+     *   - Output: "YYYY-MM-DD"
+     *
+     * For datetime:
+     *   - Input: "YYYY-MM-DDTHH:mm" (local)
+     *   - Output: ISO string in UTC: "YYYY-MM-DDTHH:mm:ss.sssZ"
+     *
+     * If disallowFuture = true, any value beyond "now" is clamped to now.
+     */
+    normalizeDateValueFromHtmlInput(inputValue, isDateTimeField, disallowFuture) {
+        const trimmed = (inputValue ?? '').trim();
+        if (!trimmed)
+            return null;
+        if (!isDateTimeField) {
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+                return null;
+            }
+            if (disallowFuture) {
+                const todayStr = this.getNowForHtmlDateInput(false);
+                if (trimmed > todayStr) {
+                    return todayStr;
+                }
+            }
+            return trimmed;
+        }
+        // ---- DATETIME (date-time) ----
+        // HTML datetime-local gives "YYYY-MM-DDTHH:mm" (local)
+        if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(trimmed)) {
+            return null;
+        }
+        // Interpret as LOCAL time
+        const localDate = new Date(trimmed);
+        if (Number.isNaN(localDate.getTime())) {
+            return null;
+        }
+        if (disallowFuture) {
+            const now = new Date();
+            if (localDate.getTime() > now.getTime()) {
+                // Option A: clamp to now
+                return now.toISOString();
+                // Option B: reject:
+                // return null;
+            }
+        }
+        // Store as UTC ISO string with millis, e.g. "2025-11-26T21:01:00.000Z"
+        return localDate.toISOString();
+    }
     async searchForDuplicates(value) {
         const d2 = window.d2Web;
         if (!value) {
@@ -7196,6 +7654,7 @@ var FieldType;
     FieldType["ORG_UNIT"] = "ORGANISATION_UNIT";
     FieldType["PHONE_NUMBER"] = "PHONE_NUMBER";
     FieldType["EMAIL"] = "EMAIL";
+    FieldType["COORDINATE"] = "COORDINATE";
 })(FieldType || (FieldType = {}));
 
 // Copyright 2025 UDSM DHIS2 Lab. All rights reserved.
@@ -7298,8 +7757,12 @@ class FieldUtil {
                 return 'org-unit';
             case FieldType.DATE:
                 return 'date';
+            case FieldType.DATE_TIME:
+                return 'date-time';
             case FieldType.FILE_RESOURCE:
                 return 'file';
+            case FieldType.COORDINATE:
+                return 'coordinate';
             default:
                 return 'text';
         }
@@ -7329,6 +7792,8 @@ class FieldUtil {
                 return 'image';
             case FieldType.FILE_RESOURCE:
                 return 'file';
+            case FieldType.COORDINATE:
+                return 'coordinate';
             default:
                 return 'textbox';
         }
@@ -7373,6 +7838,8 @@ class FieldControlTypeUtil {
                 return 'image';
             case FieldType.FILE_RESOURCE:
                 return 'file';
+            case FieldType.COORDINATE:
+                return 'coordinate';
             default:
                 return 'textbox';
         }
@@ -7392,6 +7859,10 @@ class FormFieldTypeUtil {
                 return 'image';
             case FieldType.FILE_RESOURCE:
                 return 'file';
+            case FieldType.COORDINATE:
+                return 'coordinate';
+            case FieldType.DATE_TIME:
+                return 'date-time';
             default:
                 return 'text';
         }