udp-stencil-component-library 26.5.0-beta.2 → 26.5.0-beta.21

package/dist/collection/components/forms/udp-question-form/core/validation/rules/max-decimal-places.js

@@ -0,0 +1,67 @@
+import { FieldTypeId } from "../../types";
+/**
+ * Value may have at most `maxDecimalPlaces` digits after the decimal point
+ * (e.g. currency = 2). Number-keyed with NaN-sentinel activation; the param
+ * itself must be a non-negative integer.
+ */
+export const maxDecimalPlacesRule = {
+    ruleType: 'maxDecimalPlaces',
+    appliesTo: [FieldTypeId.Number],
+    readParams: question => {
+        const v = question.fieldProperties.maxDecimalPlaces;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => Number.isInteger(n) && n >= 0 ? null : 'Enter a whole number of decimal places (0 or more).',
+    check: (value, max) => {
+        if (!Number.isInteger(max) || max < 0)
+            return null;
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return null;
+        return decimalPlaces(n) > max ? { message: message(max) } : null;
+    },
+    defaultMessage: message,
+    builder: {
+        label: 'Maximum decimal places',
+        description: 'Limit how many digits may follow the decimal point.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.maxDecimalPlaces',
+                label: 'Maximum decimal places',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 2,
+        enable: set => set('fieldProperties.maxDecimalPlaces', 2),
+        disable: set => set('fieldProperties.maxDecimalPlaces', undefined),
+    },
+};
+function decimalPlaces(n) {
+    var _a;
+    if (Number.isInteger(n))
+        return 0;
+    const s = Math.abs(n).toString();
+    const e = s.indexOf('e');
+    if (e !== -1) {
+        // Scientific notation (very small/large) — derive places from the exponent.
+        const exp = Number(s.slice(e + 1));
+        const fracDigits = ((_a = s.slice(0, e).split('.')[1]) !== null && _a !== void 0 ? _a : '').length;
+        return Math.max(0, fracDigits - exp);
+    }
+    const dot = s.indexOf('.');
+    return dot === -1 ? 0 : s.length - dot - 1;
+}
+function message(max) {
+    return `Must have at most ${max} decimal place${max === 1 ? '' : 's'}`;
+}

package/dist/collection/components/forms/udp-question-form/core/validation/rules/max-length.js

@@ -0,0 +1,38 @@
+import { FieldTypeId } from "../../types";
+export const maxLengthRule = {
+    ruleType: 'maxLength',
+    appliesTo: [FieldTypeId.SingleLineText, FieldTypeId.MultiLineText],
+    // See min-length.ts for the three-state activation rationale.
+    readParams: question => {
+        const v = question.fieldProperties.maxCharacter;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => {
+        if (!Number.isFinite(n))
+            return 'Enter a maximum length.';
+        if (n < 0)
+            return 'Maximum length must be 0 or greater.';
+        return null;
+    },
+    check: (value, max) => {
+        const len = typeof value === 'string' ? value.length : 0;
+        return len > max ? { message: `Must be at most ${max} characters` } : null;
+    },
+    defaultMessage: n => `Must be at most ${n} characters`,
+    builder: {
+        label: 'Maximum length',
+        params: [{ key: 'value', formPath: 'fieldProperties.maxCharacter', label: 'Maximum characters', type: 'number', min: 0 }],
+        defaultParams: 100,
+        enable: set => set('fieldProperties.maxCharacter', 100),
+        disable: set => set('fieldProperties.maxCharacter', undefined),
+    },
+};

package/dist/collection/components/forms/udp-question-form/core/validation/rules/max-rows.js

@@ -0,0 +1,53 @@
+import { FieldTypeId } from "../../types";
+/**
+ * Upper bound on a table's row count. The Table value is `{ rows: [...] }`.
+ * Number-keyed with the same NaN-sentinel activation as max-value.
+ */
+export const maxRowsRule = {
+    ruleType: 'maxRows',
+    appliesTo: [FieldTypeId.Table],
+    readParams: question => {
+        const v = question.fieldProperties.maxRows;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a maximum number of rows.'),
+    check: (value, max) => {
+        if (!Number.isFinite(max))
+            return null;
+        const count = rowCount(value);
+        return count > max ? { message: message(max) } : null;
+    },
+    defaultMessage: message,
+    builder: {
+        label: 'Maximum rows',
+        description: 'Limit how many rows the table may contain.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.maxRows',
+                label: 'Maximum rows',
+                type: 'number',
+                min: 1,
+            },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.maxRows', 1),
+        disable: set => set('fieldProperties.maxRows', undefined),
+    },
+};
+function rowCount(value) {
+    const rows = value === null || value === void 0 ? void 0 : value.rows;
+    return Array.isArray(rows) ? rows.length : 0;
+}
+function message(max) {
+    return `No more than ${max} row${max === 1 ? '' : 's'} allowed`;
+}

package/dist/collection/components/forms/udp-question-form/core/validation/rules/max-selections.js

@@ -0,0 +1,50 @@
+import { FieldTypeId } from "../../types";
+/**
+ * Upper bound on how many options a multi-select may have. Number-keyed with
+ * the same NaN-sentinel activation as max-value (see min-selections for the
+ * rationale).
+ */
+export const maxSelectionsRule = {
+    ruleType: 'maxSelections',
+    appliesTo: [FieldTypeId.Checkbox, FieldTypeId.DropdownMultipleSelect, FieldTypeId.ListMultiSelect],
+    readParams: question => {
+        const v = question.fieldProperties.maxSelections;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a maximum number of selections.'),
+    check: (value, max) => {
+        if (!Number.isFinite(max))
+            return null;
+        const count = Array.isArray(value) ? value.length : 0;
+        return count > max ? { message: message(max) } : null;
+    },
+    defaultMessage: message,
+    builder: {
+        label: 'Maximum selections',
+        description: 'Limit how many options may be selected.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.maxSelections',
+                label: 'Maximum selections',
+                type: 'number',
+                min: 1,
+            },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.maxSelections', 1),
+        disable: set => set('fieldProperties.maxSelections', undefined),
+    },
+};
+function message(max) {
+    return `Select at most ${max} option${max === 1 ? '' : 's'}`;
+}

package/dist/collection/components/forms/udp-question-form/core/validation/rules/max-time.js

@@ -0,0 +1,29 @@
+import { FieldTypeId } from "../../types";
+const TIME_RE = /^\d{2}:\d{2}(?::\d{2})?$/;
+// Normalize to HH:mm:ss so legacy seconds-bearing bounds compare correctly
+// against HH:mm submission values (see min-time.ts).
+const withSeconds = (t) => (t.length === 5 ? `${t}:00` : t);
+export const maxTimeRule = {
+    ruleType: 'maxTime',
+    appliesTo: [FieldTypeId.TimeSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.maxTime;
+        return typeof v === 'string' && TIME_RE.test(v) ? v : null;
+    },
+    validateParams: v => (TIME_RE.test(v) ? null : 'Must be a HH:mm[:ss] time.'),
+    check: (value, max) => {
+        const v = typeof value === 'string' ? value : '';
+        return withSeconds(v) > withSeconds(max)
+            ? { message: `Must be at or before ${max}` }
+            : null;
+    },
+    defaultMessage: max => `Must be at or before ${max}`,
+    builder: {
+        label: 'Latest time',
+        params: [{ key: 'value', formPath: 'fieldProperties.maxTime', label: 'Latest allowed time', type: 'time' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.maxTime', '23:59'),
+        disable: set => set('fieldProperties.maxTime', undefined),
+    },
+};

package/dist/collection/components/forms/udp-question-form/core/validation/rules/max-value.js

@@ -0,0 +1,34 @@
+import { FieldTypeId } from "../../types";
+export const maxValueRule = {
+    ruleType: 'maxValue',
+    appliesTo: [FieldTypeId.Number],
+    // See min-value.ts for the three-state activation rationale.
+    readParams: question => {
+        const v = question.fieldProperties.maxValue;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a maximum value.'),
+    check: (value, max) => {
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return null;
+        return n > max ? { message: `Must be at most ${max}` } : null;
+    },
+    defaultMessage: n => `Must be at most ${n}`,
+    builder: {
+        label: 'Maximum value',
+        params: [{ key: 'value', formPath: 'fieldProperties.maxValue', label: 'Maximum value', type: 'number' }],
+        defaultParams: 100,
+        enable: set => set('fieldProperties.maxValue', 100),
+        disable: set => set('fieldProperties.maxValue', undefined),
+    },
+};

package/dist/collection/components/forms/udp-question-form/core/validation/rules/min-age.js

@@ -0,0 +1,54 @@
+import { FieldTypeId } from "../../types";
+import { ageFromDob } from "./age";
+/**
+ * Minimum age in whole years, computed from a date-of-birth value against the
+ * injectable clock (`ctx.now()`). Number-keyed with NaN-sentinel activation.
+ * Empty-skip like the other date rules — an unanswered DOB doesn't fire; pair
+ * with Required to make the date mandatory.
+ */
+export const minAgeRule = {
+    ruleType: 'minAge',
+    appliesTo: [FieldTypeId.DateSelector],
+    readParams: question => {
+        const v = question.fieldProperties.minAge;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) && n >= 0 ? null : 'Enter a minimum age.'),
+    check: (value, min, _question, ctx) => {
+        if (!Number.isFinite(min))
+            return null;
+        const age = ageFromDob(value, ctx.now());
+        if (age == null)
+            return null;
+        return age < min ? { message: message(min) } : null;
+    },
+    defaultMessage: message,
+    builder: {
+        label: 'Minimum age',
+        description: 'Require the date of birth to be at least N years ago.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.minAge',
+                label: 'Minimum age (years)',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 18,
+        enable: set => set('fieldProperties.minAge', 18),
+        disable: set => set('fieldProperties.minAge', undefined),
+    },
+};
+function message(min) {
+    return `Must be at least ${min} year${min === 1 ? '' : 's'} old`;
+}

package/dist/collection/components/forms/udp-question-form/core/validation/rules/min-date-time.js

@@ -0,0 +1,34 @@
+import { FieldTypeId } from "../../types";
+const DATETIME_RE = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2})?$/;
+// Normalize a datetime string for lexicographic comparison: legacy bounds
+// use a space separator and carry seconds ('1980-01-01 00:00:00') while
+// submission values are T-separated without seconds ('1980-01-01T00:00').
+// Unify the separator and pad missing seconds so equal instants compare equal.
+const normalizeDateTime = (s) => {
+    const t = s.replace(' ', 'T');
+    return t.length === 16 ? `${t}:00` : t;
+};
+export const minDateTimeRule = {
+    ruleType: 'minDateTime',
+    appliesTo: [FieldTypeId.DateTimeSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.minDateTime;
+        return typeof v === 'string' && DATETIME_RE.test(v) ? v : null;
+    },
+    validateParams: v => (DATETIME_RE.test(v) ? null : 'Must be a YYYY-MM-DD HH:mm[:ss] datetime.'),
+    check: (value, min) => {
+        const v = typeof value === 'string' ? value : '';
+        return normalizeDateTime(v) < normalizeDateTime(min)
+            ? { message: `Must be on or after ${min}` }
+            : null;
+    },
+    defaultMessage: min => `Must be on or after ${min}`,
+    builder: {
+        label: 'Earliest date/time',
+        params: [{ key: 'value', formPath: 'fieldProperties.minDateTime', label: 'Earliest allowed date/time', type: 'datetime' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.minDateTime', `${new Date().toISOString().slice(0, 10)}T00:00`),
+        disable: set => set('fieldProperties.minDateTime', undefined),
+    },
+};

package/dist/collection/components/forms/udp-question-form/core/validation/rules/min-date.js

@@ -0,0 +1,24 @@
+import { FieldTypeId } from "../../types";
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+export const minDateRule = {
+    ruleType: 'minDate',
+    appliesTo: [FieldTypeId.DateSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.minDate;
+        return typeof v === 'string' && ISO_DATE.test(v) ? v : null;
+    },
+    validateParams: v => (ISO_DATE.test(v) ? null : 'Must be a YYYY-MM-DD date.'),
+    check: (value, min) => {
+        const v = typeof value === 'string' ? value : '';
+        return v < min ? { message: `Must be on or after ${min}` } : null;
+    },
+    defaultMessage: min => `Must be on or after ${min}`,
+    builder: {
+        label: 'Earliest date',
+        params: [{ key: 'value', formPath: 'fieldProperties.minDate', label: 'Earliest allowed date', type: 'date' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.minDate', new Date().toISOString().slice(0, 10)),
+        disable: set => set('fieldProperties.minDate', undefined),
+    },
+};

package/dist/collection/components/forms/udp-question-form/core/validation/rules/min-length.js

@@ -0,0 +1,40 @@
+import { FieldTypeId } from "../../types";
+export const minLengthRule = {
+    ruleType: 'minLength',
+    appliesTo: [FieldTypeId.SingleLineText, FieldTypeId.MultiLineText],
+    // `undefined` → rule off; a finite/parseable value → rule on with that value;
+    // anything else present → rule on with NaN, which keeps the card mounted
+    // while `validateParams` surfaces a fix-the-input error and blocks Update.
+    readParams: question => {
+        const v = question.fieldProperties.minCharacter;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => {
+        if (!Number.isFinite(n))
+            return 'Enter a minimum length.';
+        if (n < 0)
+            return 'Minimum length must be 0 or greater.';
+        return null;
+    },
+    check: (value, min) => {
+        const len = typeof value === 'string' ? value.length : 0;
+        return len < min ? { message: `Must be at least ${min} characters` } : null;
+    },
+    defaultMessage: n => `Must be at least ${n} characters`,
+    builder: {
+        label: 'Minimum length',
+        params: [{ key: 'value', formPath: 'fieldProperties.minCharacter', label: 'Minimum characters', type: 'number', min: 0 }],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.minCharacter', 1),
+        disable: set => set('fieldProperties.minCharacter', undefined),
+    },
+};

package/dist/collection/components/forms/udp-question-form/core/validation/rules/min-rows.js

@@ -0,0 +1,58 @@
+import { FieldTypeId } from "../../types";
+/**
+ * Lower bound on a table's row count. The Table value is `{ rows: [...] }`
+ * (see the table intrinsic rule). Number-keyed with the same NaN-sentinel
+ * activation as min-value. Note `required` already enforces "at least one
+ * row"; this rule is for explicit minimums (e.g. "add at least 3 line items").
+ */
+export const minRowsRule = {
+    ruleType: 'minRows',
+    appliesTo: [FieldTypeId.Table],
+    // A row minimum is mandatory by nature: an empty table (0 rows) violates
+    // "at least N", so run even when empty rather than skipping.
+    runOnEmpty: true,
+    readParams: question => {
+        const v = question.fieldProperties.minRows;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a minimum number of rows.'),
+    check: (value, min) => {
+        if (!Number.isFinite(min))
+            return null;
+        const count = rowCount(value);
+        return count < min ? { message: message(min) } : null;
+    },
+    defaultMessage: message,
+    builder: {
+        label: 'Minimum rows',
+        description: 'Require at least N rows in the table.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.minRows',
+                label: 'Minimum rows',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.minRows', 1),
+        disable: set => set('fieldProperties.minRows', undefined),
+    },
+};
+function rowCount(value) {
+    const rows = value === null || value === void 0 ? void 0 : value.rows;
+    return Array.isArray(rows) ? rows.length : 0;
+}
+function message(min) {
+    return `Add at least ${min} row${min === 1 ? '' : 's'}`;
+}

package/dist/collection/components/forms/udp-question-form/core/validation/rules/min-selections.js

@@ -0,0 +1,55 @@
+import { FieldTypeId } from "../../types";
+/**
+ * Lower bound on how many options a multi-select must have. Number-keyed with
+ * the same NaN-sentinel activation as min-value: `undefined` is off, a
+ * parseable number is active, and present-but-unparseable returns NaN
+ * (active-but-invalid) so the builder card survives an in-flight empty input
+ * while `validateParams` blocks the Update.
+ */
+export const minSelectionsRule = {
+    ruleType: 'minSelections',
+    appliesTo: [FieldTypeId.Checkbox, FieldTypeId.DropdownMultipleSelect, FieldTypeId.ListMultiSelect],
+    // A count minimum is mandatory by nature: an empty selection (0) violates
+    // "at least N", so run even when empty rather than skipping like length/value.
+    runOnEmpty: true,
+    readParams: question => {
+        const v = question.fieldProperties.minSelections;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a minimum number of selections.'),
+    check: (value, min) => {
+        if (!Number.isFinite(min))
+            return null;
+        const count = Array.isArray(value) ? value.length : 0;
+        return count < min ? { message: message(min) } : null;
+    },
+    defaultMessage: message,
+    builder: {
+        label: 'Minimum selections',
+        description: 'Require at least N options to be selected.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.minSelections',
+                label: 'Minimum selections',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.minSelections', 1),
+        disable: set => set('fieldProperties.minSelections', undefined),
+    },
+};
+function message(min) {
+    return `Select at least ${min} option${min === 1 ? '' : 's'}`;
+}

package/dist/collection/components/forms/udp-question-form/core/validation/rules/min-time.js

@@ -0,0 +1,31 @@
+import { FieldTypeId } from "../../types";
+// HH:mm or HH:mm:ss. We compare lexicographically after normalizing both
+// sides to HH:mm:ss — legacy fieldProperties store bounds WITH seconds
+// ('09:00:00') while submission values come in WITHOUT ('09:00'), and a raw
+// compare would fail the exact-boundary case ('09:00' < '09:00:00').
+const TIME_RE = /^\d{2}:\d{2}(?::\d{2})?$/;
+const withSeconds = (t) => (t.length === 5 ? `${t}:00` : t);
+export const minTimeRule = {
+    ruleType: 'minTime',
+    appliesTo: [FieldTypeId.TimeSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.minTime;
+        return typeof v === 'string' && TIME_RE.test(v) ? v : null;
+    },
+    validateParams: v => (TIME_RE.test(v) ? null : 'Must be a HH:mm[:ss] time.'),
+    check: (value, min) => {
+        const v = typeof value === 'string' ? value : '';
+        return withSeconds(v) < withSeconds(min)
+            ? { message: `Must be at or after ${min}` }
+            : null;
+    },
+    defaultMessage: min => `Must be at or after ${min}`,
+    builder: {
+        label: 'Earliest time',
+        params: [{ key: 'value', formPath: 'fieldProperties.minTime', label: 'Earliest allowed time', type: 'time' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.minTime', '00:00'),
+        disable: set => set('fieldProperties.minTime', undefined),
+    },
+};

package/dist/collection/components/forms/udp-question-form/core/validation/rules/min-value.js

@@ -0,0 +1,36 @@
+import { FieldTypeId } from "../../types";
+export const minValueRule = {
+    ruleType: 'minValue',
+    appliesTo: [FieldTypeId.Number],
+    // Same three-state pattern as min-length: `undefined` is off, a finite or
+    // parseable value is active, anything else present is NaN (active-but-invalid)
+    // so the card survives an empty input while `validateParams` blocks Update.
+    readParams: question => {
+        const v = question.fieldProperties.minValue;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a minimum value.'),
+    check: (value, min) => {
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return null;
+        return n < min ? { message: `Must be at least ${min}` } : null;
+    },
+    defaultMessage: n => `Must be at least ${n}`,
+    builder: {
+        label: 'Minimum value',
+        params: [{ key: 'value', formPath: 'fieldProperties.minValue', label: 'Minimum value', type: 'number' }],
+        defaultParams: 0,
+        enable: set => set('fieldProperties.minValue', 0),
+        disable: set => set('fieldProperties.minValue', undefined),
+    },
+};

package/dist/collection/components/forms/udp-question-form/core/validation/rules/must-be-yes.js

@@ -0,0 +1,23 @@
+import { FieldTypeId } from "../../types";
+/**
+ * Require a Yes/No to be set to Yes (e.g. attestation/consent). `required`
+ * alone treats a 'false' / 'na' answer as answered, so this is the rule
+ * that forces the affirmative. Boolean-keyed; runs on empty.
+ */
+export const mustBeYesRule = {
+    ruleType: 'mustBeYes',
+    appliesTo: [FieldTypeId.YesNo],
+    runOnEmpty: true,
+    readParams: question => question.fieldProperties.mustBeYes === true ? true : null,
+    validateParams: () => null,
+    check: value => value === 'true' || value === true ? null : { message: 'This must be set to Yes' },
+    defaultMessage: () => 'This must be set to Yes',
+    builder: {
+        label: 'Must be Yes',
+        description: 'Require the answer to be Yes (e.g. consent / attestation).',
+        params: [],
+        defaultParams: true,
+        enable: set => set('fieldProperties.mustBeYes', true),
+        disable: set => set('fieldProperties.mustBeYes', undefined),
+    },
+};