@awesomeness-js/utils 1.0.24 → 1.1.2

package/tests/clean/array.test.js

@@ -1,154 +1,202 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../../index.js';
 
 const testStringArray = [ 'a', 'b', 'c' ];
 const testIntegerArray = [ 1, 2, 3, 4, 5 ];
-const testBooleanArray = [true, false, true, false];
+const testBooleanArray = [ true, false, true, false ];
 
 const testArrayOfArraysOfIntegers = [
-    testIntegerArray,
-    testIntegerArray,
-    testIntegerArray
+	testIntegerArray,
+	testIntegerArray,
+	testIntegerArray
 ];
 
 const testArrayOfArraysOfStrings = [
-    testStringArray,
-    testStringArray,
-    testStringArray
+	testStringArray,
+	testStringArray,
+	testStringArray
 ];
 
 const schemaForStrings = {
-    type: 'array',
-    items: {
-        type: 'string'
-    }
+	type: 'array',
+	items: {
+		type: 'string'
+	}
 };
 
 const schemaForIntegers = {
-    type: 'array',
-    items: {
-        type: 'integer'
-    }
+	type: 'array',
+	items: {
+		type: 'integer'
+	}
 };
 
 
 const schemaForBooleans = {
-    type: 'array',
-    items: {
-        type: 'boolean'
-    }
+	type: 'array',
+	items: {
+		type: 'boolean'
+	}
 };
 
 const schemaForArrayOfArrays_integers = {
-    type: 'array',
-    items: {
-        type: 'array',
-        items: { type: 'integer' }
-    }
+	type: 'array',
+	items: {
+		type: 'array',
+		items: { type: 'integer' }
+	}
 };
 
 const schemaForArrayOfArrays_strings = {
-    type: 'array',
-    items: {
-        type: 'array',
-        items: { type: 'string' }
-    }
+	type: 'array',
+	items: {
+		type: 'array',
+		items: { type: 'string' }
+	}
 };
 
 const testObject = {
-    stringProp: 'a string',
-    integerProp: 42,
-    numberProp: 3.14,
-    booleanProp: true,
-    timestampProp: new Date().toISOString(),
-    uuidProp: utils.uuid(), // generate a valid UUID
+	stringProp: 'a string',
+	integerProp: 42,
+	numberProp: 3.14,
+	booleanProp: true,
+	timestampProp: new Date().toISOString(),
+	uuidProp: utils.uuid(), // generate a valid UUID
 };
 
 const arrayOfObjects = [
-    { ...testObject },
-    { ...testObject },
-    { ...testObject }
+	{ ...testObject },
+	{ ...testObject },
+	{ ...testObject }
 ];
 
 const objSchema = {
-    type: 'object',
-    properties: {
-        stringProp: { type: 'string', required: true },
-        integerProp: { type: 'integer', required: true },
-        numberProp: { type: 'number', required: true },
-        booleanProp: { type: 'boolean', required: true },
-        timestampProp: { type: 'timestamp', required: true },
-        uuidProp: { type: 'uuid', required: true },
-        optionalStringProp: { type: 'string', required: false },
-        optionalIntegerProp: { type: 'integer', required: false },
-        optionalNumberProp: { type: 'number', required: false },
-        optionalBooleanProp: { type: 'boolean', required: false },
-        optionalTimestampProp: { type: 'timestamp', required: false },
-        optionalUuidProp: { type: 'uuid', required: false }
-    },
+	type: 'object',
+	properties: {
+		stringProp: {
+			type: 'string',
+			required: true 
+		},
+		integerProp: {
+			type: 'integer',
+			required: true 
+		},
+		numberProp: {
+			type: 'number',
+			required: true 
+		},
+		booleanProp: {
+			type: 'boolean',
+			required: true 
+		},
+		timestampProp: {
+			type: 'timestamp',
+			required: true 
+		},
+		uuidProp: {
+			type: 'uuid',
+			required: true 
+		},
+		optionalStringProp: {
+			type: 'string',
+			required: false 
+		},
+		optionalIntegerProp: {
+			type: 'integer',
+			required: false 
+		},
+		optionalNumberProp: {
+			type: 'number',
+			required: false 
+		},
+		optionalBooleanProp: {
+			type: 'boolean',
+			required: false 
+		},
+		optionalTimestampProp: {
+			type: 'timestamp',
+			required: false 
+		},
+		optionalUuidProp: {
+			type: 'uuid',
+			required: false 
+		}
+	},
 };
 
 
 const schemaForArrayOfObjects = {
-    type: 'array',
-    required: true,
-    items: {
-        ... objSchema,
-    }
+	type: 'array',
+	required: true,
+	items: {
+		... objSchema,
+	}
 };
 
 test('testStringArray', () => {
 
-    const x = utils.clean.array(testStringArray, schemaForStrings);
-    expect(x).toStrictEqual(testStringArray);
+	const x = utils.clean.array(testStringArray, schemaForStrings);
+
+	expect(x).toStrictEqual(testStringArray);
 
 });
 
 test('testIntegerArray', () => {
 
-    const x = utils.clean.array(testIntegerArray, schemaForIntegers);
-    expect(x).toStrictEqual(testIntegerArray);
+	const x = utils.clean.array(testIntegerArray, schemaForIntegers);
+
+	expect(x).toStrictEqual(testIntegerArray);
 
 });
 
 test('testBooleanArray', () => {
 
-    const x = utils.clean.array(testBooleanArray, schemaForBooleans);
-    expect(x).toStrictEqual(testBooleanArray);
+	const x = utils.clean.array(testBooleanArray, schemaForBooleans);
+
+	expect(x).toStrictEqual(testBooleanArray);
 
 });
 
 test('testBooleanArray but pass different schema', () => {
 
-    expect(()=> utils.clean.array(testBooleanArray, { ... schemaForIntegers, required: true }) ).toThrow();
+	expect(()=> utils.clean.array(testBooleanArray, {
+		... schemaForIntegers,
+		required: true 
+	}) ).toThrow();
 
 });
 
 test('schemaForArrayOfArrays_integers', () => {
 
-    const x = utils.clean.array(testArrayOfArraysOfIntegers, schemaForArrayOfArrays_integers);
-    expect(x).toStrictEqual(testArrayOfArraysOfIntegers);
+	const x = utils.clean.array(testArrayOfArraysOfIntegers, schemaForArrayOfArrays_integers);
+
+	expect(x).toStrictEqual(testArrayOfArraysOfIntegers);
 
 });
 
 test('schemaForArrayOfArrays_strings', () => {
 
-    const x = utils.clean.array(testArrayOfArraysOfStrings, schemaForArrayOfArrays_strings);
-    expect(x).toStrictEqual(testArrayOfArraysOfStrings);
+	const x = utils.clean.array(testArrayOfArraysOfStrings, schemaForArrayOfArrays_strings);
+
+	expect(x).toStrictEqual(testArrayOfArraysOfStrings);
 
 });
 
 test('schemaForArrayOfArrays_strings wrong type', () => {
 
-    const x = utils.clean.array(testArrayOfArraysOfStrings, schemaForArrayOfArrays_integers);
-    expect(x).toBe(null);
+	const x = utils.clean.array(testArrayOfArraysOfStrings, schemaForArrayOfArrays_integers);
+
+	expect(x).toBe(null);
 
 });
 
 test('schemaForArrayOfObjects', () => {
 
-    const x = utils.clean.array(arrayOfObjects, schemaForArrayOfObjects);
-    expect(x).toStrictEqual(arrayOfObjects);   
+	const x = utils.clean.array(arrayOfObjects, schemaForArrayOfObjects);
+
+	expect(x).toStrictEqual(arrayOfObjects);   
 
 });

package/tests/clean/boolean.test.js

@@ -1,5 +1,7 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../../index.js';
 
 let x = true;
@@ -7,21 +9,31 @@ let y = false;
 let z = 1;
 
 test('boolean - true', () => {
-    expect(utils.clean.boolean(x)).toBe(true);
+
+	expect(utils.clean.boolean(x)).toBe(true);
+
 });
 
 test('boolean - false', () => {
-    expect(utils.clean.boolean(y)).toBe(false);
+
+	expect(utils.clean.boolean(y)).toBe(false);
+
 });
 
 test('boolean - number', () => {
-    expect(utils.clean.boolean(z)).toBe(null);
+
+	expect(utils.clean.boolean(z)).toBe(null);
+
 });
 
 test('boolean - NOT to throw', () => {
-    expect(() => utils.clean.boolean(y, { required: true })).not.toThrow();
+
+	expect(() => utils.clean.boolean(y, { required: true })).not.toThrow();
+
 });
 
 test('boolean - to throw', () => {
-    expect(() => utils.clean.boolean(z, { required: true })).toThrow();
+
+	expect(() => utils.clean.boolean(z, { required: true })).toThrow();
+
 });

package/tests/clean/integer.test.js

@@ -1,5 +1,7 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../../index.js';
 
 let x = 1;
@@ -9,31 +11,45 @@ let z2 = '102.45';
 let z3 = 102.45;
 
 test('integer - 1', () => {
-    expect(utils.clean.integer(x)).toBe(1);
+
+	expect(utils.clean.integer(x)).toBe(1);
+
 });
 
 test('integer - null', () => {
-    expect(utils.clean.integer(y)).toBe(null);
+
+	expect(utils.clean.integer(y)).toBe(null);
+
 });
 
 
 test('integer as string - 102', () => {
-    expect(utils.clean.integer(z)).toBe(102);
+
+	expect(utils.clean.integer(z)).toBe(102);
+
 });
 
 test('integer - NOT to throw - 102', () => {
-    expect(() => utils.clean.integer(z, { required: true })).not.toThrow();
+
+	expect(() => utils.clean.integer(z, { required: true })).not.toThrow();
+
 });
 
 test('integer - to throw', () => {
-    expect(() => utils.clean.integer(y, { required: true })).toThrow();
+
+	expect(() => utils.clean.integer(y, { required: true })).toThrow();
+
 });
 
 test('integer - to throw - "102.45"', () => {
-    expect(() => utils.clean.integer(z2, { required: true })).toThrow();
+
+	expect(() => utils.clean.integer(z2, { required: true })).toThrow();
+
 });
 
 test('integer - to throw - 102.45', () => {
-    console.log(utils.clean.integer(z3));
-    expect(() => utils.clean.integer(z3, { required: true })).toThrow();
+
+	console.log(utils.clean.integer(z3));
+	expect(() => utils.clean.integer(z3, { required: true })).toThrow();
+
 });

package/tests/clean/number.test.js

@@ -1,5 +1,7 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../../index.js';
 
 let x = 1;
@@ -9,41 +11,75 @@ let z2 = '102.45';
 let bad = 'bad';
 
 test('number - 1', () => {
-    expect(utils.clean.number(x)).toBe(1);
+
+	expect(utils.clean.number(x)).toBe(1);
+
 });
 
 test('number - 1.2', () => {
-    expect(utils.clean.number(y)).toBe(1.2);
+
+	expect(utils.clean.number(y)).toBe(1.2);
+
 });
 
 test('number as string - 102', () => {
-    expect(utils.clean.number(z)).toBe(102);
+
+	expect(utils.clean.number(z)).toBe(102);
+
 });
 
 test('number - string to 102', () => {
-    expect(utils.clean.number(z, { required: true })).toBe(102);
+
+	expect(utils.clean.number(z, { required: true })).toBe(102);
+
 });
 
 test('number - string to 102.45', () => {
-    console.log(utils.clean.number(z2));
-    expect(utils.clean.number(z2, { required: true })).toBe(102.45);
+
+	console.log(utils.clean.number(z2));
+	expect(utils.clean.number(z2, { required: true })).toBe(102.45);
+
 });
 
 test('number as string - bad to null', () => {
-    expect(utils.clean.number(bad)).toBe(null);
+
+	expect(utils.clean.number(bad)).toBe(null);
+
 });
 
 test('number as string - bad to throw', () => {
-    expect(()=> utils.clean.number(bad, { required: true }) ).toThrow();
+
+	expect(()=> utils.clean.number(bad, { required: true }) ).toThrow();
+
 });
 
 test('number is too high', () => {
-    expect(()=> utils.clean.number(100, { min: 1, max: 10, required: true }) ).toThrow();
-    expect(()=> utils.clean.number(100.11, { min: 1, max: 100.1, required: true }) ).toThrow();
+
+	expect(()=> utils.clean.number(100, {
+		min: 1,
+		max: 10,
+		required: true 
+	}) ).toThrow();
+	expect(()=> utils.clean.number(100.11, {
+		min: 1,
+		max: 100.1,
+		required: true 
+	}) ).toThrow();
+
 });
 
 test('number is too low', () => {
-    expect(()=> utils.clean.number(0, { min: 1, max: 10, required: true }) ).toThrow();
-    expect(()=> utils.clean.number(1.2, { min: 1.3, max: 10, required: true }) ).toThrow();
+
+	expect(()=> utils.clean.number(0, {
+		min: 1,
+		max: 10,
+		required: true 
+	}) ).toThrow();
+	expect(()=> utils.clean.number(1.2, {
+		min: 1.3,
+		max: 10,
+		required: true 
+	}) ).toThrow();
+
 });