@awesomeness-js/utils 1.0.24 → 1.0.25

package/src/utils/shouldIgnore.js

@@ -1,43 +1,63 @@
 export default function shouldIgnore(filePath, ignorePatterns) {
-    // filePath is already something like "/css/some.js" 
-    return ignorePatterns.some(pattern => {
-        // pattern might be "/css/*.js" or "/ignoreFolder", etc.
-        let normalizedPattern = pattern.replace(/\\/g, '/');
-
-        // 1) Full directory ignore: "/ignoreFolder" => ignore "/ignoreFolder" + subdirectories
-        //    If the pattern ends with "/", treat it as a directory path.
-        if (!normalizedPattern.includes('*')) {
-            // e.g. "/ignoreFolder/"
-            if (normalizedPattern.endsWith('/')) {
-                normalizedPattern = normalizedPattern.slice(0, -1); // remove trailing slash
-            }
-            return filePath === normalizedPattern || filePath.startsWith(normalizedPattern + '/');
-        }
-
-        // 2) folder/* => Ignore all immediate children in that folder (no subfolders)
-        if (normalizedPattern.endsWith('/*')) {
-            const baseFolder = normalizedPattern.slice(0, -2); // e.g. "/css"
-            // e.g. filePath === "/css/some.js" => startsWith("/css/")
-            // But also ensure there's no further subfolder.
-            return filePath.startsWith(baseFolder + '/') &&
+
+	// filePath is already something like "/css/some.js" 
+	return ignorePatterns.some((pattern) => {
+
+		// pattern might be "/css/*.js" or "/ignoreFolder", etc.
+		let normalizedPattern = pattern.replace(/\\/g, '/');
+
+		// 1) Full directory ignore: "/ignoreFolder" => ignore "/ignoreFolder" + subdirectories
+		//    If the pattern ends with "/", treat it as a directory path.
+		if (!normalizedPattern.includes('*')) {
+
+			// e.g. "/ignoreFolder/"
+			if (normalizedPattern.endsWith('/')) {
+
+				normalizedPattern = normalizedPattern.slice(0, -1); // remove trailing slash
+			
+			}
+
+			return filePath === normalizedPattern || filePath.startsWith(normalizedPattern + '/');
+		
+		}
+
+		// 2) folder/* => Ignore all immediate children in that folder (no subfolders)
+		if (normalizedPattern.endsWith('/*')) {
+
+			const baseFolder = normalizedPattern.slice(0, -2); // e.g. "/css"
+			// e.g. filePath === "/css/some.js" => startsWith("/css/")
+			// But also ensure there's no further subfolder.
+
+			return filePath.startsWith(baseFolder + '/') &&
                    !filePath.slice(baseFolder.length + 1).includes('/');
-        }
-
-        // 3) *.ext => extension-based ignore (any folder)
-        if (normalizedPattern.startsWith('*.')) {
-            const ext = normalizedPattern.slice(1); // remove '*'
-            return filePath.endsWith(ext);
-        }
-
-        // 4) folder/*.ext => only files with that extension in that folder (no subfolders)
-        if (normalizedPattern.includes('/*')) {
-            const [baseFolder, ext] = normalizedPattern.split('/*');
-            return filePath.startsWith(baseFolder + '/') &&
+		
+		}
+
+		// 3) *.ext => extension-based ignore (any folder)
+		if (normalizedPattern.startsWith('*.')) {
+
+			const ext = normalizedPattern.slice(1); // remove '*'
+
+            
+			return filePath.endsWith(ext);
+		
+		}
+
+		// 4) folder/*.ext => only files with that extension in that folder (no subfolders)
+		if (normalizedPattern.includes('/*')) {
+
+			const [ baseFolder, ext ] = normalizedPattern.split('/*');
+
+            
+			return filePath.startsWith(baseFolder + '/') &&
                    filePath.endsWith(ext) &&
                    !filePath.slice(baseFolder.length + 1).includes('/');
-        }
+		
+		}
+
+		// 5) Exact match
+		return filePath === normalizedPattern;
+	
+	});
 
-        // 5) Exact match
-        return filePath === normalizedPattern;
-    });
 }

package/src/uuid.js

@@ -2,15 +2,17 @@ import crypto from 'crypto';
 
 // V4
 function uuid() {
-  const arr = crypto.randomBytes(16);
 
-  // Set the UUID version and clock sequence bits as per RFC4122
-  arr[6] = (arr[6] & 0x0f) | 0x40;
-  arr[8] = (arr[8] & 0x3f) | 0x80;
+	const arr = crypto.randomBytes(16);
+
+	// Set the UUID version and clock sequence bits as per RFC4122
+	arr[6] = (arr[6] & 0x0f) | 0x40;
+	arr[8] = (arr[8] & 0x3f) | 0x80;
+
+	return [ ...arr ].map((b, i) =>
+		[ 4, 6, 8, 10 ].includes(i) ? '-' + b.toString(16).padStart(2, '0') : b.toString(16).padStart(2, '0')
+	).join('');
 
-  return [...arr].map((b, i) =>
-    [4, 6, 8, 10].includes(i) ? '-' + b.toString(16).padStart(2, '0') : b.toString(16).padStart(2, '0')
-  ).join('');
 }
 
 export default uuid;

package/src/validateSchema.js

@@ -2,83 +2,101 @@ import each from './each.js';
 
 function validateSchema(schema){
 
-    if(!schema){
-        throw {
-            message: 'Schema is required.',
-            schema
-        };
-    }
-
-    // ref todo
-    if(schema.ref){ return true; }
-
-    let schemaType = typeof schema;
-
-    if(schemaType !== 'object' || schema === null) {
-        throw {
-            message: 'Schema Invalid - Input must be an object',
-            schema,
-            schemaType
-        };
-    }
-
-    // object properties dont have type
-    if(!schema.type && schema.properties){ schema.type = 'object'; }
-
-    const validTypes = [
-        'array',
-        'boolean',
-        'integer',
-        'number',
-        'object',
-        'string',
-        'timestamp',
-        'uuid'
-    ];
-
-    if(!schema.type || !validTypes.includes(schema.type)) {
-        throw {
-            message: `Schema must have a valid type.`,
-            validTypes,
-            schema
-        };
-    }
-
-
-    if(schema.type === 'object') {
-
-        if(schema.properties){
-            
-            // run through each property
-            each(schema.properties, (v,k) => {
-                validateSchema(v);
-            });
-            
-        } else {
-
-            throw {
-                message: 'Object invalid - needs "properties"',
-                schema
-            }
-
-        }
-
-    }
-
-    if(schema.type === 'array') {
-
-        if(!schema.items){
-            throw {
-                message: 'Array schema must have items defined.',
-                schema
-            };
-        }
-
-        validateSchema(schema.items);
-
-    }
-
-    return true;
+	if(!schema){
+
+		throw {
+			message: 'Schema is required.',
+			schema
+		};
+	
+	}
+
+	// ref todo
+	if(schema.ref){
+
+		return true; 
+
+	}
+
+	let schemaType = typeof schema;
+
+	if(schemaType !== 'object' || schema === null) {
+
+		throw {
+			message: 'Schema Invalid - Input must be an object',
+			schema,
+			schemaType
+		};
+	
+	}
+
+	// object properties dont have type
+	if(!schema.type && schema.properties){
+
+		schema.type = 'object'; 
+
+	}
+
+	const validTypes = [
+		'array',
+		'boolean',
+		'integer',
+		'number',
+		'object',
+		'string',
+		'timestamp',
+		'uuid'
+	];
+
+	if(!schema.type || !validTypes.includes(schema.type)) {
+
+		throw {
+			message: `Schema must have a valid type.`,
+			validTypes,
+			schema
+		};
+	
+	}
+
+
+	if(schema.type === 'object') {
+
+		if(schema.properties){
+			
+			// run through each property
+			each(schema.properties, (v,k) => {
+
+				validateSchema(v);
+			
+			});
+			
+		} else {
+
+			throw {
+				message: 'Object invalid - needs "properties"',
+				schema
+			};
+
+		}
+
+	}
+
+	if(schema.type === 'array') {
+
+		if(!schema.items){
+
+			throw {
+				message: 'Array schema must have items defined.',
+				schema
+			};
+		
+		}
+
+		validateSchema(schema.items);
+
+	}
+
+	return true;
 
 }
 

package/test/collectImports.js

@@ -0,0 +1,8 @@
+import './css/some.css';
+import './js/some.js';
+
+export default () => {
+
+	console.log('collectImports.js');
+
+};

package/test/css/some.css

@@ -0,0 +1,3 @@
+.justATest {
+    background-color: aliceblue;
+}

package/test/css/some.js

@@ -0,0 +1,5 @@
+export default () => {
+
+	console.log('some.js');
+
+};

package/test/ignoreFolder/ignoreMe.js

@@ -1,3 +1,5 @@
 export default () => {
-    console.log('I should not be in the build!');
+
+	console.log('I should not be in the build!');
+
 };

package/test/ignoreFolder/ignoreMe2.js

@@ -1,3 +1,5 @@
 export default async () => {
-    console.log('I should not be in the build!');
+
+	console.log('I should not be in the build!');
+
 };

package/test/ignoreFolder2/ignoreMe.js

@@ -1,3 +1,7 @@
 export default function ignoreMeTest() {
-    console.log('I should not be in the build!');
-};
+
+	console.log('I should not be in the build!');
+
+}
+
+;

package/test/js/abc.test.js

@@ -1,6 +1,10 @@
 // example.test.js
-import { expect, test } from 'vitest'
+import {
+	expect, test 
+} from 'vitest';
 
 test('adds 2 + 3 to equal 5', () => {
-  expect(2 + 3).toBe(5)
-})
+
+	expect(2 + 3).toBe(5);
+
+});

package/test/js/some.js

@@ -0,0 +1,5 @@
+export default () => {
+
+	console.log('some.js');
+
+};

package/test/secret.test.js

@@ -3,5 +3,5 @@
 import { expect, test } from 'vitest'
 
 test('adds 2 + 3 to equal 5', () => {
-  expect(2 + 3).toBe(5)
+	expect(2 + 3).toBe(5)
 })

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