@appsemble/utils 0.30.14-test.6 → 0.32.1-test.14

package/jsonschema.test.js

@@ -1,256 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { combineSchemas, generateDataFromSchema, iterJSONSchema } from './jsonschema.js';
-describe('generateDataFromSchema', () => {
-    it('should not crash if no schema is defined', () => {
-        const result = generateDataFromSchema();
-        expect(result).toBeUndefined();
-    });
-    it('should return the default value', () => {
-        const result = generateDataFromSchema({ type: 'string', default: 'pear' });
-        expect(result).toBe('pear');
-    });
-    describe('array', () => {
-        it('should return an empty array', () => {
-            const result = generateDataFromSchema({ type: 'array' });
-            expect(result).toStrictEqual([]);
-        });
-        it('should fill the array up to minItems', () => {
-            const result = generateDataFromSchema({
-                type: 'array',
-                minItems: 3,
-                items: { type: 'string' },
-            });
-            expect(result).toStrictEqual(['', '', '']);
-        });
-        it('should use indexed array items if it’s an array', () => {
-            const result = generateDataFromSchema({
-                type: 'array',
-                minItems: 3,
-                items: [{ type: 'boolean' }, { type: 'number' }, { type: 'string' }],
-            });
-            expect(result).toStrictEqual([false, 0, '']);
-        });
-        it('should use use additionalItems if the array length', () => {
-            const result = generateDataFromSchema({
-                type: 'array',
-                minItems: 3,
-                items: [{ type: 'boolean' }],
-                additionalItems: { type: 'string' },
-            });
-            expect(result).toStrictEqual([false, '', '']);
-        });
-    });
-    describe('boolean', () => {
-        it('should return false', () => {
-            const result = generateDataFromSchema({ type: 'boolean' });
-            expect(result).toBe(false);
-        });
-    });
-    describe('integer / number', () => {
-        it('should return 0', () => {
-            const result = generateDataFromSchema({ type: 'number' });
-            expect(result).toBe(0);
-        });
-        it('should respect the minimum value', () => {
-            const result = generateDataFromSchema({ type: 'number', minimum: 5 });
-            expect(result).toBe(5);
-        });
-        it('should respect the maximum value', () => {
-            const result = generateDataFromSchema({ type: 'number', maximum: -5 });
-            expect(result).toBe(-5);
-        });
-        it('should respect the combination of multipleOf and minimum', () => {
-            const result = generateDataFromSchema({ type: 'number', minimum: 5, multipleOf: 3 });
-            expect(result).toBe(6);
-        });
-        it('should respect the combination of multipleOf and maximum', () => {
-            const result = generateDataFromSchema({ type: 'number', maximum: -5, multipleOf: 3 });
-            expect(result).toBe(-6);
-        });
-    });
-    describe('null', () => {
-        it('should return null', () => {
-            const result = generateDataFromSchema({ type: 'null' });
-            expect(result).toBeNull();
-        });
-    });
-    describe('string', () => {
-        it('should return an empty string', () => {
-            const result = generateDataFromSchema({ type: 'string' });
-            expect(result).toBe('');
-        });
-    });
-    describe('object', () => {
-        it('should recursively create an object', () => {
-            const result = generateDataFromSchema({
-                type: 'object',
-                properties: { bool: { type: 'boolean' }, num: { type: 'number' }, str: { type: 'string' } },
-            });
-            expect(result).toStrictEqual({ bool: false, num: 0, str: '' });
-        });
-    });
-});
-describe('combineSchemas', () => {
-    it('should use the first type found', () => {
-        const result = combineSchemas({ type: 'number' }, { type: 'string' });
-        expect(result).toStrictEqual({ type: 'number' });
-    });
-    it('should use the first format found', () => {
-        const result = combineSchemas({ format: 'email' }, { format: 'uuid' });
-        expect(result).toStrictEqual({ format: 'email' });
-    });
-    it('should determine the minimum', () => {
-        const result = combineSchemas({}, { minimum: 3 }, { minimum: 1 }, { minimum: 2 }, {});
-        expect(result).toStrictEqual({ minimum: 3 });
-    });
-    it('should determine the min length', () => {
-        const result = combineSchemas({}, { minLength: 3 }, { minLength: 1 }, { minLength: 2 }, {});
-        expect(result).toStrictEqual({ minLength: 3 });
-    });
-    it('should determine the maximum', () => {
-        const result = combineSchemas({}, { maximum: 3 }, { maximum: 1 }, { maximum: 2 }, {});
-        expect(result).toStrictEqual({ maximum: 1 });
-    });
-    it('should determine the max length', () => {
-        const result = combineSchemas({}, { maxLength: 3 }, { maxLength: 1 }, { maxLength: 2 }, {});
-        expect(result).toStrictEqual({ maxLength: 1 });
-    });
-    it('should use the least common multiple for multipleOf', () => {
-        const result = combineSchemas({}, { multipleOf: 0 }, { multipleOf: 6 }, { multipleOf: 8 }, {});
-        expect(result).toStrictEqual({ multipleOf: 24 });
-    });
-    it('should assign the first non-nullish default', () => {
-        const result = combineSchemas({}, { default: null }, { default: 'a' }, { default: 'b' }, {});
-        expect(result).toStrictEqual({ default: 'a' });
-    });
-    it('should use the first truthy description', () => {
-        const result = combineSchemas({}, { description: '' }, { description: 'Hi' }, { description: 'Bye' }, {});
-        expect(result).toStrictEqual({ description: 'Hi' });
-    });
-    it('should use the first truthy title', () => {
-        const result = combineSchemas({}, { title: '' }, { title: 'Hi' }, { title: 'Bye' }, {});
-        expect(result).toStrictEqual({ title: 'Hi' });
-    });
-    it('should set uniqueItems to true if any schema requires this', () => {
-        const result = combineSchemas({}, { uniqueItems: false }, { uniqueItems: true }, {});
-        expect(result).toStrictEqual({ uniqueItems: true });
-    });
-    it('should merge required arrays', () => {
-        const result = combineSchemas({}, { required: ['foo'] }, { required: ['bar'] }, {});
-        expect(result).toStrictEqual({ required: ['foo', 'bar'] });
-    });
-    it('should assign required if it’s true', () => {
-        const result = combineSchemas({}, { required: true }, { required: false }, {});
-        expect(result).toStrictEqual({ required: true });
-    });
-    it('should merge properties', () => {
-        const result = combineSchemas({}, { properties: { foo: { type: 'string' } } }, { properties: { bar: { type: 'number' } } }, { properties: { foo: { title: 'Foo' }, bar: { title: 'Bar' } } }, { required: ['foo', 'bar'] }, {});
-        expect(result).toStrictEqual({
-            required: ['foo', 'bar'],
-            properties: {
-                foo: {
-                    title: 'Foo',
-                    type: 'string',
-                },
-                bar: {
-                    title: 'Bar',
-                    type: 'number',
-                },
-            },
-        });
-    });
-});
-describe('iterJSONSchema', () => {
-    it('should handle properties', () => {
-        const onSchema = vi.fn();
-        const schema = {
-            type: 'object',
-            properties: {
-                foo: { description: 'foo' },
-            },
-        };
-        iterJSONSchema(schema, onSchema);
-        expect(onSchema).toHaveBeenCalledTimes(2);
-        expect(onSchema).toHaveBeenCalledWith(schema);
-        expect(onSchema).toHaveBeenCalledWith(schema.properties.foo);
-    });
-    it('should handle additionalProperties', () => {
-        const onSchema = vi.fn();
-        const schema = {
-            type: 'object',
-            additionalProperties: { description: 'foo' },
-        };
-        iterJSONSchema(schema, onSchema);
-        expect(onSchema).toHaveBeenCalledTimes(2);
-        expect(onSchema).toHaveBeenCalledWith(schema);
-        expect(onSchema).toHaveBeenCalledWith(schema.additionalProperties);
-    });
-    it('should handle an items object', () => {
-        const onSchema = vi.fn();
-        const schema = {
-            type: 'array',
-            items: { description: 'foo' },
-        };
-        iterJSONSchema(schema, onSchema);
-        expect(onSchema).toHaveBeenCalledTimes(2);
-        expect(onSchema).toHaveBeenCalledWith(schema);
-        expect(onSchema).toHaveBeenCalledWith(schema.items);
-    });
-    it('should handle an items array', () => {
-        const onSchema = vi.fn();
-        const schema = {
-            type: 'array',
-            items: [{ description: 'foo' }, { description: 'bar' }],
-        };
-        iterJSONSchema(schema, onSchema);
-        expect(onSchema).toHaveBeenCalledTimes(3);
-        expect(onSchema).toHaveBeenCalledWith(schema);
-        expect(onSchema).toHaveBeenCalledWith(schema.items[0]);
-        expect(onSchema).toHaveBeenCalledWith(schema.items[1]);
-    });
-    it('should handle additionalItems', () => {
-        const onSchema = vi.fn();
-        const schema = {
-            type: 'array',
-            additionalItems: { description: 'foo' },
-        };
-        iterJSONSchema(schema, onSchema);
-        expect(onSchema).toHaveBeenCalledTimes(2);
-        expect(onSchema).toHaveBeenCalledWith(schema);
-        expect(onSchema).toHaveBeenCalledWith(schema.additionalItems);
-    });
-    it('should handle anyOf', () => {
-        const onSchema = vi.fn();
-        const schema = {
-            type: 'array',
-            anyOf: [{ description: 'foo' }],
-        };
-        iterJSONSchema(schema, onSchema);
-        expect(onSchema).toHaveBeenCalledTimes(2);
-        expect(onSchema).toHaveBeenCalledWith(schema);
-        expect(onSchema).toHaveBeenCalledWith(schema.anyOf[0]);
-    });
-    it('should handle oneOf', () => {
-        const onSchema = vi.fn();
-        const schema = {
-            type: 'array',
-            oneOf: [{ description: 'foo' }],
-        };
-        iterJSONSchema(schema, onSchema);
-        expect(onSchema).toHaveBeenCalledTimes(2);
-        expect(onSchema).toHaveBeenCalledWith(schema);
-        expect(onSchema).toHaveBeenCalledWith(schema.oneOf[0]);
-    });
-    it('should handle allOf', () => {
-        const onSchema = vi.fn();
-        const schema = {
-            type: 'array',
-            allOf: [{ description: 'foo' }],
-        };
-        iterJSONSchema(schema, onSchema);
-        expect(onSchema).toHaveBeenCalledTimes(2);
-        expect(onSchema).toHaveBeenCalledWith(schema);
-        expect(onSchema).toHaveBeenCalledWith(schema.allOf[0]);
-    });
-});
-//# sourceMappingURL=jsonschema.test.js.map

package/mapValues.test.d.ts

@@ -1 +0,0 @@
-export {};

package/mapValues.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { mapValues } from './mapValues.js';
-describe('mapValues', () => {
-    it('should call the iteratee over each own property', () => {
-        const proto = {
-            nope: 'Discard me',
-        };
-        const data = Object.create(proto);
-        data.yep = 'Overwrite me.';
-        const result = mapValues(data, (value) => `${value} Done.`);
-        expect(result).toStrictEqual({
-            yep: 'Overwrite me. Done.',
-        });
-    });
-});
-//# sourceMappingURL=mapValues.test.js.map

package/miscellaneous.test.d.ts

@@ -1 +0,0 @@
-export {};

package/miscellaneous.test.js

@@ -1,87 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { identity, rethrow, stripNullValues } from './miscellaneous.js';
-/**
- * Return the input data.
- *
- * @param data The data to return.
- * @returns The input data.
- */
-describe('identity', () => {
-    it('should return the input data', () => {
-        const input = {};
-        expect(identity(input)).toBe(input);
-    });
-});
-/**
- * Throw the input data.
- *
- * @param data The data to throw.
- * @throws The input data.
- */
-describe('rethrow', () => {
-    it('should throw the input data', () => {
-        expect(() => rethrow('Test')).toThrow('Test');
-    });
-});
-describe('stripNullValues', () => {
-    it('should convert null to undefined', () => {
-        const input = null;
-        expect(stripNullValues(input)).toBeUndefined();
-    });
-    it('should return raw primitives', () => {
-        const input = 42;
-        expect(stripNullValues(input)).toBe(42);
-    });
-    it('should remove empty, undefined, and null from arrays', () => {
-        const input = [, undefined, null];
-        expect(stripNullValues(input)).toStrictEqual([]);
-    });
-    it('should not remove Blob values', () => {
-        const blob = new Blob([], { type: 'image/jpeg' });
-        const input = {
-            foo: null,
-            bar: blob,
-            baz: 'hello',
-        };
-        expect(stripNullValues(input)).toStrictEqual({
-            bar: blob,
-            baz: 'hello',
-        });
-    });
-    it('should remove undefined, and null values from objects', () => {
-        const input = {
-            foo: null,
-            bar: undefined,
-            baz: 42,
-        };
-        expect(stripNullValues(input)).toStrictEqual({ baz: 42 });
-    });
-    it('should remove empty, undefined, and null values recursively', () => {
-        const input = {
-            foo: {
-                bar: {
-                    fooz: null,
-                    baz: [, undefined, null],
-                },
-            },
-        };
-        expect(stripNullValues(input)).toStrictEqual({ foo: { bar: { baz: [] } } });
-    });
-    it('should respect depth for objects', () => {
-        const input = {
-            foo: {
-                bar: {
-                    asd: null,
-                },
-                baz: null,
-            },
-            fooz: null,
-        };
-        expect(stripNullValues(input, { depth: 2 })).toStrictEqual({ foo: { bar: { asd: null } } });
-    });
-    it('should respect depth for arrays', () => {
-        const input = [null, [null, [null]]];
-        expect(stripNullValues(input, { depth: 2 })).toStrictEqual([[[null]]]);
-    });
-});
-//# sourceMappingURL=miscellaneous.test.js.map

package/normalize.test.d.ts

@@ -1 +0,0 @@
-export {};

package/normalize.test.js

@@ -1,23 +0,0 @@
-import { expect, it } from 'vitest';
-import { normalize } from './normalize.js';
-const fixtures = [
-    ['Foo', 'foo'],
-    ['A somewhat long sentence.', 'a-somewhat-long-sentence'],
-    ['Ĺòt’s øf wəìŕð ćĥâṙąçṫœ®ş', 'lot-s-f-w-ir-charact-s'],
-    ['I___contain_underscores', 'i-contain-underscores'],
-    ['many----hyphens', 'many-hyphens'],
-    ['includes.dot', 'includes-dot'],
-    ['trailing-hyphen-', 'trailing-hyphen'],
-    ['0123456789 digits', '0123456789-digits'],
-    ['-leading-hyphen', 'leading-hyphen'],
-    ['*-multiple-leading-non-word-characters', 'multiple-leading-non-word-characters'],
-];
-it.each(fixtures)('should turn “%s” into “%s”', (actual, expected) => {
-    const result = normalize(actual);
-    expect(result).toBe(expected);
-});
-it('should have an option to not support a trailing hyphen', () => {
-    const result = normalize('trailing-hyphen-', false);
-    expect(result).toBe('trailing-hyphen-');
-});
-//# sourceMappingURL=normalize.test.js.map

package/objectCache.test.d.ts

@@ -1 +0,0 @@
-export {};

package/objectCache.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { objectCache } from './objectCache.js';
-describe('objectCache', () => {
-    it('should cache results', () => {
-        let count = 0;
-        const cache = objectCache((id) => {
-            count += 1;
-            return { id, count };
-        });
-        const a = cache('a');
-        expect(a).toStrictEqual({ id: 'a', count: 1 });
-        const b = cache('b');
-        expect(b).toStrictEqual({ id: 'b', count: 2 });
-        expect(b).not.toBe(a);
-        const c = cache('a');
-        expect(c).toStrictEqual({ id: 'a', count: 1 });
-        expect(c).toBe(a);
-    });
-});
-//# sourceMappingURL=objectCache.test.js.map

package/prefix.test.d.ts

@@ -1 +0,0 @@
-export {};

package/prefix.test.js

@@ -1,11 +0,0 @@
-import { expect, it } from 'vitest';
-import { prefix } from './prefix.js';
-it('should prefix a string if the prefix is truthy', () => {
-    const result = prefix('bar', 'foo');
-    expect(result).toBe('foobar');
-});
-it('should not prefix a string if the prefix is falsy', () => {
-    const result = prefix('bar', null);
-    expect(result).toBe('bar');
-});
-//# sourceMappingURL=prefix.test.js.map

package/remap.test.d.ts

@@ -1 +0,0 @@
-export {};