[Proposal] tg-resources ValidationError changes

changes.diff

# Key differences w/ the current default error parser
- Lists of errors joined by a comma
+ Lists of primitive errors joined by a space (configurable via options)
+ Lists of complex errors parsed as ListValidationErrors
+ ValidationError.asString()
+ ValidationError.toString() (proxy of asString)
+ Add iterators to ValidationErrors w/ children (so users don't have to iterate over .errors directly). Note: List/Object validationerrors should have same iteration API

example.js

const responseBody = {
    statusCode: 400,
    responseText: JSON.stringify({
        errors: {
            non_field_errors: [                              // string (joined by space)
                'Something is generally broken',
            ],

            
            password: [                                      // string (joined by space)
                'too short.',
                'missing numbers.',
            ],

            email: {                                         // Nested (object) ValidationError
                something: 'be wrong yo',                    // string
            },

            remember: false,                                 // string

            deliveryAddress: [                               // Nested (list) ValidationError
                {                                            // Nested (object) ValidationError
                    non_field_errors: [
                        'Provided address is not supported', // string (joined by space)
                    ],
                },
                null,                                        // null
                {                                            // Nested (object) ValidationError
                    zip: 'Please enter a valid address',     // string
                    country: [                               // string (joined by space)
                        'This field is required.',
                        'Please select a valid country.' 
                    ]
                },
                undefined,                                   // null (since no errors)
                {                                            // null (since no errors)
                    non_field_errors: [],                   
                },
                {}                                           // null (since no errors)
            ],

            paymentMethods: []                               // null
        },
    }),
};

const parsedError = ValidationError({
    nonFieldErrors: 'Something is generally broken',
    errors: {
        password: 'Too short. missing numbers.',
        email: ValidationError({
            nonFieldErrors: null,
            errors: {
                something: 'be wrong yo',
            },
        }),
        remember: 'false',
        deliveryAddress: ListValidationError({
            nonFieldErrors: undefined,  // unused for list validation errors (e.g. always undefined)
            errors: [
                ValidationError({
                    nonFieldErrors: 'Provided address is not supported',
                    errors: {},
                }),
                null,
                ValidationError({
                    nonFieldErrors: null,
                    errors: {
                        zip: 'Please enter a valid address',
                        country: 'This field is required. Please select a valid country.',
                    }
                }),
                null,
                null,
                null,
            ],
        }),
        // paymentMethods is stripped since it evaluates to an empty array (those are ignored)
    }
})

Preserving non_field_errors as list might make it easier to display in a meaningful way so unrelated sentences don't end up looking like a paragraph (user can still join with space if they want to)

parsedError.nonFieldErrors.map(e => <div class="error">e</div>)