@wise/dynamic-flow-client 3.9.2-experimental-535221d → 3.9.2

package/build/legacy/jsonSchemaForm/arrayTypeSchema/arrayListSchema/repeatableSchema/utils/summary-utils.spec.js

@@ -1,909 +0,0 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import { getItemSummaryFromSchema } from './summary-utils';
-describe('getItemSummaryFromSchema', function () {
-    describe('titles', function () {
-        var defaultTitle = 'default title';
-        describe('const schemas', function () {
-            var constSchema = {
-                const: 'const',
-            };
-            var constSchemaWithTitle = __assign(__assign({}, constSchema), { summary: {
-                    providesTitle: true,
-                } });
-            var constSchemaWithTitleProp = __assign(__assign({}, constSchemaWithTitle), { title: 'title' });
-            it('should return the default if the schema does not provide a title', function () {
-                expect(getItemSummaryFromSchema(constSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-                expect(getItemSummaryFromSchema(constSchema, 'const', { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the const if the schema provides a title', function () {
-                expect(getItemSummaryFromSchema(constSchemaWithTitle, null, { defaultTitle: defaultTitle }).title).toBe('const');
-                expect(getItemSummaryFromSchema(constSchemaWithTitle, 'const', { defaultTitle: defaultTitle }).title).toBe('const');
-            });
-            it('should prefer the title prop over the const value', function () {
-                expect(getItemSummaryFromSchema(constSchemaWithTitleProp, 'const', { defaultTitle: defaultTitle }).title).toBe('title');
-            });
-        });
-        describe('basic schemas', function () {
-            var basicSchema = {
-                type: 'string',
-                title: 'basic schema',
-            };
-            var basicSchemaWithTitle = __assign(__assign({}, basicSchema), { summary: {
-                    providesTitle: true,
-                } });
-            it('should return the default if the schema does not provide a title', function () {
-                expect(getItemSummaryFromSchema(basicSchema, 'value', { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-                expect(getItemSummaryFromSchema(basicSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the default if the schema provides a title but the model is null', function () {
-                expect(getItemSummaryFromSchema(basicSchemaWithTitle, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the model if the schema provides a title and the model is valued', function () {
-                expect(getItemSummaryFromSchema(basicSchemaWithTitle, 'value', { defaultTitle: defaultTitle }).title).toBe('value');
-            });
-        });
-        describe('object schemas', function () {
-            var objectSchema = {
-                type: 'object',
-                displayOrder: ['name'],
-                properties: {
-                    name: {
-                        title: 'Name',
-                        type: 'string',
-                    },
-                },
-            };
-            var objectSchemaWithTitle = __assign(__assign({}, objectSchema), { summary: {
-                    providesTitle: true,
-                } });
-            var objectSchemaWithTitleInChild = {
-                type: 'object',
-                displayOrder: ['age', 'name'],
-                properties: {
-                    name: {
-                        title: 'Name',
-                        type: 'string',
-                        summary: {
-                            providesTitle: true,
-                        },
-                    },
-                    age: {
-                        title: 'Age',
-                        type: 'string',
-                    },
-                },
-            };
-            it('should return the default if the schema does not provide a title', function () {
-                expect(getItemSummaryFromSchema(objectSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-                expect(getItemSummaryFromSchema(objectSchema, { name: 'name' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the default if schema provides a title but the model is not a string', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithTitle, { name: 'name' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the default if a child schema provides a title but the model is null', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithTitleInChild, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the model if a child schema provides a title and the model is valued', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithTitleInChild, { name: 'name' }, { defaultTitle: defaultTitle })
-                    .title).toBe('name');
-            });
-        });
-        describe('oneOf schemas', function () {
-            var oneOfSchema = {
-                oneOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            var oneOfSchemaWithTitle = __assign(__assign({}, oneOfSchema), { summary: {
-                    providesTitle: true,
-                } });
-            var oneOfSchemaWithTitleOnChildSchema = {
-                oneOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                                summary: {
-                                    providesTitle: true,
-                                },
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            it('should return the default if the schema does not provide a title', function () {
-                expect(getItemSummaryFromSchema(oneOfSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the default if the schema does not provide a title, even if the model is valued', function () {
-                expect(getItemSummaryFromSchema(oneOfSchema, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the default if a child schema provides a title but the model is null', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithTitleOnChildSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the model if a child schema provides a title and the model is valued', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithTitleOnChildSchema, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe('iban');
-            });
-            it('should return the default if schema provides a title but the model is not a string', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithTitle, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-        });
-        describe('allOf schemas', function () {
-            var allOfSchema = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            var allOfSchemaWithTitle = __assign(__assign({}, allOfSchema), { summary: {
-                    providesTitle: true,
-                } });
-            var allOfSchemaWithTitleOnChild = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                                summary: {
-                                    providesTitle: true,
-                                },
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            it('should return the default if the schema does not provide a title', function () {
-                expect(getItemSummaryFromSchema(allOfSchema, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-                expect(getItemSummaryFromSchema(allOfSchema, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the default if schema provides a title but the model is not a string', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithTitle, { iban: 'iban' }, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the default if a child schema provides a title but the model is null', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithTitleOnChild, null, { defaultTitle: defaultTitle }).title).toBe(defaultTitle);
-            });
-            it('should return the model if a child schema provides a title and the model is valued', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithTitleOnChild, { iban: 'iban' }, { defaultTitle: defaultTitle })
-                    .title).toBe('iban');
-            });
-        });
-    });
-    describe('descriptions', function () {
-        var defaultDescription = 'default description';
-        describe('const schemas', function () {
-            var constSchema = {
-                const: 'const',
-            };
-            var constSchemaWithDescription = __assign(__assign({}, constSchema), { summary: {
-                    providesDescription: true,
-                } });
-            var constSchemaWithDescriptionProp = __assign(__assign({}, constSchemaWithDescription), { title: 'title' });
-            it('should return the default if the schema does not provide a description', function () {
-                expect(getItemSummaryFromSchema(constSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-                expect(getItemSummaryFromSchema(constSchema, 'const', { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-            });
-            it('should return the const if the schema provides a description', function () {
-                expect(getItemSummaryFromSchema(constSchemaWithDescription, null, { defaultDescription: defaultDescription })
-                    .description).toBe('const');
-                expect(getItemSummaryFromSchema(constSchemaWithDescription, 'const', { defaultDescription: defaultDescription })
-                    .description).toBe('const');
-            });
-            it('should prefer the title prop over the const value', function () {
-                expect(getItemSummaryFromSchema(constSchemaWithDescriptionProp, 'const', { defaultDescription: defaultDescription })
-                    .description).toBe('title');
-            });
-        });
-        describe('basic schemas', function () {
-            var basicSchema = {
-                type: 'string',
-                title: 'basic schema',
-            };
-            var basicSchemaWithDescription = __assign(__assign({}, basicSchema), { summary: {
-                    providesDescription: true,
-                } });
-            it('should return the default if the schema does not provide a description', function () {
-                expect(getItemSummaryFromSchema(basicSchema, 'value', { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-                expect(getItemSummaryFromSchema(basicSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-            });
-            it('should return the default if the schema provides a description but the model is null', function () {
-                expect(getItemSummaryFromSchema(basicSchemaWithDescription, null, { defaultDescription: defaultDescription })
-                    .description).toBe(defaultDescription);
-            });
-            it('should return the model if the schema provides a description and the model is valued', function () {
-                expect(getItemSummaryFromSchema(basicSchemaWithDescription, 'value', { defaultDescription: defaultDescription })
-                    .description).toBe('value');
-            });
-        });
-        describe('object schemas', function () {
-            var objectSchema = {
-                type: 'object',
-                displayOrder: ['name'],
-                properties: {
-                    name: {
-                        title: 'Name',
-                        type: 'string',
-                    },
-                },
-            };
-            var objectSchemaWithDescription = __assign(__assign({}, objectSchema), { summary: {
-                    providesDescription: true,
-                } });
-            var objectSchemaWithDescriptionInChild = {
-                type: 'object',
-                displayOrder: ['age', 'name'],
-                properties: {
-                    name: {
-                        title: 'Name',
-                        type: 'string',
-                        summary: {
-                            providesDescription: true,
-                        },
-                    },
-                    age: {
-                        title: 'Age',
-                        type: 'string',
-                    },
-                },
-            };
-            it('should return the default if the schema does not provide a description', function () {
-                expect(getItemSummaryFromSchema(objectSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-                expect(getItemSummaryFromSchema(objectSchema, { name: 'name' }, { defaultDescription: defaultDescription })
-                    .description).toBe(defaultDescription);
-            });
-            it('should return the default if schema provides a description but the model is not a string', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithDescription, { name: 'name' }, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-            });
-            it('should return the default if a child schema provides a description but the model is null', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithDescriptionInChild, null, { defaultDescription: defaultDescription })
-                    .description).toBe(defaultDescription);
-            });
-            it('should return the model if a child schema provides a description and the model is valued', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithDescriptionInChild, { name: 'name' })
-                    .description).toBe('name');
-            });
-        });
-        describe('oneOf schemas', function () {
-            var oneOfSchema = {
-                oneOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            var oneOfSchemaWithDescription = __assign(__assign({}, oneOfSchema), { summary: {
-                    providesDescription: true,
-                } });
-            var oneOfSchemaWithDescriptionOnChildSchema = {
-                oneOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                                summary: {
-                                    providesDescription: true,
-                                },
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            it('should return the default if the schema does not provide a description', function () {
-                expect(getItemSummaryFromSchema(oneOfSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-            });
-            it('should return the default if the schema does not provide a description, even if the model is valued', function () {
-                expect(getItemSummaryFromSchema(oneOfSchema, { iban: 'iban' }, { defaultDescription: defaultDescription })
-                    .description).toBe(defaultDescription);
-            });
-            it('should return the default if a child schema provides a description but the model is null', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithDescriptionOnChildSchema, null, {
-                    defaultDescription: defaultDescription,
-                }).description).toBe(defaultDescription);
-            });
-            it('should return the model if a child schema provides a description and the model is valued', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithDescriptionOnChildSchema, {
-                    iban: 'iban',
-                }, { defaultDescription: defaultDescription }).description).toBe('iban');
-            });
-            it('should return the default if schema provides a description but the model is not a string', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithDescription, { iban: 'iban' }, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-            });
-        });
-        describe('allOf schemas', function () {
-            var allOfSchema = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            var allOfSchemaWithDescription = __assign(__assign({}, allOfSchema), { summary: {
-                    providesDescription: true,
-                } });
-            var allOfSchemaWithDescriptionOnChild = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                                summary: {
-                                    providesDescription: true,
-                                },
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            it('should return the default if the schema does not provide a description', function () {
-                expect(getItemSummaryFromSchema(allOfSchema, null, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-                expect(getItemSummaryFromSchema(allOfSchema, { iban: 'iban' }, { defaultDescription: defaultDescription })
-                    .description).toBe(defaultDescription);
-            });
-            it('should return the default if schema provides a description but the model is not a string', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithDescription, { iban: 'iban' }, { defaultDescription: defaultDescription }).description).toBe(defaultDescription);
-            });
-            it('should return the default if a child schema provides a description but the model is null', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithDescriptionOnChild, null, { defaultDescription: defaultDescription })
-                    .description).toBe(defaultDescription);
-            });
-            it('should return the model if a child schema provides a description and the model is valued', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithDescriptionOnChild, { iban: 'iban' }, { defaultDescription: defaultDescription }).description).toBe('iban');
-            });
-        });
-    });
-    describe('icons', function () {
-        var icon = {
-            name: 'plus',
-        };
-        var defaultIcon = {
-            name: 'default',
-        };
-        describe('const schemas', function () {
-            var constSchema = {
-                const: 'const',
-            };
-            var constSchemaWithIcon = __assign(__assign({}, constSchema), { icon: icon, summary: {
-                    providesIcon: true,
-                } });
-            it('should return the default if the schema does not provide an icon', function () {
-                expect(getItemSummaryFromSchema(constSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-            });
-            it('should return icon if the schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(constSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
-                expect(getItemSummaryFromSchema(constSchemaWithIcon, 'const', { defaultIcon: defaultIcon }).icon).toBe(icon);
-            });
-        });
-        describe('basic schemas', function () {
-            var basicSchema = {
-                type: 'string',
-                title: 'basic schema',
-            };
-            var basicSchemaWithIcon = __assign(__assign({}, basicSchema), { icon: icon, summary: {
-                    providesIcon: true,
-                } });
-            it('should return the default if the schema does not provide an icon', function () {
-                expect(getItemSummaryFromSchema(basicSchema, 'value', { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-                expect(getItemSummaryFromSchema(basicSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-            });
-            it('should return icon if the schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(basicSchemaWithIcon, 'value', { defaultIcon: defaultIcon }).icon).toBe(icon);
-                expect(getItemSummaryFromSchema(basicSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
-            });
-        });
-        describe('object schemas', function () {
-            var objectSchema = {
-                type: 'object',
-                displayOrder: ['name'],
-                properties: {
-                    name: {
-                        title: 'Name',
-                        type: 'string',
-                    },
-                },
-            };
-            var objectSchemaWithIcon = __assign(__assign({}, objectSchema), { icon: icon, summary: {
-                    providesIcon: true,
-                } });
-            var objectSchemaWithIconInChild = {
-                type: 'object',
-                displayOrder: ['age', 'name'],
-                properties: {
-                    name: {
-                        title: 'Name',
-                        type: 'string',
-                        icon: icon,
-                        summary: {
-                            providesIcon: true,
-                        },
-                    },
-                    age: {
-                        title: 'Age',
-                        type: 'string',
-                    },
-                },
-            };
-            it('should return the default if the schema does not provide an icon', function () {
-                expect(getItemSummaryFromSchema(objectSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-                expect(getItemSummaryFromSchema(objectSchema, { name: 'name' }, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-            });
-            it('should return icon if schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithIcon, { name: 'name' }, { defaultIcon: defaultIcon }).icon).toBe(icon);
-                expect(getItemSummaryFromSchema(objectSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
-            });
-            it('should return icon if a child schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithIconInChild, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
-                expect(getItemSummaryFromSchema(objectSchemaWithIconInChild, { name: 'name' }, { defaultIcon: defaultIcon })
-                    .icon).toBe(icon);
-            });
-        });
-        describe('oneOf schemas', function () {
-            var oneOfSchema = {
-                oneOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            var oneOfSchemaWithIcon = __assign(__assign({}, oneOfSchema), { icon: icon, summary: {
-                    providesIcon: true,
-                } });
-            var oneOfSchemaWithIconOnChildSchema = {
-                oneOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                                icon: icon,
-                                summary: {
-                                    providesIcon: true,
-                                },
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            it('should return the default if the schema does not provide an icon', function () {
-                expect(getItemSummaryFromSchema(oneOfSchema, { iban: 'iban' }, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-                expect(getItemSummaryFromSchema(oneOfSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-            });
-            it('should return icon schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
-            });
-            it('should return icon if active child schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithIconOnChildSchema, {
-                    iban: 'iban',
-                }, { defaultIcon: defaultIcon }).icon).toBe(icon);
-            });
-            it('should return the default if non-active child schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithIconOnChildSchema, {
-                    accountNumber: 'accountNumber',
-                }, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-            });
-        });
-        describe('allOf schemas', function () {
-            var allOfSchema = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            var allOfSchemaWithIcon = __assign(__assign({}, allOfSchema), { icon: icon, summary: {
-                    providesIcon: true,
-                } });
-            var allOfSchemaWithIconOnChild = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                                icon: icon,
-                                summary: {
-                                    providesIcon: true,
-                                },
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            it('should return the default if the schema does not provide an icon', function () {
-                expect(getItemSummaryFromSchema(allOfSchema, null, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-                expect(getItemSummaryFromSchema(allOfSchema, { iban: 'iban' }, { defaultIcon: defaultIcon }).icon).toBe(defaultIcon);
-            });
-            it('should icon if schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithIcon, null, { defaultIcon: defaultIcon }).icon).toBe(icon);
-            });
-            it('should return icon if a child schema provides an icon', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithIconOnChild, { iban: 'iban' }, { defaultIcon: defaultIcon })
-                    .icon).toBe(icon);
-            });
-        });
-    });
-    describe('images', function () {
-        var image = {
-            url: '/cat.jpg',
-        };
-        var defaultImage = {
-            url: '/default.jpg',
-        };
-        describe('const schemas', function () {
-            var constSchema = {
-                const: 'const',
-            };
-            var constSchemaWithImage = __assign(__assign({}, constSchema), { image: image, summary: {
-                    providesImage: true,
-                } });
-            it('should return the default if the schema does not provide an image', function () {
-                expect(getItemSummaryFromSchema(constSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
-            });
-            it('should return image if the schema provides an image', function () {
-                expect(getItemSummaryFromSchema(constSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
-                expect(getItemSummaryFromSchema(constSchemaWithImage, 'const', { defaultImage: defaultImage }).image).toBe(image);
-            });
-        });
-        describe('basic schemas', function () {
-            var basicSchema = {
-                type: 'string',
-                title: 'basic schema',
-            };
-            var basicSchemaWithImage = __assign(__assign({}, basicSchema), { image: image, summary: {
-                    providesImage: true,
-                } });
-            it('should return the default if the schema does not provide an image', function () {
-                expect(getItemSummaryFromSchema(basicSchema, 'value', { defaultImage: defaultImage }).image).toBe(defaultImage);
-                expect(getItemSummaryFromSchema(basicSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
-            });
-            it('should return image if the schema provides an image', function () {
-                expect(getItemSummaryFromSchema(basicSchemaWithImage, 'value', { defaultImage: defaultImage }).image).toBe(image);
-                expect(getItemSummaryFromSchema(basicSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
-            });
-        });
-        describe('object schemas', function () {
-            var objectSchema = {
-                type: 'object',
-                displayOrder: ['name'],
-                properties: {
-                    name: {
-                        title: 'Name',
-                        type: 'string',
-                    },
-                },
-            };
-            var objectSchemaWithImage = __assign(__assign({}, objectSchema), { image: image, summary: {
-                    providesImage: true,
-                } });
-            var objectSchemaWithImageInChild = {
-                type: 'object',
-                displayOrder: ['age', 'name'],
-                properties: {
-                    name: {
-                        title: 'Name',
-                        type: 'string',
-                        image: image,
-                        summary: {
-                            providesImage: true,
-                        },
-                    },
-                    age: {
-                        title: 'Age',
-                        type: 'string',
-                    },
-                },
-            };
-            it('should return the default if the schema does not provide an image', function () {
-                expect(getItemSummaryFromSchema(objectSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
-                expect(getItemSummaryFromSchema(objectSchema, { name: 'name' }, { defaultImage: defaultImage }).image).toBe(defaultImage);
-            });
-            it('should return image if schema provides an image', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithImage, { name: 'name' }, { defaultImage: defaultImage }).image).toBe(image);
-                expect(getItemSummaryFromSchema(objectSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
-            });
-            it('should return image if a child schema provides an image', function () {
-                expect(getItemSummaryFromSchema(objectSchemaWithImageInChild, null, { defaultImage: defaultImage }).image).toBe(image);
-                expect(getItemSummaryFromSchema(objectSchemaWithImageInChild, { name: 'name' }, { defaultImage: defaultImage })
-                    .image).toBe(image);
-            });
-        });
-        describe('oneOf schemas', function () {
-            var oneOfSchema = {
-                oneOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            var oneOfSchemaWithImage = __assign(__assign({}, oneOfSchema), { image: image, summary: {
-                    providesImage: true,
-                } });
-            var oneOfSchemaWithImageOnChildSchema = {
-                oneOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                                image: image,
-                                summary: {
-                                    providesImage: true,
-                                },
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            it('should return the default if the schema does not provide an image', function () {
-                expect(getItemSummaryFromSchema(oneOfSchema, { iban: 'iban' }, { defaultImage: defaultImage }).image).toBe(defaultImage);
-                expect(getItemSummaryFromSchema(oneOfSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
-            });
-            it('should return image schema provides an image', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
-            });
-            it('should return image if active child schema provides an image', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithImageOnChildSchema, {
-                    iban: 'iban',
-                }, { defaultImage: defaultImage }).image).toBe(image);
-            });
-            it('should return the default if non-active child schema provides an image', function () {
-                expect(getItemSummaryFromSchema(oneOfSchemaWithImageOnChildSchema, {
-                    accountNumber: 'accountNumber',
-                }, { defaultImage: defaultImage }).image).toBe(defaultImage);
-            });
-        });
-        describe('allOf schemas', function () {
-            var allOfSchema = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            var allOfSchemaWithImage = __assign(__assign({}, allOfSchema), { image: image, summary: {
-                    providesImage: true,
-                } });
-            var allOfSchemaWithImageOnChild = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            accountNumber: {
-                                type: 'string',
-                            },
-                        },
-                        displayOrder: ['accountNumber'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            iban: {
-                                type: 'string',
-                                image: image,
-                                summary: {
-                                    providesImage: true,
-                                },
-                            },
-                        },
-                        displayOrder: ['iban'],
-                    },
-                ],
-            };
-            it('should return the default if the schema does not provide an image', function () {
-                expect(getItemSummaryFromSchema(allOfSchema, null, { defaultImage: defaultImage }).image).toBe(defaultImage);
-                expect(getItemSummaryFromSchema(allOfSchema, { iban: 'iban' }, { defaultImage: defaultImage }).image).toBe(defaultImage);
-            });
-            it('should image if schema provides an image', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithImage, null, { defaultImage: defaultImage }).image).toBe(image);
-            });
-            it('should return image if a child schema provides an image', function () {
-                expect(getItemSummaryFromSchema(allOfSchemaWithImageOnChild, { iban: 'iban' }, { defaultImage: defaultImage })
-                    .image).toBe(image);
-            });
-        });
-    });
-});