@dhis2/ui-forms 10.16.2 → 10.16.3

package/src/validators/__tests__/dhis2Username.test.js

@@ -0,0 +1,75 @@
+import { dhis2Username, invalidUsernameMessage } from '../dhis2Username.js'
+import {
+    testValidatorValues,
+    allowsEmptyValues,
+} from '../test-helpers/index.js'
+
+describe('validator: dhis2Username', () => {
+    allowsEmptyValues(dhis2Username)
+
+    describe('constrains length of username to between 4 and 255 characters long', () => {
+        testValidatorValues(dhis2Username, undefined, [
+            's'.repeat(4),
+            's'.repeat(255),
+            'valid_username',
+        ])
+
+        testValidatorValues(dhis2Username, invalidUsernameMessage, [
+            '1',
+            's',
+            's'.repeat(256),
+        ])
+    })
+
+    describe('does not allow usernames to start with _, -, . or @', () => {
+        testValidatorValues(dhis2Username, invalidUsernameMessage, [
+            '_xxx',
+            '-xxx',
+            '.xxx',
+            '@xxx',
+        ])
+    })
+
+    describe('does not allow usernames to end with _, -, . or @', () => {
+        testValidatorValues(dhis2Username, invalidUsernameMessage, [
+            'xxx_',
+            'xxx-',
+            'xxx.',
+            'xxx@',
+        ])
+    })
+
+    describe('does not allow usernames to contain __, --, .. or @@', () => {
+        testValidatorValues(dhis2Username, invalidUsernameMessage, [
+            'xx__xx',
+            'xx--xx',
+            'xx..xx',
+            'xx@@xx',
+        ])
+    })
+
+    describe('constrains characters in usernames to [a-z0-9._@]', () => {
+        testValidatorValues(dhis2Username, undefined, [
+            'v@lid_user.name',
+            'v@lid-user.name',
+            '123another_v@lid_usern@me',
+            'UPPER_CASE',
+            'lower@ca.se',
+        ])
+
+        testValidatorValues(dhis2Username, invalidUsernameMessage, [
+            'あいうえお',
+            'some_username^%&*(',
+        ])
+    })
+
+    describe('rejects non-string data types', () => {
+        testValidatorValues(dhis2Username, invalidUsernameMessage, [
+            1,
+            true,
+            {},
+            [],
+            () => {},
+        ])
+    })
+})

package/src/validators/__tests__/email.test.js

@@ -0,0 +1,83 @@
+import { email, invalidEmailMessage } from '../email.js'
+import {
+    testValidatorValues,
+    allowsEmptyValues,
+} from '../test-helpers/index.js'
+
+/*
+ * A comprehensive list technically valid and invalid email addresses was
+ * taken from:
+ * https://codefool.tumblr.com/post/15288874550/list-of-valid-and-invalid-email-addresses
+ *
+ * Our chosen regex does not work correctly in each case, but on balance
+ * it performs pretty well: all plausible email addresses are accepted
+ * and most malformed email addresses are rejected.
+ *
+ * I have kept the original list of values and have simply commented out
+ * the ones that are not evaluated correctly by our regex.
+ */
+
+describe('validator: email', () => {
+    allowsEmptyValues(email)
+
+    describe('allows valid email addresses', () => {
+        /*
+         * Items that have been commented out below are FALSELY REJECTED by the chosen regex
+         */
+        testValidatorValues(email, undefined, [
+            'email@example.com',
+            'firstname.lastname@example.com',
+            'email@subdomain.example.com',
+            'firstname+lastname@example.com',
+            // 'email@123.123.123.123',
+            'email@[123.123.123.123]',
+            '"email"@example.com',
+            '1234567890@example.com',
+            'email@example-one.com',
+            '_______@example.com',
+            'email@example.name',
+            'email@example.museum',
+            'email@example.co.jp',
+            'firstname-lastname@example.com',
+
+            /* very strange but technically valid addresses */
+            // 'much."more unusual"@example.com',
+            // 'very.unusual."@".unusual.com@example.com',
+            // 'very."(),:;<>[]".VERY."very@\\\\\\ "very".unusual@strange.example.com',
+        ])
+    })
+
+    describe('rejects invalid email addresses', () => {
+        /*
+         * Items that have been commented out below are FALSELY ACCEPTED by the chosen regex
+         */
+        testValidatorValues(email, invalidEmailMessage, [
+            'plainaddress',
+            '#@%^%#$@#$@#.com',
+            '@example.com',
+            'Joe Smith <email@example.com>',
+            'email.example.com',
+            'email@example@example.com',
+            '.email@example.com',
+            'email.@example.com',
+            'email..email@example.com',
+            /*
+             * I think this false positive below may actualy be correct behaviour,
+             * see https://en.wikipedia.org/wiki/International_email)
+             */
+            // 'あいうえお@example.com'
+            'email@example.com (Joe Smith)',
+            'email@example',
+            // 'email@-example.com',
+            // 'email@example.web',
+            'email@111.222.333.44444',
+            'email@example..com',
+            'Abc..123@example.com',
+
+            /* very strange invalid addresses */
+            '"(),:;<>[]@example.com',
+            'just"not"right@example.com',
+            'this is"really"not\\\\allowed@example.com',
+        ])
+    })
+})

package/src/validators/__tests__/hasValue.test.js

@@ -0,0 +1,21 @@
+import { hasValue, hasValueMessage } from '../hasValue.js'
+import { testValidatorValues } from '../test-helpers/index.js'
+
+describe('validator: hasValue', () => {
+    describe('should return undefined for allowed values', () => {
+        testValidatorValues(hasValue, undefined, [
+            'test',
+            false,
+            true,
+            0,
+            1,
+            {},
+            [],
+            new Date(),
+        ])
+    })
+
+    describe('should return the error message for disallowed values', () => {
+        testValidatorValues(hasValue, hasValueMessage, ['', undefined, null])
+    })
+})

package/src/validators/__tests__/integer.test.js

@@ -0,0 +1,48 @@
+import { integer, invalidIntegerMessage } from '../integer.js'
+import {
+    testValidatorValues,
+    allowsEmptyValues,
+} from '../test-helpers/index.js'
+
+describe('validator: integer', () => {
+    allowsEmptyValues(integer)
+
+    describe('allows integers and string representations of integers', () => {
+        testValidatorValues(integer, undefined, [
+            -2,
+            0,
+            2,
+            10000,
+            '-2',
+            '0',
+            '2',
+            '10000',
+            12e4,
+        ])
+    })
+
+    describe('rejects other data types and leading zeros', () => {
+        testValidatorValues(integer, invalidIntegerMessage, [
+            'text',
+            '014',
+            true,
+            {},
+            [],
+            () => {},
+        ])
+    })
+
+    describe('rejects floats and string representations of floats', () => {
+        testValidatorValues(integer, invalidIntegerMessage, [
+            0.23456,
+            5.987,
+            1e-12,
+            '4.0',
+            '4.000',
+            '4,0',
+            '0.23456',
+            '5.987',
+            '1e-12',
+        ])
+    })
+})

package/src/validators/__tests__/internationalPhoneNumber.test.js

@@ -0,0 +1,49 @@
+import {
+    internationalPhoneNumber,
+    invalidInternationalPhoneNumberMessage,
+} from '../internationalPhoneNumber.js'
+import {
+    testValidatorValues,
+    allowsEmptyValues,
+} from '../test-helpers/index.js'
+
+describe('validator: internationalPhoneNumber', () => {
+    allowsEmptyValues(internationalPhoneNumber)
+
+    describe('allows valid phone numbers', () => {
+        testValidatorValues(internationalPhoneNumber, undefined, [
+            '+31(0)725111889',
+            '068.468.0076',
+            '1-724-187-8238',
+            '(967) 211-7114',
+            '(978) 242-4017',
+            '105-535-1160',
+            '147-357-7565',
+            '(974) 309-3992',
+            '+1-228-630-0639',
+            '917.258.5059',
+            '888-814-8989',
+        ])
+    })
+
+    describe('rejects non-string values', () => {
+        testValidatorValues(
+            internationalPhoneNumber,
+            invalidInternationalPhoneNumberMessage,
+            [true, 3, {}, [], () => {}]
+        )
+    })
+
+    describe('rejects invalid phone numbers', () => {
+        testValidatorValues(
+            internationalPhoneNumber,
+            invalidInternationalPhoneNumberMessage,
+            [
+                'sometext123', // text
+                '+3172%^$#%*182838485868', // special characters
+                '+31725111889101112131415', // too long
+                '0031_72_5111889', // bad separators
+            ]
+        )
+    })
+})

package/src/validators/__tests__/number.test.js

@@ -0,0 +1,39 @@
+import { number, invalidNumberMessage } from '../number.js'
+import {
+    testValidatorValues,
+    allowsEmptyValues,
+} from '../test-helpers/index.js'
+
+describe('validator: number', () => {
+    allowsEmptyValues(number)
+
+    describe('allows numbers and string representations of numbers', () => {
+        testValidatorValues(number, undefined, [
+            -2,
+            0,
+            2,
+            10000,
+            '-2',
+            '0',
+            '2',
+            '10000',
+            12e4,
+            0.23456,
+            5.987,
+            1e-12,
+            '0.23456',
+            '5.987',
+            '1e-12',
+        ])
+    })
+
+    describe('rejects other data types', () => {
+        testValidatorValues(number, invalidNumberMessage, [
+            'text',
+            true,
+            {},
+            [],
+            () => {},
+        ])
+    })
+})

package/src/validators/__tests__/string.test.js

@@ -0,0 +1,29 @@
+import { string, invalidStringMessage } from '../string.js'
+import {
+    testValidatorValues,
+    allowsEmptyValues,
+} from '../test-helpers/index.js'
+
+describe('validator: string', () => {
+    allowsEmptyValues(string)
+
+    describe('allows strings', () => {
+        testValidatorValues(string, undefined, [
+            'text',
+            '1',
+            '0.15',
+            'true',
+            'false',
+        ])
+    })
+
+    describe('rejects other data types', () => {
+        testValidatorValues(string, invalidStringMessage, [
+            1,
+            true,
+            {},
+            [],
+            () => {},
+        ])
+    })
+})

package/src/validators/__tests__/url.test.js

@@ -0,0 +1,106 @@
+import {
+    testValidatorValues,
+    allowsEmptyValues,
+} from '../test-helpers/index.js'
+import { url, invalidUrlMessage } from '../url.js'
+
+/**
+ * List of valid and invalid URIs was sourced from
+ * https://formvalidation.io/guide/validators/uri
+ */
+
+describe('validator: url', () => {
+    allowsEmptyValues(url)
+
+    describe('allows valid URLs', () => {
+        testValidatorValues(url, undefined, [
+            'http://foo.com/blah_blah',
+            'http://foo.com/blah_blah/',
+            'http://foo.com/blah_blah_(wikipedia)',
+            'http://foo.com/blah_blah_(wikipedia)_(again)',
+            'http://www.example.com/wpstyle/?p=364',
+            'https://www.example.com/foo/?bar=baz&inga=42&quux',
+            'http://✪df.ws/123',
+            'http://userid:password@example.com:8080',
+            'http://userid:password@example.com:8080/',
+            'http://userid@example.com',
+            'http://userid@example.com/',
+            'http://userid@example.com:8080',
+            'http://userid@example.com:8080/',
+            'http://userid:password@example.com',
+            'http://userid:password@example.com/',
+            'http://142.42.1.1/',
+            'http://142.42.1.1:8080/',
+            'http://➡.ws/䨹',
+            'http://⌘.ws',
+            'http://⌘.ws/',
+            'http://foo.com/blah_(wikipedia)#cite-1',
+            'http://foo.com/blah_(wikipedia)_blah#cite-1',
+            'http://foo.com/unicode_(✪)_in_parens',
+            'http://foo.com/(something)?after=parens',
+            'http://☺.damowmow.com/',
+            'http://code.google.com/events/#&product=browser',
+            'http://j.mp',
+            'ftp://foo.bar/baz',
+            'http://foo.bar/?q=Test%20URL-encoded%20stuff',
+            'http://مثال.إختبار',
+            'http://例子.测试',
+            'http://उदाहरण.परीक्षा',
+            'http://-.~_!$&()*+,;=:%40:80%2f::::::@example.com',
+            'http://1337.net',
+            'http://a.b-c.de',
+            'http://223.255.255.254',
+            /*
+             * The one below is classified as valid by our regex
+             * but it was originally in the list of invalid urls
+             * I think it was misclassified, so moved it into the valid list. See:
+             * https://www.domainit.com/support/faq.mhtml?category=Domain_FAQ&question=9
+             * "A little known fact is that you CAN have multiple dashes right next to each other."
+             */
+            'http://a.b--c.de/',
+        ])
+    })
+
+    describe('rejects invalid URLs', () => {
+        testValidatorValues(url, invalidUrlMessage, [
+            'http://',
+            'http://.',
+            'http://..',
+            'http://../',
+            'http://?',
+            'http://??',
+            'http://??/',
+            'http://#',
+            'http://##',
+            'http://##/',
+            'http://foo.bar?q=Spaces should be encoded',
+            '//',
+            '//a',
+            '///a',
+            '///',
+            'http:///a',
+            'foo.com',
+            'rdar://1234',
+            'h://test',
+            'http:// shouldfail.com',
+            ':// should fail',
+            'http://foo.bar/foo(bar)baz quux',
+            'ftps://foo.bar/',
+            'http://-error-.invalid/',
+            'http://-a.b.co',
+            'http://a.b-.co',
+            'http://0.0.0.0',
+            'http://10.1.1.0',
+            'http://10.1.1.255',
+            'http://224.1.1.1',
+            'http://1.1.1.1.1',
+            'http://123.123.123',
+            'http://3628126748',
+            'http://.www.foo.bar/',
+            'http://www.foo.bar./',
+            'http://.www.foo.bar./',
+            'http://10.1.1.1',
+            'http://10.1.1.',
+        ])
+    })
+})

package/src/validators/alphaNumeric.js

@@ -0,0 +1,15 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isString } from './helpers/index.js'
+
+const ALPHA_NUMERIC_PATTERN = /^[a-z0-9 ]*$/i
+
+const invalidAlphaNumericMessage = i18n.t(
+    'Please provide an alpha-numeric value'
+)
+
+const alphaNumeric = (value) =>
+    isEmpty(value) || (isString(value) && ALPHA_NUMERIC_PATTERN.test(value))
+        ? undefined
+        : invalidAlphaNumericMessage
+
+export { alphaNumeric, invalidAlphaNumericMessage }

package/src/validators/boolean.js

@@ -0,0 +1,11 @@
+import i18n from '../locales/index.js'
+import { isEmpty } from './helpers/index.js'
+
+const invalidBooleanMessage = i18n.t('Please provide a boolean value')
+
+const boolean = (value) =>
+    isEmpty(value) || typeof value === 'boolean'
+        ? undefined
+        : invalidBooleanMessage
+
+export { boolean, invalidBooleanMessage }

package/src/validators/composeValidators.js

@@ -0,0 +1,8 @@
+export const composeValidators = (...validators) => {
+    return (...args) => {
+        return validators.reduce(
+            (error, validator) => error || validator(...args),
+            undefined
+        )
+    }
+}

package/src/validators/createCharacterLengthRange.js

@@ -0,0 +1,27 @@
+import i18n from '../locales/index.js'
+import {
+    isEmpty,
+    isString,
+    isInRange,
+    requireArgument,
+} from './helpers/index.js'
+
+const createCharacterLengthRange = (lowerBound, upperBound, customMessage) => {
+    requireArgument(lowerBound, 'number')
+    requireArgument(upperBound, 'number')
+
+    const errorMessage =
+        customMessage ||
+        i18n.t(
+            'Please enter between {{lowerBound}} and {{upperBound}} characters',
+            { lowerBound, upperBound }
+        )
+
+    return (value) =>
+        isEmpty(value) ||
+        (isString(value) && isInRange(lowerBound, upperBound, value.length))
+            ? undefined
+            : errorMessage
+}
+
+export { createCharacterLengthRange }

package/src/validators/createEqualTo.js

@@ -0,0 +1,16 @@
+import i18n from '../locales/index.js'
+import { isEmpty, requireArgument } from './helpers/index.js'
+
+const createEqualTo = (key, description) => {
+    requireArgument(key, 'string')
+
+    const errorMessage = i18n.t(
+        'Please make sure the value of this input matches the value in "{{otherField}}".',
+        { otherField: description || key }
+    )
+
+    return (value, allValues) =>
+        isEmpty(value) || value === allValues[key] ? undefined : errorMessage
+}
+
+export { createEqualTo }

package/src/validators/createMaxCharacterLength.js

@@ -0,0 +1,13 @@
+import i18n from '../locales/index.js'
+import { createCharacterLengthRange } from './createCharacterLengthRange.js'
+
+const createMaxCharacterLength = (upperBound) =>
+    createCharacterLengthRange(
+        0,
+        upperBound,
+        i18n.t('Please enter a maximum of {{upperBound}} characters', {
+            upperBound,
+        })
+    )
+
+export { createMaxCharacterLength }

package/src/validators/createMaxNumber.js

@@ -0,0 +1,13 @@
+import i18n from '../locales/index.js'
+import { createNumberRange } from './createNumberRange.js'
+
+const createMaxNumber = (upperBound) =>
+    createNumberRange(
+        -Infinity,
+        upperBound,
+        i18n.t('Please enter a number with a maximum of {{upperBound}}', {
+            upperBound,
+        })
+    )
+
+export { createMaxNumber }

package/src/validators/createMinCharacterLength.js

@@ -0,0 +1,13 @@
+import i18n from '../locales/index.js'
+import { createCharacterLengthRange } from './createCharacterLengthRange.js'
+
+const createMinCharacterLength = (lowerBound) =>
+    createCharacterLengthRange(
+        lowerBound,
+        Infinity,
+        i18n.t('Please enter at least {{lowerBound}} characters', {
+            lowerBound,
+        })
+    )
+
+export { createMinCharacterLength }

package/src/validators/createMinNumber.js

@@ -0,0 +1,13 @@
+import i18n from '../locales/index.js'
+import { createNumberRange } from './createNumberRange.js'
+
+const createMinNumber = (lowerBound) =>
+    createNumberRange(
+        lowerBound,
+        Infinity,
+        i18n.t('Please enter a number of at least {{lowerBound}}', {
+            lowerBound,
+        })
+    )
+
+export { createMinNumber }

package/src/validators/createNumberRange.js

@@ -0,0 +1,28 @@
+import i18n from '../locales/index.js'
+import {
+    isEmpty,
+    isNumeric,
+    toNumber,
+    isInRange,
+    requireArgument,
+} from './helpers/index.js'
+
+const createNumberRange = (lowerBound, upperBound, customMessage) => {
+    requireArgument(lowerBound, 'number')
+    requireArgument(upperBound, 'number')
+
+    const errorMessage =
+        customMessage ||
+        i18n.t(
+            'Number cannot be less than {{lowerBound}} or more than {{upperBound}}',
+            { lowerBound, upperBound }
+        )
+
+    return (value) =>
+        isEmpty(value) ||
+        (isNumeric(value) && isInRange(lowerBound, upperBound, toNumber(value)))
+            ? undefined
+            : errorMessage
+}
+
+export { createNumberRange }

package/src/validators/createPattern.js

@@ -0,0 +1,22 @@
+import i18n from '../locales/index.js'
+import { isEmpty, isString } from './helpers/index.js'
+
+const invalidPatternMessage =
+    'The first argument passed to createPattern was not a valid regex'
+
+const createPattern = (pattern, message) => {
+    if (!(pattern instanceof RegExp)) {
+        throw new Error(invalidPatternMessage)
+    }
+
+    return (value) =>
+        isEmpty(value) || (isString(value) && pattern.test(value))
+            ? undefined
+            : message ||
+              i18n.t(
+                  'Please make sure the value of this input matches the pattern {{patternString}}.',
+                  { patternString: pattern.toString() }
+              )
+}
+
+export { createPattern, invalidPatternMessage }