@awesomeness-js/utils 1.0.24 → 1.1.2

package/src/clean/string.js

@@ -1,72 +1,96 @@
 export default function cleanString(x, {
-    required = false,
-    minLength = false,
-    maxLength = false,
-    allowHtml = false,
-    allowScripts = false,
-    validValues = false
+	required = false,
+	minLength = false,
+	maxLength = false,
+	allowHtml = false,
+	allowScripts = false,
+	validValues = false
 } = {}){
 
-    if(allowScripts && !allowHtml){ allowHtml = true; }
-    
-    try {
-
-        if(typeof x !== 'string') {
-            throw {
-                name: 'TypeError',
-                message: 'Input must be a string',
-                value: x
-            };
-        }
-
-        if(minLength !== false && x.length < minLength) {
-            throw {
-                message: `String length must be between ${minLength} `,
-                length: x.length,
-                value: x
-            };
-        }
-
-        if(maxLength !== false && x.length > maxLength) {
-            throw {
-                message: `String length must be less than or equal to ${maxLength}`,
-                length: x.length,
-                value: x
-            };
-        }
-
-        if(!allowHtml && /<[^>]*>/g.test(x)) {
-            throw {
-                message: 'HTML tags are not allowed',
-                value: x
-            };
-        }
-
-        if(!allowScripts && /<script[^>]*>.*<\/script>/g.test(x)) {
-            throw {
-                message: 'Script tags are not allowed',
-                value: x
-            };
-        }
-
-        if( 
-            validValues
-            && Array.isArray(validValues) 
-            && !validValues.includes(x) 
-        ) {
-            throw {
-                message: `Value invalid`,
-                validValues,
-                value: x
-            };
-        }
-
-        return x;
-
-    } catch (e) {
-
-        if(required) { throw e; } else { return null; }
-        
-    }
+	if(allowScripts && !allowHtml){
+
+		allowHtml = true; 
+
+	}
+	
+	try {
+
+		if(typeof x !== 'string') {
+
+			throw {
+				name: 'TypeError',
+				message: 'Input must be a string',
+				value: x
+			};
+		
+		}
+
+		if(minLength !== false && x.length < minLength) {
+
+			throw {
+				message: `String length must be between ${minLength} `,
+				length: x.length,
+				value: x
+			};
+		
+		}
+
+		if(maxLength !== false && x.length > maxLength) {
+
+			throw {
+				message: `String length must be less than or equal to ${maxLength}`,
+				length: x.length,
+				value: x
+			};
+		
+		}
+
+		if(!allowHtml && /<[^>]*>/g.test(x)) {
+
+			throw {
+				message: 'HTML tags are not allowed',
+				value: x
+			};
+		
+		}
+
+		if(!allowScripts && /<script[^>]*>.*<\/script>/g.test(x)) {
+
+			throw {
+				message: 'Script tags are not allowed',
+				value: x
+			};
+		
+		}
+
+		if( 
+			validValues
+			&& Array.isArray(validValues) 
+			&& !validValues.includes(x) 
+		) {
+
+			throw {
+				message: `Value invalid`,
+				validValues,
+				value: x
+			};
+		
+		}
+
+		return x;
+
+	} catch (e) {
+
+		if(required) {
+
+			throw e; 
+
+		} else {
+
+			return null; 
+
+		}
+		
+	}
 
 }

package/src/clean/timestamp.js

@@ -1,50 +1,66 @@
 export default function cleanTimestamp( isoDateTimeString , {
-    required = false,
-    maxDaysInFuture = false,
-    maxDaysInFPast = false,
+	required = false,
+	maxDaysInFuture = false,
+	maxDaysInFPast = false,
 } = {}){
-    
-    try {
-
-        if(typeof isoDateTimeString !== 'string') {
-            throw {
-                message: 'Input must be a string',
-                isoDateTimeString
-            };
-        }
-    
-        const date = new Date(isoDateTimeString);
-    
-        if(isNaN(date.getTime())) {
-            throw {
-                message: 'Invalid date string',
-                isoDateTimeString
-            };
-        }
-    
-        const now = new Date();
-        
-        if(maxDaysInFuture !== false && (date - now) > maxDaysInFuture * 24 * 60 * 60 * 1000) {
-            throw {
-                message: `Date is more than ${maxDaysInFuture} days in the future`,
-                isoDateTimeString
-            };
-        }
-    
-        if(maxDaysInFPast !== false && (now - date) > maxDaysInFPast * 24 * 60 * 60 * 1000) {
-            throw {
-                message: `Date is more than ${maxDaysInFPast} days in the past`,
-                value: isoDateTimeString
-            };
-        }
-    
-        return date.toISOString();
-
-    } catch (e) {
-
-        if(required) { throw e; } else { return null; }
-        
-    }
+	
+	try {
+
+		if(typeof isoDateTimeString !== 'string') {
+
+			throw {
+				message: 'Input must be a string',
+				isoDateTimeString
+			};
+		
+		}
+	
+		const date = new Date(isoDateTimeString);
+	
+		if(isNaN(date.getTime())) {
+
+			throw {
+				message: 'Invalid date string',
+				isoDateTimeString
+			};
+		
+		}
+	
+		const now = new Date();
+		
+		if(maxDaysInFuture !== false && (date - now) > maxDaysInFuture * 24 * 60 * 60 * 1000) {
+
+			throw {
+				message: `Date is more than ${maxDaysInFuture} days in the future`,
+				isoDateTimeString
+			};
+		
+		}
+	
+		if(maxDaysInFPast !== false && (now - date) > maxDaysInFPast * 24 * 60 * 60 * 1000) {
+
+			throw {
+				message: `Date is more than ${maxDaysInFPast} days in the past`,
+				value: isoDateTimeString
+			};
+		
+		}
+	
+		return date.toISOString();
+
+	} catch (e) {
+
+		if(required) {
+
+			throw e; 
+
+		} else {
+
+			return null; 
+
+		}
+		
+	}
 
   
 

package/src/clean/uuid.js

@@ -1,31 +1,44 @@
 import isUUID from "../isUUID.js";
+
 export default function cleanUUID(uuid,{
-    required = false,
+	required = false,
 } = {}){
-    
-    try {
-            
-        if(typeof uuid !== 'string'){
-            throw {
-                message: 'Input must be a string',
-                uuid
-            };
-        }
-
-        if(!isUUID(uuid)){
-            throw {
-                message: 'Invalid UUID format',
-                uuid
-            };
-        }
-
-        return uuid;
-
-    } catch (e) {
-
-        if(required) { throw e; } else { return null; }
-
-    }
+	
+	try {
+			
+		if(typeof uuid !== 'string'){
+
+			throw {
+				message: 'Input must be a string',
+				uuid
+			};
+		
+		}
+
+		if(!isUUID(uuid)){
+
+			throw {
+				message: 'Invalid UUID format',
+				uuid
+			};
+		
+		}
+
+		return uuid;
+
+	} catch (e) {
+
+		if(required) {
+
+			throw e; 
+
+		} else {
+
+			return null; 
+
+		}
+
+	}
 
 
 

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]}`;
+
+}