@awesomeness-js/utils 1.0.24 → 1.1.2

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

package/tests/clean/timestamp.test.js

@@ -1,13 +1,20 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../../index.js';
 
 test('good timestamp', () => {
-    const x = utils.clean.timestamp('2024-12-30');
-    expect(x).toBe('2024-12-30T00:00:00.000Z');
+
+	const x = utils.clean.timestamp('2024-12-30');
+
+	expect(x).toBe('2024-12-30T00:00:00.000Z');
+
 });
 
 test('bad timestamp', () => {
-    expect(utils.clean.timestamp('2024-12-32')).toBe(null);
-    expect(()=>utils.clean.timestamp('2024-12-32', { required: true })).toThrow();
+
+	expect(utils.clean.timestamp('2024-12-32')).toBe(null);
+	expect(()=>utils.clean.timestamp('2024-12-32', { required: true })).toThrow();
+
 });

package/tests/clean/uuid.test.js

@@ -1,14 +1,21 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../../index.js';
 
 test('good uuid', () => {
-    const id = utils.uuid();
-    const x = utils.clean.uuid(id);
-    expect(x).toBe(id);
+
+	const id = utils.uuid();
+	const x = utils.clean.uuid(id);
+
+	expect(x).toBe(id);
+
 });
 
 test('bad uuid', () => {
-    expect(utils.clean.uuid('2024-12-32')).toBe(null);
-    expect(()=>utils.clean.uuid('2024-12-32', { required: true })).toThrow();
+
+	expect(utils.clean.uuid('2024-12-32')).toBe(null);
+	expect(()=>utils.clean.uuid('2024-12-32', { required: true })).toThrow();
+
 });

package/tests/collectImports.test.js

@@ -0,0 +1,66 @@
+import utils from '../index.js';
+import {
+	expect, test 
+} from 'vitest';
+
+test('collectImports', () => {
+   
+	const imports = utils.collectImports('./test/collectImports.js');
+
+	const names = imports.map((i) => i.name).sort();
+
+	expect(names).toStrictEqual([
+		'test.collectImports', 
+		'test.js.some',
+		'test_css_some', 
+	]);
+
+	expect(imports.length).toBe(3);
+
+	expect(Object.keys(imports[0]).sort()).toStrictEqual([
+		'code', 
+		'fullPath', 
+		'hash',
+		'name',
+		'rootPath',
+		'type',
+	]);
+
+});
+
+
+test('collectImports - collect all imports in collectImports.js', () => {
+   
+	const imports = utils.collectImports('./test/collectImports.js',{
+		returnCode: false,
+		jsMaps: {
+			'test.js': 'app.print',
+			'test': 'app.fn',
+		},
+		cssMaps: {
+			'test': 'awesomeness',
+		},
+	});
+
+	const names = imports.map((i) => i.name).sort();
+
+
+	expect(names).toStrictEqual([
+		'app.fn.collectImports', // test.collectImports
+		'app.print.some', // test.js.some
+		'awesomeness_css_some', // test_css_some
+	]);
+
+	expect(imports.length).toBe(3);
+
+	expect(Object.keys(imports[0]).sort()).toStrictEqual([
+		//'code', 
+		'fullPath', 
+		'hash',
+		'name',
+		'rootPath',
+		'type',
+	]);
+
+});
+

package/tests/combineFiles.test.js

@@ -1,35 +1,37 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../index.js';
 
 let combineTest = utils.combineFiles('./test', 'js');
 
 let combineTest2 = utils.combineFiles('./test', 'js', { 
-	processContent: ({ content, path  }) => { 
-
-        const fnName = path.split('/')
-        .filter(x => x !== '') // remove empty strings
-        .join('.') // join with dots
-        .replaceAll('..', '.') // remove double dots
-        .replaceAll('.js', '') // remove .js
-        .replace(/^\./, '');
-
-        console.log({content, path});
-        content = content.replaceAll('export default function', `${fnName} = function`);
-        content = content.replaceAll('export default async function', `${fnName} = async function`);
-        content = content.replaceAll('export default async', `${fnName} = async`);
-        content = content.replaceAll('export default', `${fnName} =`);
-        console.log(content);
-        console.log('');
-        console.log('');
-        console.log('');
-        return content; 
-    },
+	processContent: ({
+		content, path  
+	}) => { 
+
+		const fnName = path.split('/')
+			.filter((x) => x !== '') // remove empty strings
+			.join('.') // join with dots
+			.replaceAll('..', '.') // remove double dots
+			.replaceAll('.js', '') // remove .js
+			.replace(/^\./, '');
+
+		content = content.replaceAll('export default function', `${fnName} = function`);
+		content = content.replaceAll('export default async function', `${fnName} = async function`);
+		content = content.replaceAll('export default async', `${fnName} = async`);
+		content = content.replaceAll('export default', `${fnName} =`);
+
+		return content; 
+	
+	},
 });
 
 test('combineFiles - combine all files in src/js', () => {
-    expect(combineTest).toBeDefined();
-    expect(combineTest2).toBeDefined();
-    expect(combineTest).not.toEqual(combineTest2);
-    console.log({combineTest2});
-})
+
+	expect(combineTest).toBeDefined();
+	expect(combineTest2).toBeDefined();
+	expect(combineTest).not.toEqual(combineTest2);
+
+});

package/tests/convertBytes.test.js

@@ -1,9 +1,14 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 import utils from '../index.js';
 
 let convertBytesTest = utils.convertBytes(1024);
+
 test('convertBytes 1024 => 1.00 KB', () => {
-    expect(convertBytesTest).toBeDefined();
-    expect(convertBytesTest).toEqual('1.00 KB');
+
+	expect(convertBytesTest).toBeDefined();
+	expect(convertBytesTest).toEqual('1.00 KB');
+
 });