@awesomeness-js/utils 1.0.24 → 1.0.25

package/src/collectImports.js

@@ -0,0 +1,195 @@
+import fs from 'fs';
+import path from 'path';
+import md5 from './md5.js';
+import each from './each.js';
+
+
+function collectImports(filePath, seen = new Set(), collected = []) {
+  
+	const fullPath = path.resolve(filePath);
+ 
+	if (seen.has(fullPath)) return;
+	seen.add(fullPath);
+
+	const code = fs.readFileSync(fullPath, 'utf-8');
+	const hash = md5(code);
+
+	collected.push({ 
+		fullPath, 
+		hash,
+		code,
+	});
+
+	const importRegex = /import\s+.*?['"](.+?)['"];?/g;
+	let match;
+
+	while ((match = importRegex.exec(code)) !== null) {
+
+		const importPath = match[1];
+
+		// Skip package imports (non-relative paths)
+		if (!importPath.startsWith('.')) continue;
+
+		const resolved = resolveImport(path.dirname(fullPath), importPath);
+
+		if (resolved) collectImports(resolved, seen, collected);
+	
+	}
+
+	return collected;
+
+}
+
+function findProjectRoot(from = process.cwd()) {
+
+	let currentPath = from;
+
+	while (true) {
+
+		if (fs.existsSync(path.join(currentPath, 'package.json'))) {
+
+			return currentPath;
+		
+		}
+
+		const parent = path.dirname(currentPath);
+
+
+		if (parent === currentPath) {
+
+			throw new Error('Project root not found (no package.json)');
+		
+		}
+
+		currentPath = parent;
+	
+	}
+
+}
+
+
+function resolveImport(baseDir, importPath) {
+
+	const candidates = [
+		importPath,
+		`${importPath}.js`,
+		`${importPath}.css`,
+		path.join(importPath, 'index.js'),
+		path.join(importPath, 'index.css'),
+	];
+
+	for (const candidate of candidates) {
+
+		const full = path.resolve(baseDir, candidate);
+
+
+		if (fs.existsSync(full) && fs.statSync(full).isFile()) {
+
+			return full;
+		
+		}
+	
+	}
+
+	return null;
+
+}
+
+function jsName( file ){
+
+	return file.rootPath
+		.replace('.'+file.type, '')
+		.replaceAll('/', '.');
+
+}
+
+function cssName( file ){
+
+	return file.rootPath
+		.replace('.'+file.type, '')
+		.replaceAll('/', '_');
+
+}
+
+function run(filePath, {
+	returnCode = true,
+	jsMaps = {},
+	cssMaps = {}
+} = {}){
+
+	const root = findProjectRoot(__dirname);
+
+	const imports = collectImports(filePath);
+
+	imports.forEach((file) => {
+    
+		const rootPath = path.relative(root, file.fullPath).replace(/\\/g, '/');
+
+		file.rootPath = rootPath;
+
+		// strip file type
+		const fileType = rootPath.split('.').pop();
+
+		file.type = fileType;
+
+		if(fileType === 'js'){
+      
+			file.name = jsName(file);
+
+			if(Object.keys(jsMaps).length){
+        
+				each(jsMaps,( v, k ) => {
+
+					file.name = file.name.replace(k.replace(/\.\//g, ''),v);
+				
+				});
+
+			}
+
+			if(returnCode){
+
+				file.code = file.code.replace(/import\s+.*?['"](.+?)['"];?/g, '').replace('export default', `${file.name} =`);
+			
+			} else {
+
+				delete file.code;
+			
+			}
+      
+
+		}
+
+		if(fileType === 'css'){
+
+			file.name = cssName(file);
+
+			if(Object.keys(cssMaps).length){
+        
+				each(cssMaps,( v, k ) => {
+
+					file.name = file.name.replace(k.replace(/\.\//g, ''),v);
+				
+				});
+
+			}
+
+			if(returnCode){
+
+				file.code = file.code.replace(/import\s+.*?['"](.+?)['"];?/g, '');
+			
+			} else {
+
+				delete file.code;
+			
+			}
+
+
+		}
+
+	});
+
+	return imports;
+
+}
+
+export default run;

package/src/combineFiles.js

@@ -1,66 +1,75 @@
 // main-module/index.js
-import { readdirSync, statSync, readFileSync } from 'fs';
+import {
+	readdirSync, statSync, readFileSync 
+} from 'fs';
 
 function combineFiles(dir, fileType, {
 	minify = false,
-	processContent = ({ content, path  }) => { return content; },
+	processContent = ({
+		content, path  
+	}) => {
+
+		return content; 
+
+	},
 } = {}) {
 
-		var returnString = "";
+	var returnString = "";
 
-		let stuff = readdirSync(dir);
+	let stuff = readdirSync(dir);
 
-		// sort it
-		stuff = stuff.sort();
+	// sort it
+	stuff = stuff.sort();
 		
 
-		stuff.forEach(stuff => {
+	stuff.forEach((stuff) => {
 
-			const isDir = statSync(`${dir}/${stuff}`).isDirectory();
+		const isDir = statSync(`${dir}/${stuff}`).isDirectory();
 			
-			if(isDir){
+		if(isDir){
 
-				returnString += combineFiles(`${dir}/${stuff}`, fileType, {
-					minify,
-					processContent,
-				});  
+			returnString += combineFiles(`${dir}/${stuff}`, fileType, {
+				minify,
+				processContent,
+			});  
 
-			} else {
+		} else {
 
-				// is file
+			// is file
 
-				// get file and extension from stuff
-				let file = stuff.split('.');
-				let ext = file[file.length - 1];
+			// get file and extension from stuff
+			let file = stuff.split('.');
+			let ext = file[file.length - 1];
 
 
-				if(ext === fileType){
+			if(ext === fileType){
 					
-					let thisData = readFileSync(`${dir}/${stuff}`, 'utf8');
-
-					if(typeof processContent === 'function'){
-
-						thisData = processContent({
-							path: `${dir}/${stuff}`,
-							content: thisData,
-						});
+				let thisData = readFileSync(`${dir}/${stuff}`, 'utf8');
 
-					}
+				if(typeof processContent === 'function'){
 
-					if(minify){
-						// todo
-					}
+					thisData = processContent({
+						path: `${dir}/${stuff}`,
+						content: thisData,
+					});
 
-					returnString += thisData + " \n ";
+				}
 
+				if(minify){
+					// todo
 				}
 
+				returnString += thisData + " \n ";
+
 			}
 
-		});
+		}
+
+	});
+
+	return returnString;
 
-		return returnString;
+}
 
-	};
 
-	export default combineFiles;
+export default combineFiles;

package/src/convertBytes.js

@@ -7,10 +7,15 @@
  * @returns {string} The converted bytes in a string format with appropriate units.
  */
 export default function convertBytes(bytes, precision = 2) {
-    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-    bytes = Math.max(bytes, 0);
-    const pow = Math.floor((bytes ? Math.log(bytes) : 0) / Math.log(1024));
-    const index = Math.min(pow, units.length - 1);
-    bytes /= 2 ** (10 * pow);
-    return `${bytes.toFixed(precision)} ${units[index]}`;
-};
+
+	const units = [ 'B', 'KB', 'MB', 'GB', 'TB' ];
+
+	bytes = Math.max(bytes, 0);
+	const pow = Math.floor((bytes ? Math.log(bytes) : 0) / Math.log(1024));
+	const index = Math.min(pow, units.length - 1);
+
+	bytes /= 2 ** (10 * pow);
+	
+	return `${bytes.toFixed(precision)} ${units[index]}`;
+
+}

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