@awesomeness-js/utils 1.0.24 → 1.0.25

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();
+
 });
 

package/tests/clean/object.test.js

@@ -1,172 +1,243 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../../index.js';
 
 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 invalidTestObject = {
-    stringProp: 123, // should be a string
-    integerProp: 'not an integer', // should be an integer
-    numberProp: 'not a number', // should be a number
-    booleanProp: 'not a boolean', // should be a boolean
-    timestampProp: 'not a timestamp', // should be a timestamp
-    uuidProp: 'not a uuid', // should be a uuid
-    optionalStringProp: 456, // should be a string
-    optionalIntegerProp: 'not an integer', // should be an integer
-    optionalNumberProp: 'not a number', // should be a number
-    optionalBooleanProp: 'not a boolean', // should be a boolean
-    optionalTimestampProp: 'not a timestamp', // should be a timestamp
-    optionalUuidProp: 'not a uuid' // should be a uuid
+	stringProp: 123, // should be a string
+	integerProp: 'not an integer', // should be an integer
+	numberProp: 'not a number', // should be a number
+	booleanProp: 'not a boolean', // should be a boolean
+	timestampProp: 'not a timestamp', // should be a timestamp
+	uuidProp: 'not a uuid', // should be a uuid
+	optionalStringProp: 456, // should be a string
+	optionalIntegerProp: 'not an integer', // should be an integer
+	optionalNumberProp: 'not a number', // should be a number
+	optionalBooleanProp: 'not a boolean', // should be a boolean
+	optionalTimestampProp: 'not a timestamp', // should be a timestamp
+	optionalUuidProp: 'not a uuid' // should be a uuid
 };
 
 const testObject2 = {
-    obj1: { ...testObject },
-    obj2: { ...testObject }
+	obj1: { ...testObject },
+	obj2: { ...testObject }
 };
 
 const invalidTestObject2 = {
-    obj1: { ...invalidTestObject },
-    obj2: { ...invalidTestObject }
+	obj1: { ...invalidTestObject },
+	obj2: { ...invalidTestObject }
 };
 
 const schema = {
-    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 schema2 = {
-    type: 'object',
-    properties: {
-        obj1: {
-            type: 'object',
-            required: true,
-            properties: { ... schema.properties }
-        },
-        obj2: {
-            type: 'object',
-            required: true,
-            properties: { ... schema.properties }
-        }
-    },
+	type: 'object',
+	properties: {
+		obj1: {
+			type: 'object',
+			required: true,
+			properties: { ... schema.properties }
+		},
+		obj2: {
+			type: 'object',
+			required: true,
+			properties: { ... schema.properties }
+		}
+	},
 };
 
 
 const testArraysOfIntegers = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9]
+	[ 1, 2, 3 ],
+	[ 4, 5, 6 ],
+	[ 7, 8, 9 ]
 ];
 
 const testStringArrayOfArrays = [
-    ['a', 'b', 'c'],
-    ['d', 'e', 'f'],
-    ['g', 'h', 'i'],
+	[ 'a', 'b', 'c' ],
+	[ 'd', 'e', 'f' ],
+	[ 'g', 'h', 'i' ],
 ];
 
 const testArrayOfBooleans = [
-    [true, false, true],
-    [false, true, false],
-    [true, true, false]
+	[ true, false, true ],
+	[ false, true, false ],
+	[ true, true, false ]
 ];
 
 const objectOfArrays = {
-    testArraysOfIntegers: [...testArraysOfIntegers],
-    testStringArrayOfArrays: [...testStringArrayOfArrays],
-    testArrayOfBooleans: [...testArrayOfBooleans],
+	testArraysOfIntegers: [ ...testArraysOfIntegers ],
+	testStringArrayOfArrays: [ ...testStringArrayOfArrays ],
+	testArrayOfBooleans: [ ...testArrayOfBooleans ],
 };
 
 const objectOfArrays_schema = {
-    type: 'object',
-    properties: {
-        testArraysOfIntegers: {
-            type: 'array',
-            items: {
-                type: 'array',
-                items: { type: 'integer' }
-            }
-        },
-        testStringArrayOfArrays: {
-            type: 'array',
-            items: {
-                type: 'array',
-                items: { type: 'string' }
-            }
-        },
-        testArrayOfBooleans: {
-            type: 'array',
-            items: {
-                type: 'array',
-                items: { type: 'boolean' }
-            }
-        }
-    }
+	type: 'object',
+	properties: {
+		testArraysOfIntegers: {
+			type: 'array',
+			items: {
+				type: 'array',
+				items: { type: 'integer' }
+			}
+		},
+		testStringArrayOfArrays: {
+			type: 'array',
+			items: {
+				type: 'array',
+				items: { type: 'string' }
+			}
+		},
+		testArrayOfBooleans: {
+			type: 'array',
+			items: {
+				type: 'array',
+				items: { type: 'boolean' }
+			}
+		}
+	}
 };
 
 test('testObject', () => {
-    try {
-        const cleanedObject = utils.clean.object(testObject, schema);
-        expect(cleanedObject).toStrictEqual(testObject);
-    } catch (error) {
-        console.error('Error cleaning object:', error);
-        throw error; // rethrow to fail the test
-    }
+
+	try {
+
+		const cleanedObject = utils.clean.object(testObject, schema);
+
+		expect(cleanedObject).toStrictEqual(testObject);
+	
+	} catch (error) {
+
+		console.error('Error cleaning object:', error);
+
+		throw error; // rethrow to fail the test
+	
+	}
+
 });
 
 test('invalidTestObject', () => {
-    try {
-        const cleanedObject = utils.clean.object(invalidTestObject, schema);
-        //console.log({ cleanedObject })
-        expect(cleanedObject).toStrictEqual(invalidTestObject);
-    } catch (error) {
-        //console.error('Error cleaning object:', error);
-        expect(error.message).toBe('type invalid');
-    }
+
+	try {
+
+		const cleanedObject = utils.clean.object(invalidTestObject, schema);
+		//console.log({ cleanedObject })
+
+		expect(cleanedObject).toStrictEqual(invalidTestObject);
+	
+	} catch (error) {
+
+		//console.error('Error cleaning object:', error);
+		expect(error.message).toBe('type invalid');
+	
+	}
+
 });
 
 test('testObject2', () => {
-    try {
-        const cleanedObject = utils.clean.object(testObject2, schema2);
-        //console.log('cleanedObject', cleanedObject);
-        expect(cleanedObject).toStrictEqual(testObject2);
-    } catch (error) {
-        console.error('Error cleaning object:', error);
-        throw error; // rethrow to fail the test
-    }
+
+	try {
+
+		const cleanedObject = utils.clean.object(testObject2, schema2);
+		//console.log('cleanedObject', cleanedObject);
+
+		expect(cleanedObject).toStrictEqual(testObject2);
+	
+	} catch (error) {
+
+		console.error('Error cleaning object:', error);
+
+		throw error; // rethrow to fail the test
+	
+	}
+
 });
 
 
 test('incorrect should throw', () => {
-    expect(()=> utils.clean.object(testObject, schema2)).toThrow();
+
+	expect(()=> utils.clean.object(testObject, schema2)).toThrow();
+
 });
 
 
 test('object of arrays test', () => {
-    try {
-        const cleanedObject = utils.clean.object(objectOfArrays, objectOfArrays_schema);
-        //console.log('cleanedObject', cleanedObject);
-        expect(cleanedObject).toStrictEqual(objectOfArrays);
-    } catch (error) {
-        console.error('Error cleaning object:', error);
-        throw error; // rethrow to fail the test
-    }
+
+	try {
+
+		const cleanedObject = utils.clean.object(objectOfArrays, objectOfArrays_schema);
+		//console.log('cleanedObject', cleanedObject);
+
+		expect(cleanedObject).toStrictEqual(objectOfArrays);
+	
+	} catch (error) {
+
+		console.error('Error cleaning object:', error);
+
+		throw error; // rethrow to fail the test
+	
+	}
+
 });

package/tests/clean/string.test.js

@@ -1,44 +1,75 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../../index.js';
 
 test('good string', () => {
-    expect(utils.clean.string('good string')).toBe('good string');
+
+	expect(utils.clean.string('good string')).toBe('good string');
+
 });
 
 test('number', () => {
-    expect(utils.clean.string(123)).toBe(null);
-    expect(()=> utils.clean.string(123, { required: true })).toThrow();
+
+	expect(utils.clean.string(123)).toBe(null);
+	expect(()=> utils.clean.string(123, { required: true })).toThrow();
+
 });
 
 test('string too short', () => {
-    expect(utils.clean.string('123456789', { minLength: 10 })).toBe(null);
-    expect(()=> utils.clean.string('123456789', { minLength: 10, required: true })).toThrow();
+
+	expect(utils.clean.string('123456789', { minLength: 10 })).toBe(null);
+	expect(()=> utils.clean.string('123456789', {
+		minLength: 10,
+		required: true 
+	})).toThrow();
+
 });
 
 test('string too long', () => {
-    expect(utils.clean.string('123456789', { maxLength: 5 })).toBe(null);
-    expect(()=> utils.clean.string('123456789', { maxLength: 5, required: true })).toThrow();
+
+	expect(utils.clean.string('123456789', { maxLength: 5 })).toBe(null);
+	expect(()=> utils.clean.string('123456789', {
+		maxLength: 5,
+		required: true 
+	})).toThrow();
+
 });
 
 test('no html', () => {
-    expect(utils.clean.string('<div>no go</div>')).toBe(null);
-    expect(()=> utils.clean.string('<div>no go</div>', { required: true })).toThrow();
+
+	expect(utils.clean.string('<div>no go</div>')).toBe(null);
+	expect(()=> utils.clean.string('<div>no go</div>', { required: true })).toThrow();
+
 });
 
 test('no script', () => {
-    expect(utils.clean.string('<script>no go</script>')).toBe(null);
-    expect(()=> utils.clean.string('<script>no go</script>', { required: true })).toThrow();
+
+	expect(utils.clean.string('<script>no go</script>')).toBe(null);
+	expect(()=> utils.clean.string('<script>no go</script>', { required: true })).toThrow();
+
 });
 
 test('allow html', () => {
-    let x = utils.clean.string('<div>all good/div>', { allowHtml: true });
-    expect(utils.clean.string('<div>all good</div>', { allowHtml: true })).toBe('<div>all good</div>');
-    expect(utils.clean.string('<div>all good</div>', { allowHtml: true, required: true })).toBe('<div>all good</div>');
+
+	let x = utils.clean.string('<div>all good/div>', { allowHtml: true });
+
+	expect(utils.clean.string('<div>all good</div>', { allowHtml: true })).toBe('<div>all good</div>');
+	expect(utils.clean.string('<div>all good</div>', {
+		allowHtml: true,
+		required: true 
+	})).toBe('<div>all good</div>');
+
 });
 
 test('allow script', () => {
-    expect(utils.clean.string('<script>all good</script>', { allowScripts: true })).toBe('<script>all good</script>');
-    expect(utils.clean.string('<script>all good</script>', { allowScripts: true, required: true })).toBe('<script>all good</script>');
+
+	expect(utils.clean.string('<script>all good</script>', { allowScripts: true })).toBe('<script>all good</script>');
+	expect(utils.clean.string('<script>all good</script>', {
+		allowScripts: true,
+		required: true 
+	})).toBe('<script>all good</script>');
+
 });