@awesomeness-js/utils 1.0.24 → 1.1.2

package/src/decrypt.js

@@ -2,18 +2,26 @@ import { createDecipheriv } from 'crypto';
 
 export default function decrypt(encryptedData, key = process.env.AWESOMENESS_ENCRYPTION_KEY) {
 
-    if(!key){
-        throw new Error('Encryption key is not set. Please set the AWESOMENESS_ENCRYPTION_KEY environment variable.');
-    }
+	if(!key){
 
-    const { iv, authTag, cipherText } = encryptedData;
+		throw new Error('Encryption key is not set. Please set the AWESOMENESS_ENCRYPTION_KEY environment variable.');
+	
+	}
+
+	const {
+		iv, 
+		authTag, 
+		cipherText 
+	} = encryptedData;
   
-    const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(iv, 'hex'));
-    decipher.setAuthTag(Buffer.from(authTag, 'hex'));
+	const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(iv, 'hex'));
+
+	decipher.setAuthTag(Buffer.from(authTag, 'hex'));
   
-    let decrypted = decipher.update(cipherText, 'hex', 'utf8');
-    decrypted += decipher.final('utf8');
+	let decrypted = decipher.update(cipherText, 'hex', 'utf8');
+
+	decrypted += decipher.final('utf8');
   
-    return decrypted;
+	return decrypted;
 
 }

package/src/each.js

@@ -13,15 +13,37 @@ export default function each(objectOrArray, callback) {
 	if(Array.isArray(objectOrArray)){
 
 		objectOrArray.every( (v, k) => {
-			if(callback( v, k ) === false){ return false; } else { return true; }
+
+			if(callback( v, k ) === false){
+
+				return false; 
+
+			} else {
+
+				return true; 
+
+			}
+		
 		});
 
 	} else {
 
-		Object.entries(objectOrArray).every(entry => {
-			if(callback( entry[1], entry[0] ) === false){ return false; } else { return true; }
+		Object.entries(objectOrArray).every((entry) => {
+
+			if(callback( entry[1], entry[0] ) === false){
+
+				return false; 
+
+			} else {
+
+				return true; 
+
+			}
+		
 		});
 
 	}
 
-};
+}
+
+;

package/src/eachAsync.js

@@ -1,21 +1,37 @@
 export default async function eachAsync(objectOrArray, callback) {
-    if (Array.isArray(objectOrArray)) {
-        // Use a for...of loop for arrays
-        for (const [k, v] of objectOrArray.entries()) {
-            // Await the callback
-            if (await callback(v, k) === false) {
-                break;
-            }
-        }
-    } else {
-        // Use a for...in loop for objects
-        for (const k in objectOrArray) {
-            if (objectOrArray.hasOwnProperty(k)) {
-                // Await the callback
-                if (await callback(objectOrArray[k], k) === false) {
-                    break;
-                }
-            }
-        }
-    }
+
+	if (Array.isArray(objectOrArray)) {
+
+		// Use a for...of loop for arrays
+		for (const [ k, v ] of objectOrArray.entries()) {
+
+			// Await the callback
+			if (await callback(v, k) === false) {
+
+				break;
+			
+			}
+		
+		}
+	
+	} else {
+
+		// Use a for...in loop for objects
+		for (const k in objectOrArray) {
+
+			if (objectOrArray.hasOwnProperty(k)) {
+
+				// Await the callback
+				if (await callback(objectOrArray[k], k) === false) {
+
+					break;
+				
+				}
+			
+			}
+		
+		}
+	
+	}
+
 }

package/src/encrypt.js

@@ -1,29 +1,34 @@
-import { randomBytes, createCipheriv } from 'crypto';
+import {
+	randomBytes, createCipheriv 
+} from 'crypto';
 
 
 // Encrypt plaintext using AES-256-GCM
 export default function encrypt(plainText, key = process.env.AWESOMENESS_ENCRYPTION_KEY) {
 
-    if(!key){
-        throw new Error('Encryption key is not set. Please set the AWESOMENESS_ENCRYPTION_KEY environment variable.');
-    }
+	if(!key){
 
-    // GCM typically uses a 12- or 16-byte IV/nonce
-    const iv = randomBytes(12);
+		throw new Error('Encryption key is not set. Please set the AWESOMENESS_ENCRYPTION_KEY environment variable.');
+	
+	}
 
-    const cipher = createCipheriv('aes-256-gcm', key, iv);
-    let encrypted = cipher.update(plainText, 'utf8', 'hex');
-    encrypted += cipher.final('hex');
+	// GCM typically uses a 12- or 16-byte IV/nonce
+	const iv = randomBytes(12);
 
-    // GCM provides an auth tag, which is required for decryption
-    const authTag = cipher.getAuthTag().toString('hex');
+	const cipher = createCipheriv('aes-256-gcm', key, iv);
+	let encrypted = cipher.update(plainText, 'utf8', 'hex');
 
-    // Return all parts needed for safe decryption
-    return {
-        iv: iv.toString('hex'),
-        authTag,
-        cipherText: encrypted
-    };
+	encrypted += cipher.final('hex');
+
+	// GCM provides an auth tag, which is required for decryption
+	const authTag = cipher.getAuthTag().toString('hex');
+
+	// Return all parts needed for safe decryption
+	return {
+		iv: iv.toString('hex'),
+		authTag,
+		cipherText: encrypted
+	};
 
 }
 

package/src/getAllFiles.js

@@ -1,48 +1,62 @@
-import { readdirSync, statSync } from 'fs';
+import {
+	readdirSync, statSync 
+} from 'fs';
 import { join } from 'path';
-import shouldIgnore from './utils/shouldIgnore.js';
+import shouldIgnore from './shouldIgnore.js';
 
 export default function getAllFiles(base, {
-    dir = '.',
-    files = [], 
-    ignore = [],
-    fileTypes = []
+	dir = '.',
+	files = [], 
+	ignore = [],
+	fileTypes = []
 } = {}) {
 
-    const directory = join(base, dir);
-
-    const sortedFiles = readdirSync(directory).sort();
-
-    sortedFiles.forEach(file => {
-        const fullPath = join(directory, file);
-        // 1) Generate the original "relative path"
-        const relativePath = join(dir, file).replace(/\\/g, '/');
-
-        // 2) Prepend a slash so patterns like "/css/*.js" will match "/css/some.js"
-        const pathForIgnore = '/' + relativePath.replace(/^\/*/, '');
-
-        // 3) Check with the leading slash path
-        if (shouldIgnore(pathForIgnore, ignore)) {
-            return;
-        }
-
-        // Recurse if it's a directory
-        if (statSync(fullPath).isDirectory()) {
-            getAllFiles(base, {
-                dir: join(dir, file),
-                files,
-                ignore,
-                fileTypes
-            });
-        } else {
-            // Filter by file types if specified
-            if (fileTypes.length > 0 && !fileTypes.some(ext => file.endsWith(ext))) {
-                return;
-            }
-            // 4) Store the original relative path (without leading slash) in `files` if you prefer
-            files.push(relativePath);
-        }
-    });
-
-    return files;
+	const directory = join(base, dir);
+
+	const sortedFiles = readdirSync(directory).sort();
+
+	sortedFiles.forEach((file) => {
+
+		const fullPath = join(directory, file);
+		// 1) Generate the original "relative path"
+		const relativePath = join(dir, file).replace(/\\/g, '/');
+
+		// 2) Prepend a slash so patterns like "/css/*.js" will match "/css/some.js"
+		const pathForIgnore = '/' + relativePath.replace(/^\/*/, '');
+
+		// 3) Check with the leading slash path
+		if (shouldIgnore(pathForIgnore, ignore)) {
+
+			return;
+		
+		}
+
+		// Recurse if it's a directory
+		if (statSync(fullPath).isDirectory()) {
+
+			getAllFiles(base, {
+				dir: join(dir, file),
+				files,
+				ignore,
+				fileTypes
+			});
+		
+		} else {
+
+			// Filter by file types if specified
+			if (fileTypes.length > 0 && !fileTypes.some((ext) => file.endsWith(ext))) {
+
+				return;
+			
+			}
+
+			// 4) Store the original relative path (without leading slash) in `files` if you prefer
+			files.push(relativePath);
+		
+		}
+	
+	});
+
+	return files;
+
 }

package/src/ignoreFolder/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/src/ignoreMe.js

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

package/src/isUUID.js

@@ -1,4 +1,8 @@
 export default function isUUID(uuid) {
+
 	const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+	
 	return uuidV4Regex.test(uuid);
+
 }

package/src/md5.js

@@ -1,5 +1,9 @@
 import { createHash } from 'crypto';
+
 function md5(data) {
-    return createHash('md5').update(data).digest('hex');
+
+	return createHash('md5').update(data).digest('hex');
+
 }
+
 export default md5;

package/src/password/check.js

@@ -2,8 +2,12 @@ import { pbkdf2Sync } from 'crypto';
 
 // Compare a plain-text password to a stored salt+hash
 export default function validatePassword(password, storedHash) {
-  const [salt, originalHash] = storedHash.split('::');
-  const derivedKey = pbkdf2Sync(password, salt, 100000, 64, 'sha512');
-  return derivedKey.toString('hex') === originalHash;
+
+	const [ salt, originalHash ] = storedHash.split('::');
+	const derivedKey = pbkdf2Sync(password, salt, 100000, 64, 'sha512');
+
+  
+	return derivedKey.toString('hex') === originalHash;
+
 }
 

package/src/password/hash.js

@@ -1,11 +1,16 @@
-import { randomBytes, pbkdf2Sync } from 'crypto';
+import {
+	randomBytes, pbkdf2Sync 
+} from 'crypto';
 
 // Hash a password using Node.js built-in crypto (no external deps).
 export default function hashPassword(password) {
-  // Generate a random 16-byte salt
-  const salt = randomBytes(16).toString('hex');
-  // Derive a 64-byte key using PBKDF2 with 100k iterations (adjust as needed)
-  const derivedKey = pbkdf2Sync(password, salt, 100000, 64, 'sha512');
-  // Return salt and hash combined as a single string
-  return `${salt}::${derivedKey.toString('hex')}`;
+
+	// Generate a random 16-byte salt
+	const salt = randomBytes(16).toString('hex');
+	// Derive a 64-byte key using PBKDF2 with 100k iterations (adjust as needed)
+	const derivedKey = pbkdf2Sync(password, salt, 100000, 64, 'sha512');
+	// Return salt and hash combined as a single string
+
+	return `${salt}::${derivedKey.toString('hex')}`;
+
 }

package/src/setLocalEnvs.js

@@ -1,15 +1,22 @@
 import { readFile } from 'fs/promises';
+
 export default async (localSecretsPath = './secrets/local.env') => {
 
-		// get the file
+	// get the file
 	let localSecrets = await readFile(localSecretsPath, 'utf8');
 
 	// parse the file
 	let lines = localSecrets.split('\n');
+
+
 	for(let line of lines){
 
 		// skip #
-		if(line[0] === '#'){ continue; }
+		if(line[0] === '#'){
+
+			continue; 
+
+		}
 
 		let parts = line.split('=');
 
@@ -17,7 +24,9 @@ export default async (localSecretsPath = './secrets/local.env') => {
 
 			// remove \r
 			if(parts[1][parts[1].length - 1] === '\r'){
+
 				parts[1] = parts[1].substring(0, parts[1].length - 1);
+			
 			}
 			
 			// remove outside single quotes
@@ -25,14 +34,18 @@ export default async (localSecretsPath = './secrets/local.env') => {
 				parts[1][0] === "'"
 				&& parts[1][parts[1].length - 1] === "'"
 			){
+
 				parts[1] = parts[1].substring(1, parts[1].length - 1);
+			
 			}
 
 
 			
 			process.env[parts[0]] = parts[1];
+		
 		}
+	
 	}
 
 
-}
+};

package/src/shouldIgnore.js

@@ -0,0 +1,99 @@
+export default function shouldIgnore(filePath, ignorePatterns) {
+
+	const normalizePath = (p) => {
+
+		let v = String(p).replace(/\\/g, '/');      // Windows → POSIX
+
+		v = v.replace(/^\.\/+/, '');                // strip leading ./
+		v = v.replace(/\/+/g, '/');                 // collapse multiple slashes
+		// if the path includes /src/, make it relative to src
+		v = v.replace(/^.*\/src(\/|$)/, '/');       // ".../src/foo" → "/foo"
+		if (!v.startsWith('/')) v = '/' + v;        // ensure leading slash
+		// strip trailing slash except for root
+		if (v.length > 1 && v.endsWith('/')) v = v.slice(0, -1);
+		
+		return v.toLowerCase();                     // case-insensitive
+	
+	};
+
+	const normalizePattern = (p) => {
+
+		let v = String(p).replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+/g, '/');
+
+		if (!v.includes('*') && !v.includes('.') && !v.endsWith('/')) v += '/';
+		if (!v.startsWith('/')) v = '/' + v;
+		
+		return v.toLowerCase();                     // case-insensitive
+	
+	};
+
+	const pathCandidates = (() => {
+
+		const p = normalizePath(filePath);
+		const noSrc = String(filePath).replace(/\\/g, '/').replace(/^\.\/+/, '');
+		const alt = (noSrc.startsWith('/') ? noSrc : '/' + noSrc).toLowerCase();
+
+    
+		return Array.from(new Set([ p, alt ]));
+	
+	})();
+
+	const matches = (fp, pat) => {
+
+		// 1) "*.ext" anywhere
+		if (/^\/\*\.[^/]+$/.test(pat)) {
+
+			const ext = pat.slice(2); // "*.js" -> ".js"
+
+      
+			return fp.endsWith(ext);
+		
+		}
+
+		// 2) "folder/*" => only immediate children (no subfolders)
+		if (pat.endsWith('/*')) {
+
+			const base = pat.slice(0, -2);
+
+      
+			return fp.startsWith(base + '/') && !fp.slice(base.length + 1).includes('/');
+		
+		}
+
+		// 3) "folder/*.ext" => files with ext in that folder (no subfolders)
+		if (pat.includes('/*')) {
+
+			const [ base, tail ] = pat.split('/*');
+
+      
+			return fp.startsWith(base + '/') &&
+             fp.endsWith(tail) &&
+             !fp.slice(base.length + 1).includes('/');
+		
+		}
+
+		// 4) Plain directory "folder/" => whole dir + subdirs
+		if (pat.endsWith('/')) {
+
+			const base = pat.slice(0, -1);
+
+      
+			return fp === base || fp.startsWith(base + '/');
+		
+		}
+
+		// 5) Exact file
+		return fp === pat;
+	
+	};
+
+	return ignorePatterns.some((raw) => {
+
+		const pat = normalizePattern(raw);
+
+    
+		return pathCandidates.some((fp) => matches(fp, pat));
+	
+	});
+
+}

package/src/thingType.js

@@ -1,35 +1,73 @@
-import isUUID from './isUUID.js'
+import isUUID from './isUUID.js';
+
 export default (thing) => {
 
-    if (thing === undefined) { return 'undefined'; }
-    if (thing === null) { return 'null'; }
+	if (thing === undefined) {
+
+		return 'undefined'; 
+
+	}
+
+	if (thing === null) {
+
+		return 'null'; 
+
+	}
+
+	let type = typeof thing;
+
+	let same = [ 'undefined', 'null', 'boolean', 'function', 'symbol', 'bigint' ].includes(type);
+
+
+	if (same) {
+
+		return type; 
+
+	}
+
+	// array vs object
+	if (type === 'object' && thing !== null) {
+
+		type = Array.isArray(thing) ? 'array' : 'object';
+		
+		return type;
+	
+	}
+
+	// integer vs double
+	if (type === 'number') {
+
+		type = Number.isInteger(thing) ? 'integer' : 'number';
+		
+		return type;
+	
+	}
+
+	// string vs iso timestamp vs uuid
+	let is_uuid = isUUID(thing);
+
+
+	if(is_uuid){
+
+		type = 'uuid'; 
+
+		return type; 
+
+	}
 
-    let type = typeof thing;
+	let is_iso_dateTime = thing && typeof thing === 'string' && thing.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$/);
 
-    let same = ['undefined', 'null', 'boolean', 'function', 'symbol', 'bigint'].includes(type);
-    if (same) { return type; }
 
-    // array vs object
-    if (type === 'object' && thing !== null) {
-        type = Array.isArray(thing) ? 'array' : 'object';
-        return type;
-    }
+	if(is_iso_dateTime) {
 
-    // integer vs double
-    if (type === 'number') {
-        type = Number.isInteger(thing) ? 'integer' : 'number';
-        return type;
-    }
+		type = 'timestamp'; 
 
-    // string vs iso timestamp vs uuid
-    let is_uuid = isUUID(thing);
-    if(is_uuid){ type = 'uuid'; return type; }
+		return type; 
 
-    let is_iso_dateTime = thing && typeof thing === 'string' && thing.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$/);
-    if(is_iso_dateTime) { type = 'timestamp'; return type; }
+	}
 
-    return type;
+	return type;
 
-    
-}
+	
+};
 

package/src/toPennies.js

@@ -1,7 +1,16 @@
 export default function toPennies(uglyMoney){
 
-	if(!uglyMoney){ return 0; }
-	if(uglyMoney.length == 0){ return 0; }
+	if(!uglyMoney){
+
+		return 0; 
+
+	}
+
+	if(uglyMoney.length == 0){
+
+		return 0; 
+
+	}
 
 	// trim all whitespace from string
 	uglyMoney = uglyMoney.replace(/\s/g,'');
@@ -9,11 +18,20 @@ export default function toPennies(uglyMoney){
 	let hasDecimal = uglyMoney.includes(".");
 	let cleanMoney_v1 = uglyMoney.replace(/\D/g,'');
 
-	if(cleanMoney_v1.length == 0){ return 0; }
+	if(cleanMoney_v1.length == 0){
+
+		return 0; 
+
+	}
 
 	let cleanMoney = cleanMoney_v1*1;
 
-	if(!hasDecimal){ cleanMoney = cleanMoney * 100; }
+	if(!hasDecimal){
+
+		cleanMoney = cleanMoney * 100; 
+
+	}
 
 	return cleanMoney;
-};
+
+}